Merge 96bed9bd7e into 7c8358656a

benches/visual/insertion.bench.luau

@@ -5,7 +5,8 @@ local ReplicatedStorage = game:GetService("ReplicatedStorage")
 local jecs = require(ReplicatedStorage.Lib:Clone())
 local ecs = jecs.world()
 local mirror = require(ReplicatedStorage.mirror:Clone())
-local mcs = mirror.world()
+local mcs = mirror.World.new()
+
 
 local C1 = ecs:component()
 local C2 = ecs:component()

benches/visual/query.bench.luau

@@ -2,7 +2,7 @@
 --!native
 
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
-local Matter = require(ReplicatedStorage.DevPackages.Matter)
+local Matter = require(ReplicatedStorage.DevPackages.matter)
 local ecr = require(ReplicatedStorage.DevPackages.ecr)
 local newWorld = Matter.World.new()
 

benches/visual/remove.bench.luau

@@ -8,7 +8,7 @@ local jecs = require(ReplicatedStorage.Lib)
 local pair = jecs.pair
 local ecs = jecs.world()
 local mirror = require(ReplicatedStorage.mirror)
-local mcs = mirror.world()
+local mcs = mirror.World.new()
 
 local C1 = ecs:component()
 local C2 = ecs:entity()
@@ -32,7 +32,7 @@ return {
 	Functions = {
 		Mirror = function()
 			local m = mcs:entity()
-			for i = 1, 1000 do
+			for i = 1, 100 do
 				mcs:add(m, E3)
 				mcs:remove(m, E3)
 			end
@@ -40,7 +40,7 @@ return {
 
 		Jecs = function()
 			local j = ecs:entity()
-			for i = 1, 1000 do
+			for i = 1, 100 do
 				ecs:add(j, C3)
 				ecs:remove(j, C3)
 			end

demo/src/ReplicatedStorage/components.luau

@@ -1,5 +1,3 @@
---!strict
-local RunService = game:GetService("RunService")
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
 local jecs = require(ReplicatedStorage.ecs)
 local types = require("./types")
@@ -7,58 +5,31 @@ local types = require("./types")
 local Networked = jecs.tag()
 local NetworkedPair = jecs.tag()
 
-local InstanceMapping = jecs.component() :: jecs.Id<Instance>
-jecs.meta(InstanceMapping, jecs.OnAdd, function(component)
-	jecs.meta(component, jecs.OnAdd, function(entity, _, instance)
-		if RunService:IsServer() then
-			instance:SetAttribute("entity_server")
-		else
-			instance:SetAttribute("entity_client")
-		end
-	end)
-end)
+local Renderable = jecs.component() :: jecs.Id<Instance>
+jecs.meta(Renderable, Networked)
 
-local function networked_id(ct)
-	jecs.meta(ct, Networked)
-	return ct
-end
-local function networked_pair(ct)
-	jecs.meta(ct, NetworkedPair)
-	return ct
-end
-local function instance_mapping_id(ct)
-	jecs.meta(ct, InstanceMapping)
-	return ct
-end
 
-local Renderable = jecs.component() :: types.Id<Instance>
-local Poison = jecs.component() :: types.Id<number>
-local Health = jecs.component() :: types.Id<number>
-local Player = jecs.component() :: types.Id<Player>
-local Debuff = jecs.tag() :: types.Entity
-local Lifetime = jecs.component() :: types.Id<{
-	duration: number,
-	created: number
-}>
-local Destroy = jecs.tag()
+local Poison = jecs.component() :: jecs.Id<number>
+jecs.meta(Poison, Networked)
+
+local Health = jecs.component() :: jecs.Id<number>
+jecs.meta(Health, Networked)
+
+local Player = jecs.component() :: jecs.Id<Player>
+jecs.meta(Player, Networked)
+
 
 local components = {
-	Renderable = networked_id(instance_mapping_id(Renderable)),
-	Player = networked_id(Player),
-	Poison = networked_id(Poison),
-	Health = networked_id(Health),
-	Lifetime = networked_id(Lifetime),
-	Debuff = networked_id(Debuff),
-	Destroy = networked_id(Destroy),
-
-	-- We have to define that some builtin IDs can also be networked
-	ChildOf = networked_pair(jecs.ChildOf),
+	Renderable = Renderable,
+	Player = Player,
+	Poison = Poison,
+	Health = Health,
 
 	Networked = Networked,
 	NetworkedPair = NetworkedPair,
 }
 
-for name, component in components :: {[string]: types.Id<any> } do
+for name, component in components do
 	jecs.meta(component, jecs.Name, name)
 end
 

demo/src/ReplicatedStorage/main.client.luau

@@ -10,5 +10,4 @@ local world = observers_add(jecs.world())
 
 local systems = ReplicatedStorage.systems
 SYSTEM(world, systems.receive_replication)
-SYSTEM(world, systems.entities_delete)
 RUN(world)

demo/src/ReplicatedStorage/systems/entities_delete.luau

@@ -1,13 +0,0 @@
-
---!strict
-local ReplicatedStorage = game:GetService("ReplicatedStorage")
-local types = require(ReplicatedStorage.types)
-local ct = require(ReplicatedStorage.components)
-
-local function entities_delete(world: types.World, dt: number)
-	for e in world:each(ct.Destroy) do
-		world:delete(e)
-	end
-end
-
-return entities_delete

demo/src/ReplicatedStorage/systems/receive_replication.luau

@@ -2,51 +2,45 @@ local types = require("../types")
 local jecs = require(game:GetService("ReplicatedStorage").ecs)
 local remotes = require("../remotes")
 local collect = require("../collect")
-local components = require("../components")
+local client_ids = {}
 
 
-local client_ids: {[jecs.Entity]: jecs.Entity } = {}
+local function ecs_map_get(world, id)
+	local deserialised_id = client_ids[id]
 
-local function ecs_ensure_entity(world: jecs.World, id: jecs.Entity)
-	local e = 0
-
-	local ser_id = id
-	local deser_id = client_ids[ser_id]
-	if deser_id  then
-		if deser_id == 0 then
-			local new_id = world:entity()
-			client_ids[ser_id] = new_id
-			deser_id = new_id
-		end
-	else
-		if not world:exists(ser_id)
-			or (world:contains(ser_id) and not world:get(ser_id, jecs.Name))
-		then
-			deser_id = world:entity()
+	if not deserialised_id then
+		if world:has(id, jecs.Name) then
+			deserialised_id = world:entity(id)
 		else
-			if world:contains(ser_id) and world:get(ser_id, jecs.Name) then
-				deser_id = ser_id
-			else
-				deser_id = world:entity()
-			end
+			deserialised_id = world:entity()
 		end
-		client_ids[ser_id] = deser_id
+
+		client_ids[id] = deserialised_id
 	end
 
-	e = deser_id
+	-- local deserialised_id = client_ids[id]
+	-- if not deserialised_id then
+	-- 	if world:has(id, jecs.Name) then
+	-- 		deserialised_id = world:entity(id)
+	-- 	else
+	-- 		if world:exists(id) then
+	-- 			deserialised_id = world:entity()
+	-- 		else
+	-- 			deserialised_id = world:entity(id)
+	-- 		end
+	-- 	end
+	-- 	client_ids[id] = deserialised_id
+	-- end
 
-	return e
+	return deserialised_id
 end
 
--- local rel_render = `e{jecs.ECS_ID(rel)}v{jecs.ECS_GENERATION(rel)}`
--- local tgt_render = `e{jecs.ECS_ID(tgt)}v{jecs.ECS_GENERATION(tgt)}`
-local function ecs_deser_pairs(world, token)
-	local tokens = string.split(token, ",")
-	local rel = tonumber(tokens[1])
-	local tgt = tonumber(tokens[2])
+local function ecs_make_alive_id(world, id)
+	local rel = jecs.ECS_PAIR_FIRST(id)
+	local tgt = jecs.ECS_PAIR_SECOND(id)
 
-	rel = ecs_ensure_entity(world, rel)
-	tgt = ecs_ensure_entity(world, tgt)
+	rel = ecs_map_get(world, rel)
+	tgt = ecs_map_get(world, tgt)
 
 	return jecs.pair(rel, tgt)
 end
@@ -54,31 +48,25 @@ end
 local snapshots = collect(remotes.replication.OnClientEvent)
 
 return function(world: types.World)
-	for entity in world:each(components.Destroy) do
-		client_ids[entity] = nil
-	end
     for snapshot in snapshots do
-        for ser_id, map in snapshot do
-        	local id = tonumber(ser_id)
-            if not id then
-            	id = ecs_deser_pairs(world, ser_id)
-            else
-            	id = ecs_ensure_entity(world, id)
+        for id, map in snapshot do
+        	id = tonumber(id)
+            if jecs.IS_PAIR(id) then
+            	id = ecs_make_alive_id(world, id)
             end
 
             local set = map.set
             if set then
                 if jecs.is_tag(world, id) then
                    	for _, entity in set do
-                       	entity = ecs_ensure_entity(world, entity)
+                       	entity = ecs_map_get(world, entity)
                   		world:add(entity, id)
                    	end
                 else
-                	local t = os.clock()
 	                local values = map.values
 	                for i, entity in set do
-						entity = ecs_ensure_entity(world, entity)
-						world:set(entity, id, values[i])
+						entity = ecs_map_get(world, entity)
+                  		world:set(entity, id, values[i])
                    	end
 			    end
             end
@@ -86,12 +74,11 @@ return function(world: types.World)
             local removed = map.removed
 
             if removed then
-                for _, entity in removed do
-                    entity = ecs_ensure_entity(world, entity)
-                    if not world:contains(entity) then
+                for i, e in removed do
+                    if not world:contains(e) then
                         continue
                     end
-                    world:remove(entity, id)
+                    world:remove(e, id)
                 end
             end
         end

demo/src/ServerScriptService/main.server.luau

@@ -15,8 +15,5 @@ local systems = ServerScriptService.systems
 SYSTEM(world, systems.replication)
 SYSTEM(world, systems.players_added)
 SYSTEM(world, systems.poison_hurts)
-SYSTEM(world, systems.health_regen)
-SYSTEM(world, systems.lifetimes_expire)
 SYSTEM(world, systems.life_is_painful)
-SYSTEM(world, ReplicatedStorage.systems.entities_delete)
 RUN(world, 0)

demo/src/ServerScriptService/systems/health_regen.luau

@@ -1,15 +0,0 @@
-local ReplicatedStorage = game:GetService("ReplicatedStorage")
-local ct = require(ReplicatedStorage.components)
-local types = require(ReplicatedStorage.types)
-
-return function(world: types.World, dt: number)
-	for e in world:query(ct.Player):without(ct.Health) do
-		world:set(e, ct.Health, 100)
-	end
-
-	for e, health in world:query(ct.Health) do
-		if math.random() < 1 / 60 / 30 then
-			world:set(e, ct.Health, 100)
-		end
-	end
-end

demo/src/ServerScriptService/systems/life_is_painful.luau

@@ -1,19 +1,12 @@
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
 local ct = require(ReplicatedStorage.components)
 local types = require(ReplicatedStorage.types)
-local jecs = require(ReplicatedStorage.ecs)
 
 return function(world: types.World, dt: number)
-	if math.random() < (1 / 60 / 7) then
-		for e in world:each(ct.Health) do
-			local poison = world:entity()
-			world:add(poison, ct.Debuff)
-			world:add(poison, jecs.pair(jecs.ChildOf, e))
-			world:set(poison, ct.Poison, 10)
-			world:set(poison, ct.Lifetime, {
-				duration = 3,
-				created = os.clock()
-			})
-		end
+	for e in world:query(ct.Player):without(ct.Health) do
+		world:set(e, ct.Health, 100)
+	end
+	for e in world:query(ct.Player, ct.Health):without(ct.Poison) do
+		world:set(e, ct.Poison, 10)
 	end
 end

demo/src/ServerScriptService/systems/lifetimes_expire.luau

@@ -1,12 +0,0 @@
-
-local ReplicatedStorage = game:GetService("ReplicatedStorage")
-local ct = require(ReplicatedStorage.components)
-local types = require(ReplicatedStorage.types)
-
-return function(world: types.World, dt: number)
-	for e, lifetime in world:query(ct.Lifetime) do
-		if os.clock() > lifetime.created + lifetime.duration then
-			world:add(e, ct.Destroy)
-		end
-	end
-end

demo/src/ServerScriptService/systems/players_added.luau

@@ -12,13 +12,9 @@ return function(world: types.World, dt: number)
 
 	for entity, player in world:query(ct.Player):without(ct.Renderable) do
 		local character = player.Character
-		if not character then
-			continue
-		end
+		if character then
 		if not character.Parent then
-			continue
+			world:set(entity, ct.Renderable, character)
 		end
-
-		world:set(entity, ct.Renderable, character)
 	end
 end

demo/src/ServerScriptService/systems/poison_hurts.luau

@@ -1,18 +1,12 @@
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
 local ct = require(ReplicatedStorage.components)
-local types = require(ReplicatedStorage.types)
-local jecs = require(ReplicatedStorage.ecs)
-
-return function(world: types.World, dt: number)
-	for e, poison_tick in world:query(ct.Poison, jecs.pair(jecs.ChildOf, jecs.w)) do
-		local tgt = world:target(e, jecs.ChildOf)
-		local health = world:get(tgt, ct.Health)
-		if not health then
+return function(world, dt)
+	for e, poison, health in world:query(ct.Poison, ct.Health) do
+		local health_after_tick = health - poison * dt * 0.05
+		if health_after_tick < 0 then
+			world:remove(e, ct.Health)
 			continue
 		end
-
-		if math.random() < 1 / 60 / 1 and health > 1 then
-			world:set(tgt, ct.Health, health - 1)
-		end
+		world:set(e, ct.Health, health_after_tick)
 	end
 end

demo/src/ServerScriptService/systems/replication.luau

@@ -1,13 +1,9 @@
-
---!strict
-local Players = game:GetService("Players")
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
-local ct = require(ReplicatedStorage.components)
-local components = ct :: { [string]: jecs.Entity }
-local remotes = require(ReplicatedStorage.remotes)
+local types = require("../../ReplicatedStorage/types")
+local ct = require("../../ReplicatedStorage/components")
 local jecs = require(ReplicatedStorage.ecs)
-local collect = require(ReplicatedStorage.collect)
-local ty = require(ReplicatedStorage.types)
+local remotes = require("../../ReplicatedStorage/remotes")
+local components = ct :: {[string]: jecs.Entity }
 
 return function(world: ty.World)
 
@@ -23,10 +19,9 @@ return function(world: ty.World)
     local networked_pairs = {}
 
     for component in world:each(ct.Networked) do
-		local name = assert(world:get(component, jecs.Name), "Invalid component")
+    	local name = world:get(component, jecs.Name) :: string
 		if components[name] == nil then
-			error("Invalid component:"..name)
-
+			continue
 		end
 
         storages[component] = {}
@@ -37,30 +32,29 @@ return function(world: ty.World)
 	for relation in world:each(ct.NetworkedPair) do
 		local name = world:get(relation, jecs.Name) :: string
 		if not components[name] then
-			error("Invalid component")
+			continue
 		end
 		table.insert(networked_pairs, relation)
 	end
 
 	for _, component in networked_components do
-		local name = world:get(component, jecs.Name)
+		local name = world:get(component, jecs.Name) :: string
 		if not components[name] then
-			-- error("Invalid component")
 			error(`Networked Component (%id{component}%name{name})`)
 		end
 		local is_tag = jecs.is_tag(world, component)
 		local storage = storages[component]
 		if is_tag then
-			world:added(component, function(entity)
-				storage[entity] = true
-			end)
+		    world:added(component, function(entity)
+		        storage[entity] = true
+		    end)
 		else
-			world:added(component, function(entity, _, value)
-				storage[entity] = value
-			end)
-			world:changed(component, function(entity, _, value)
-				storage[entity] = value
-			end)
+		    world:added(component, function(entity, _, value)
+		        storage[entity] = value
+		    end)
+		    world:changed(component, function(entity, _, value)
+		        storage[entity] = value
+		    end)
 		end
 
         world:removed(component, function(entity)
@@ -70,55 +64,51 @@ return function(world: ty.World)
 
 	for _, relation in networked_pairs do
 		world:added(relation, function(entity, id, value)
-		local is_tag = jecs.is_tag(world, id)
-		local storage = storages[id]
-		if not storage then
-			storage = {}
-			storages[id] = storage
-		end
-		if is_tag then
-			storage[entity] = true
-		else
-			storage[entity] = value
-		end
-	end)
+	        local is_tag = jecs.is_tag(world, id)
+	        local storage = storages[id]
+	        if not storage then
+	            storage = {}
+	            storages[id] = storage
+	        end
+	        if is_tag then
+	            storage[entity] = true
+	        else
+	            storage[entity] = value
+	        end
+	    end)
 
-	world:changed(relation, function(entity, id, value)
-		local is_tag = jecs.is_tag(world, id)
-		if is_tag then
-			return
-		end
+	    world:changed(relation, function(entity, id, value)
+	        local is_tag = jecs.is_tag(world, id)
+	        if is_tag then
+	            return
+	        end
 
-		local storage = storages[id]
-		if not storage then
-			storage = {}
-			storages[id] = storage
-		end
+	        local storage = storages[id]
+	        if not storage then
+	            storage = {}
+	            storages[id] = storage
+	        end
 
-		storage[entity] = value
-	end)
+	        storage[entity] = value
+	    end)
 
-	world:removed(relation, function(entity, id)
-		local storage = storages[id]
-		if not storage then
-			storage = {}
-			storages[id] = storage
-		end
+	    world:removed(relation, function(entity, id)
+	        local storage = storages[id]
+	        if not storage then
+	            storage = {}
+	            storages[id] = storage
+	        end
 
-		storage[entity] = "jecs.Remove"
-	end)
+	        storage[entity] = "jecs.Remove"
+	    end)
 	end
 
-    -- local requested_snapshots = collect(remotes.request_snapshot.OnServerEvent)
     local players_added = collect(Players.PlayerAdded)
 
     return function()
         local snapshot_lazy: ty.Snapshot
         local set_ids_lazy: { jecs.Entity }
 
-        -- In the future maybe it should be requested by the player instead when they
-        -- are ready to receive the replication. Otherwise streaming could be complicated
-        -- with intances references being nil.
 		for player in players_added do
 			if not snapshot_lazy then
 				snapshot_lazy, set_ids_lazy =  {}, {}
@@ -136,7 +126,7 @@ return function(world: ty.World)
 						if is_tag then
 							set_values = table.create(entities_len, true)
 						else
-							local column = archetype.columns_map[component]
+							local column = archetype.columns[archetype.records[component]]
 							table.move(column, 1, entities_len, set_n + 1, set_values)
 						end
 
@@ -145,18 +135,10 @@ return function(world: ty.World)
 
 					local set = table.move(set_ids_lazy, 1, set_n, 1, {})
 
-					local ser_id: string = nil :: any
-
-					if jecs.IS_PAIR(component) then
-						ser_id = `{jecs.pair_first(world, component)},{jecs.pair_first(world, component)}`
-					else
-						ser_id = tostring(component)
-					end
-
-			    	snapshot_lazy[ser_id] = {
-	                    set = if set_n > 0 then set else nil,
-	                    values = if set_n > 0 then set_values else nil,
-	                }
+					snapshot_lazy[tostring(component)] = {
+					    set = if set_n > 0 then set else nil,
+					    values = if set_n > 0 then set_values else nil,
+					}
 				end
 			end
 
@@ -177,7 +159,7 @@ return function(world: ty.World)
 		            set_n += 1
 		            set_ids[set_n] = e
 		            set_values[set_n] = v or true
-		        elseif not world:contains(e) then
+		        elseif world:contains(e) then
 		            removed_n += 1
 		            removed_ids[removed_n] = e
 		        end
@@ -194,15 +176,7 @@ return function(world: ty.World)
             if dirty then
             	local removed = table.move(removed_ids, 1, removed_n, 1, {}) :: { jecs.Entity }
              	local set = table.move(set_ids, 1, set_n, 1, {}) :: { jecs.Entity }
-	            local ser_id: string = nil :: any
-
-				if jecs.IS_PAIR(component) then
-					ser_id = `{jecs.pair_first(world, component)},{jecs.pair_second(world, component)}`
-				else
-					ser_id = tostring(component)
-				end
-
-	            snapshot[ser_id] = {
+	            snapshot[tostring(component)] = {
                     set = if set_n > 0 then set else nil,
                     values = if set_n > 0 then set_values else nil,
                     removed = if removed_n > 0 then removed else nil

jecs.luau

@@ -42,18 +42,8 @@ export type Iter<T...> = (query: Query<T...>) -> () -> (Entity, T...)
 export type Query<T...> = typeof(setmetatable(
 	{} :: {
 		iter: Iter<T...>,
-		with:
-			(<a>(Query<T...>, Id<a>) -> Query<T...>)
-			& (<a, b>(Query<T...>, Id<a>, Id<b>) -> Query<T...>)
-			& (<a, b, c>(Query<T...>, Id<a>, Id<b>, Id<c>) -> Query<T...>)
-			& (<a, b, c>(Query<T...>, Id<a>, Id<b>, Id<c>) -> Query<T...>)
-			& (<a, b, c, d>(Query<T...>, Id<a>, Id<b>, Id<c>, Id) -> Query<T...>),
-		without:
-			(<a>(Query<T...>, Id<a>) -> Query<T...>)
-			& (<a, b>(Query<T...>, Id<a>, Id<b>) -> Query<T...>)
-			& (<a, b, c>(Query<T...>, Id<a>, Id<b>, Id<c>) -> Query<T...>)
-			& (<a, b, c>(Query<T...>, Id<a>, Id<b>, Id<c>) -> Query<T...>)
-			& (<a, b, c, d>(Query<T...>, Id<a>, Id<b>, Id<c>, Id) -> Query<T...>),
+		with: (self: Query<T...>, ...Id) -> Query<T...>,
+		without: (self: Query<T...>, ...Id) -> Query<T...>,
 		archetypes: (self: Query<T...>) -> { Archetype },
 		cached: (self: Query<T...>) -> Query<T...>,
 	},
@@ -449,7 +439,6 @@ end
 
 local function archetype_move(
 	entity_index: EntityIndex,
-	entity: Entity,
 	to: Archetype,
 	dst_row: i24,
 	from: Archetype,
@@ -463,58 +452,48 @@ local function archetype_move(
 	local id_types = from.types
 	local columns_map = to.columns_map
 
-	if src_row ~= last then
+	for i, column in src_columns do
+		if column == NULL_ARRAY then
+			continue
+		end
+		-- Retrieves the new column index from the source archetype's record from each component
+		-- We have to do this because the columns are tightly packed and indexes may not correspond to each other.
+		local dst_column = columns_map[id_types[i]]
+
+		-- Sometimes target column may not exist, e.g. when you remove a component.
+		if dst_column then
+			dst_column[dst_row] = column[src_row]
+		end
+
 		-- If the entity is the last row in the archetype then swapping it would be meaningless.
-
-		for i, column in src_columns do
-			if column == NULL_ARRAY then
-				continue
-			end
-			-- Retrieves the new column index from the source archetype's record from each component
-			-- We have to do this because the columns are tightly packed and indexes may not correspond to each other.
-			local dst_column = columns_map[id_types[i]]
-
-			-- Sometimes target column may not exist, e.g. when you remove a component.
-			if dst_column then
-				dst_column[dst_row] = column[src_row]
-			end
-
+		if src_row ~= last then
 			-- Swap rempves columns to ensure there are no holes in the archetype.
 			column[src_row] = column[last]
-			column[last] = nil
-		end
-
-
-		-- Move the entity from the source to the destination archetype.
-		-- Because we have swapped columns we now have to update the records
-		-- corresponding to the entities' rows that were swapped.
-
-		local e2 = src_entities[last]
-		src_entities[src_row] = e2
-
-		local sparse_array = entity_index.sparse_array
-		local record2 = sparse_array[ECS_ENTITY_T_LO(e2 :: number)]
-		record2.row = src_row
-	else
-		for i, column in src_columns do
-			if column == NULL_ARRAY then
-				continue
-			end
-			-- Retrieves the new column index from the source archetype's record from each component
-			-- We have to do this because the columns are tightly packed and indexes may not correspond to each other.
-			local dst_column = columns_map[id_types[i]]
-
-			-- Sometimes target column may not exist, e.g. when you remove a component.
-			if dst_column then
-				dst_column[dst_row] = column[src_row]
-			end
-
-			column[last] = nil
 		end
+		column[last] = nil
 	end
 
-	src_entities[last] = nil :: any
-	dst_entities[dst_row] = entity
+	local moved = #src_entities
+
+	-- Move the entity from the source to the destination archetype.
+	-- Because we have swapped columns we now have to update the records
+	-- corresponding to the entities' rows that were swapped.
+	local e1 = src_entities[src_row]
+	local e2 = src_entities[moved]
+
+	if src_row ~= moved then
+		src_entities[src_row] = e2
+	end
+
+	src_entities[moved] = nil :: any
+	dst_entities[dst_row] = e1
+
+	local sparse_array = entity_index.sparse_array
+
+	local record1 = sparse_array[ECS_ENTITY_T_LO(e1 :: number)]
+	local record2 = sparse_array[ECS_ENTITY_T_LO(e2 :: number)]
+	record1.row = dst_row
+	record2.row = src_row
 end
 
 local function archetype_append(
@@ -547,7 +526,7 @@ local function entity_move(
 	local sourceRow = record.row
 	local from = record.archetype
 	local dst_row = archetype_append(entity, to)
-	archetype_move(entity_index, entity, to, dst_row, from, sourceRow)
+	archetype_move(entity_index, to, dst_row, from, sourceRow)
 	record.archetype = to
 	record.row = dst_row
 end
@@ -765,7 +744,7 @@ local function archetype_register(world: World, archetype: Archetype)
 	local columns = archetype.columns
 	for i, component_id in archetype.types do
 		local idr = id_record_ensure(world, component_id)
-		local is_tag = bit32.btest(idr.flags, ECS_ID_IS_TAG)
+		local is_tag = bit32.band(idr.flags, ECS_ID_IS_TAG) ~= 0
 		local column = if is_tag then NULL_ARRAY else {}
 		columns[i] = column
 
@@ -2415,7 +2394,7 @@ local function world_new()
 				return entity
 			else
 				for i = eindex_max_id + 1, index do
-					eindex_sparse_array[i]= { dense = i } :: Record
+					eindex_sparse_array[i]	= { dense = i } :: Record
 					eindex_dense_array[i] = i
 				end
 				entity_index.max_id = index
@@ -2480,8 +2459,8 @@ local function world_new()
 				local idr_archetype = archetypes[archetype_id]
 				local entities = idr_archetype.entities
 				local n = #entities
-				table.move(entities, 1, n, count + 1, queue)
 				count += n
+				table.move(entities, 1, n, #queue + 1, queue)
 			end
 			for _, e in queue do
 				inner_world_remove(world, e, entity)
@@ -2593,7 +2572,7 @@ local function world_new()
 
 		if idr then
 			local flags = idr.flags
-			if bit32.btest(flags, ECS_ID_DELETE) then
+			if bit32.band(flags, ECS_ID_DELETE) ~= 0 then
 				for archetype_id in idr.records do
 					local idr_archetype = archetypes[archetype_id]
 
@@ -2668,8 +2647,8 @@ local function world_new()
 					end
 					local id_record = component_index[id]
 					local flags = id_record.flags
-					local flags_delete_mask = bit32.btest(flags, ECS_ID_DELETE)
-					if flags_delete_mask then
+					local flags_delete_mask: number = bit32.band(flags, ECS_ID_DELETE)
+					if flags_delete_mask ~= 0 then
 						for i = #entities, 1, -1 do
 							local child = entities[i]
 							inner_world_delete(world, child)
@@ -2711,7 +2690,7 @@ local function world_new()
 		if idr_r then
 			local archetype_ids = idr_r.records
 			local flags = idr_r.flags
-			if bit32.btest(flags, ECS_ID_DELETE) then
+			if (bit32.band(flags, ECS_ID_DELETE) :: number) ~= 0 then
 				for archetype_id in archetype_ids do
 					local idr_r_archetype = archetypes[archetype_id]
 					local entities = idr_r_archetype.entities
@@ -2889,7 +2868,7 @@ end
 local function ecs_is_tag(world: World, entity: Entity): boolean
 	local idr = world.component_index[entity]
 	if idr then
-		return bit32.btest(idr.flags, ECS_ID_IS_TAG)
+		return bit32.band(idr.flags, ECS_ID_IS_TAG) ~= 0
 	end
 	return not world_has_one_inline(world, entity, EcsComponent)
 end
@@ -2898,7 +2877,7 @@ return {
 	world = world_new :: () -> World,
 	component = (ECS_COMPONENT :: any) :: <T>() -> Entity<T>,
 	tag = (ECS_TAG :: any) :: <T>() -> Entity<T>,
-	meta = (ECS_META :: any) :: <T, a>(id: Entity<T>, id: Id<a>, value: a?) -> Entity<T>,
+	meta = (ECS_META :: any) :: <T>(id: Entity, id: Id<T>, value: T) -> Entity<T>,
 	is_tag = (ecs_is_tag :: any) :: <T>(World, Id<T>) -> boolean,
 
     OnAdd = (EcsOnAdd :: any) :: Entity<<T>(entity: Entity, id: Id<T>, data: T) -> ()>,

test/tests.luau

@@ -22,8 +22,60 @@ type Entity<T=nil> = jecs.Entity<T>
 type Id<T=unknown> = jecs.Id<T>
 
 local entity_visualiser = require("@tools/entity_visualiser")
+local lifetime_tracker_add = require("@tools/lifetime_tracker")
 local dwi = entity_visualiser.stringify
 
+TEST("repro#", function()
+	do CASE "pair(OnDelete, Delete)"
+	    local world = jecs.world()
+	    local ct = world:component()
+	    world:add(ct, jecs.pair(jecs.OnDelete, jecs.Delete))
+
+	    local e1 = world:entity()
+	    local e2 = world:entity()
+
+	    local dummy = world:entity()
+
+	    world:add(e1, ct)
+	    world:add(e2, jecs.pair(ct, dummy))
+
+	    world:delete(dummy)
+
+	    CHECK(world:contains(e2))
+
+	    world:delete(ct)
+
+	    CHECK(not world:contains(e1))
+	end
+
+	do CASE "pair(OnDeleteTarget, Delete)"
+		print("start")
+	    local world = jecs.world()
+	    local ct = world:component()
+	    world:add(ct, jecs.pair(jecs.OnDeleteTarget, jecs.Delete))
+
+	    local e1 = world:entity()
+	    local e2 = world:entity()
+
+	    -- local dummy = world:entity()
+
+		print("flags")
+	    world:add(e1, ct)
+
+		print(world.component_index[ct].flags)
+	    -- world:add(e2, jecs.pair(ct, dummy))
+
+	    -- world:delete(dummy)
+
+	    -- CHECK(not world:contains(e2))
+
+	    world:delete(ct)
+
+	    CHECK(world:contains(e1))
+	end
+
+end)
+
 TEST("bulk", function()
 	local world = jecs.world()
 	local A = world:component()
@@ -381,51 +433,8 @@ TEST("world:contains()", function()
 end)
 
 TEST("world:delete()", function()
-	do CASE "pair(OnDelete, Delete)"
-	    local world = jecs.world()
-	    local ct = world:component()
-	    world:add(ct, jecs.pair(jecs.OnDelete, jecs.Delete))
-
-	    local e1 = world:entity()
-	    local e2 = world:entity()
-
-	    local dummy = world:entity()
-
-	    world:add(e1, ct)
-	    world:add(e2, jecs.pair(ct, dummy))
-
-	    world:delete(dummy)
-
-	    CHECK(world:contains(e2))
-
-	    world:delete(ct)
-
-	    CHECK(not world:contains(e1))
-	end
-
-	do CASE "pair(OnDeleteTarget, Delete)"
-	    local world = jecs.world()
-	    local ct = world:component()
-	    world:add(ct, jecs.pair(jecs.OnDeleteTarget, jecs.Delete))
-
-	    local e1 = world:entity()
-	    local e2 = world:entity()
-
-	    local dummy = world:entity()
-
-	    world:add(e1, ct)
-
-	    world:add(e2, jecs.pair(ct, dummy))
-
-	    world:delete(dummy)
-
-	    CHECK(not world:contains(e2))
-
-	    world:delete(ct)
-
-	    CHECK(world:contains(e1))
-	end
 	do CASE "remove (*, R) pairs when relationship is invalidated"
+		print("-------")
 		local world = jecs.world()
 		local e1 = world:entity()
 		local e2 = world:entity()