impl DUPLICATE fragment trait

develop/untests.lua

@@ -7994,3 +7994,992 @@ do
 
     assert(not evo.is_alive(c1))
 end
+
+do
+    local q1, q2, fq = evo.id(3)
+
+    evo.set(q1, fq)
+    evo.set(q2, fq)
+
+    local qf = evo.id()
+    evo.set(qf, evo.INCLUDES, fq)
+
+    local f1, f2 = evo.id(2)
+
+    local fs = { f1, f2 }
+    evo.batch_multi_set(qf, { evo.INCLUDES }, { fs })
+
+    do
+        local q1_fs = evo.get(q1, evo.INCLUDES)
+        assert(q1_fs and q1_fs ~= fs)
+        assert(#q1_fs == #fs)
+        assert(q1_fs[1] == fs[1] and q1_fs[2] == fs[2])
+    end
+
+    do
+        local q2_fs = evo.get(q2, evo.INCLUDES)
+        assert(q2_fs and q2_fs ~= fs)
+        assert(#q2_fs == #fs)
+        assert(q2_fs[1] == fs[1] and q2_fs[2] == fs[2])
+    end
+
+    do
+        local q1_fs = evo.get(q1, evo.INCLUDES)
+        local q2_fs = evo.get(q2, evo.INCLUDES)
+        assert(q1_fs ~= q2_fs)
+    end
+end
+
+do
+    local q1, q2 = evo.id(2)
+
+    local f1, f2 = evo.id(2)
+
+    local fs = { f1, f2 }
+    evo.multi_set(q1, { evo.INCLUDES }, { fs })
+    evo.multi_set(q2, { evo.INCLUDES }, { fs })
+
+    do
+        local q1_fs = evo.get(q1, evo.INCLUDES)
+        assert(q1_fs and q1_fs ~= fs)
+        assert(#q1_fs == #fs)
+        assert(q1_fs[1] == fs[1] and q1_fs[2] == fs[2])
+    end
+
+    do
+        local q2_fs = evo.get(q2, evo.INCLUDES)
+        assert(q2_fs and q2_fs ~= fs)
+        assert(#q2_fs == #fs)
+        assert(q2_fs[1] == fs[1] and q2_fs[2] == fs[2])
+    end
+
+    do
+        local q1_fs = evo.get(q1, evo.INCLUDES)
+        local q2_fs = evo.get(q2, evo.INCLUDES)
+        assert(q1_fs ~= q2_fs)
+    end
+end
+
+do
+    -- evo.set
+    -- evo.multi_set
+
+    local function v2(x, y) return { x = x or 0, y = y or 0 } end
+    local function v2_clone(v) return { x = v.x, y = v.y } end
+
+    do
+        local f = evo.fragment():build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+
+            evo.set(e1, f, v2(1, 2))
+            evo.set(e2, f, v2(3, 4))
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f, v2(1, 2))
+            evo.set(e2, f, v2(3, 4))
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+        end
+    end
+
+    do
+        local f = evo.fragment():default(v2(11, 22)):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.set(e1, f, v2(1, 2))
+            evo.set(e2, f, v2(3, 4))
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f, v2(1, 2))
+            evo.set(e2, f, v2(3, 4))
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+    end
+
+    do
+        local f = evo.fragment():default(v2(11, 22)):duplicate(v2_clone):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f, v2(1, 2))
+            evo.set(e2, f, v2(3, 4))
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f, v2(1, 2))
+            evo.set(e2, f, v2(3, 4))
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+        end
+    end
+
+    do
+        local f = evo.fragment():construct(v2):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.set(e1, f, 1, 2)
+            evo.set(e2, f, 3, 4)
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f, 1, 2)
+            evo.set(e2, f, 3, 4)
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+    end
+
+    do
+        local f = evo.fragment():duplicate(v2_clone):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.set(e1, f, v2(1, 2))
+            evo.set(e2, f, v2(3, 4))
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f, v2(1, 2))
+            evo.set(e2, f, v2(3, 4))
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+    end
+
+    do
+        local f = evo.fragment():construct(v2):default(v2(11, 22)):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.set(e1, f, 1, 2)
+            evo.set(e2, f, 3, 4)
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+
+            evo.set(e1, f, 1, 2)
+            evo.set(e2, f, 3, 4)
+            evo.multi_set(e3, { f }, { v2(5, 6) })
+            evo.multi_set(e4, { f }, { v2(7, 8) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 3 and evo.get(e2, f).y == 4)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 5 and evo.get(e3, f).y == 6)
+            assert(evo.get(e4, f).x == 7 and evo.get(e4, f).y == 8)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.set(e1, f)
+            evo.set(e2, f)
+            evo.multi_set(e3, { f })
+            evo.multi_set(e4, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+    end
+end
+
+do
+    -- evo.batch_set
+    -- evo.batch_multi_set
+
+    local function v2(x, y) return { x = x or 0, y = y or 0 } end
+    local function v2_clone(v) return { x = v.x, y = v.y } end
+
+    do
+        local f = evo.fragment():build()
+
+        local t1 = evo.fragment():tag():build()
+        local qt1 = evo.query():include(t1):build()
+
+        local t2 = evo.fragment():tag():build()
+        local qt2 = evo.query():include(t2):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+
+            evo.batch_set(qt1, f, v2(1, 2))
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f, v2(1, 2))
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+        end
+    end
+
+    do
+        local f = evo.fragment():default(v2(11, 22)):build()
+
+        local t1 = evo.fragment():tag():build()
+        local qt1 = evo.query():include(t1):build()
+
+        local t2 = evo.fragment():tag():build()
+        local qt2 = evo.query():include(t2):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f, v2(1, 2))
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f, v2(1, 2))
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+    end
+
+    do
+        local f = evo.fragment():default(v2(11, 22)):duplicate(v2_clone):build()
+
+        local t1 = evo.fragment():tag():build()
+        local qt1 = evo.query():include(t1):build()
+
+        local t2 = evo.fragment():tag():build()
+        local qt2 = evo.query():include(t2):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.batch_set(qt1, f, v2(1, 2))
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f, v2(1, 2))
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 11 and evo.get(e1, f).y == 22)
+            assert(evo.get(e2, f).x == 11 and evo.get(e2, f).y == 22)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+        end
+    end
+
+    do
+        local f = evo.fragment():construct(v2):build()
+
+        local t1 = evo.fragment():tag():build()
+        local qt1 = evo.query():include(t1):build()
+
+        local t2 = evo.fragment():tag():build()
+        local qt2 = evo.query():include(t2):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f, 1, 2)
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f, 1, 2)
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+    end
+
+    do
+        local f = evo.fragment():duplicate(v2_clone):build()
+
+        local t1 = evo.fragment():tag():build()
+        local qt1 = evo.query():include(t1):build()
+
+        local t2 = evo.fragment():tag():build()
+        local qt2 = evo.query():include(t2):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f, v2(1, 2))
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f, v2(1, 2))
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) ~= evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f) == true)
+            assert(evo.get(e2, f) == true)
+            assert(evo.get(e1, f) == evo.get(e2, f))
+            assert(evo.get(e3, f) == true)
+            assert(evo.get(e4, f) == true)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+    end
+    do
+        local f = evo.fragment():construct(v2):default(v2(11, 22)):build()
+
+        local t1 = evo.fragment():tag():build()
+        local qt1 = evo.query():include(t1):build()
+
+        local t2 = evo.fragment():tag():build()
+        local qt2 = evo.query():include(t2):build()
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f, 1, 2)
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+
+        do
+            local e1, e2, e3, e4 = evo.id(4)
+            evo.set(e1, t1); evo.set(e2, t1); evo.set(e3, t2); evo.set(e4, t2)
+
+            evo.batch_set(qt1, f, 1, 2)
+            evo.batch_multi_set(qt2, { f }, { v2(3, 4) })
+
+            assert(evo.get(e1, f).x == 1 and evo.get(e1, f).y == 2)
+            assert(evo.get(e2, f).x == 1 and evo.get(e2, f).y == 2)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 3 and evo.get(e3, f).y == 4)
+            assert(evo.get(e4, f).x == 3 and evo.get(e4, f).y == 4)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+
+            evo.batch_set(qt1, f)
+            evo.batch_multi_set(qt2, { f })
+
+            assert(evo.get(e1, f).x == 0 and evo.get(e1, f).y == 0)
+            assert(evo.get(e2, f).x == 0 and evo.get(e2, f).y == 0)
+            assert(evo.get(e1, f) ~= evo.get(e2, f))
+            assert(evo.get(e3, f).x == 11 and evo.get(e3, f).y == 22)
+            assert(evo.get(e4, f).x == 11 and evo.get(e4, f).y == 22)
+            assert(evo.get(e3, f) == evo.get(e4, f))
+        end
+    end
+end
+
+do
+    local function v2(x, y) return { x = x or 0, y = y or 0 } end
+
+    local f1 = evo.fragment():default(v2(10, 11)):build()
+    local f2 = evo.fragment():default(v2(11, 22)):build()
+
+    local fs, cs = { f1, f2 }, { v2(1, 2) }
+    local c12 = evo.chunk(f1, f2)
+
+    do
+        local e1 = evo.spawn_at(c12, fs, cs)
+        local e2 = evo.spawn_at(c12, fs, cs)
+
+        assert(evo.get(e1, f1).x == 1 and evo.get(e1, f1).y == 2)
+        assert(evo.get(e2, f1).x == 1 and evo.get(e2, f1).y == 2)
+        assert(evo.get(e1, f1) == evo.get(e2, f1))
+
+        assert(evo.get(e1, f2).x == 11 and evo.get(e1, f2).y == 22)
+        assert(evo.get(e2, f2).x == 11 and evo.get(e2, f2).y == 22)
+        assert(evo.get(e1, f2) == evo.get(e2, f2))
+    end
+
+    do
+        local e1 = evo.spawn_with(fs, cs)
+        local e2 = evo.spawn_with(fs, cs)
+
+        assert(evo.get(e1, f1).x == 1 and evo.get(e1, f1).y == 2)
+        assert(evo.get(e2, f1).x == 1 and evo.get(e2, f1).y == 2)
+        assert(evo.get(e1, f1) == evo.get(e2, f1))
+
+        assert(evo.get(e1, f2).x == 11 and evo.get(e1, f2).y == 22)
+        assert(evo.get(e2, f2).x == 11 and evo.get(e2, f2).y == 22)
+        assert(evo.get(e1, f2) == evo.get(e2, f2))
+    end
+end
+
+do
+    local function v2(x, y) return { x = x or 0, y = y or 0 } end
+    local function v2_clone(v) return { x = v.x, y = v.y } end
+
+    local f1 = evo.fragment():default(v2(10, 11)):duplicate(v2_clone):build()
+    local f2 = evo.fragment():default(v2(11, 22)):duplicate(v2_clone):build()
+
+    local fs, cs = { f1, f2 }, { v2(1, 2) }
+    local c12 = evo.chunk(f1, f2)
+
+    do
+        local e1 = evo.spawn_at(c12, fs, cs)
+        local e2 = evo.spawn_at(c12, fs, cs)
+
+        assert(evo.get(e1, f1).x == 1 and evo.get(e1, f1).y == 2)
+        assert(evo.get(e2, f1).x == 1 and evo.get(e2, f1).y == 2)
+        assert(evo.get(e1, f1) ~= evo.get(e2, f1))
+
+        assert(evo.get(e1, f2).x == 11 and evo.get(e1, f2).y == 22)
+        assert(evo.get(e2, f2).x == 11 and evo.get(e2, f2).y == 22)
+        assert(evo.get(e1, f2) ~= evo.get(e2, f2))
+    end
+
+    do
+        local e1 = evo.spawn_with(fs, cs)
+        local e2 = evo.spawn_with(fs, cs)
+
+        assert(evo.get(e1, f1).x == 1 and evo.get(e1, f1).y == 2)
+        assert(evo.get(e2, f1).x == 1 and evo.get(e2, f1).y == 2)
+        assert(evo.get(e1, f1) ~= evo.get(e2, f1))
+
+        assert(evo.get(e1, f2).x == 11 and evo.get(e1, f2).y == 22)
+        assert(evo.get(e2, f2).x == 11 and evo.get(e2, f2).y == 22)
+        assert(evo.get(e1, f2) ~= evo.get(e2, f2))
+    end
+end

evolved.lua

@@ -831,6 +831,67 @@ local function __component_list_copy(argument_list)
     return dupl_argument_list
 end
 
+---@param default? evolved.component
+---@param construct? evolved.construct
+---@param duplicate? evolved.duplicate
+---@param ... any component arguments
+---@return evolved.component
+---@nodiscard
+local function __component_common_construct(default, construct, duplicate, ...)
+    local component = ...
+
+    if construct then
+        component = construct(...)
+
+        if component ~= nil then
+            return component
+        end
+    end
+
+    if component == nil then
+        component = default
+    end
+
+    if component ~= nil and duplicate then
+        component = duplicate(component)
+    end
+
+    return component == nil and true or component
+end
+
+---@param default? evolved.component
+---@param prototype? evolved.component
+---@return evolved.component
+---@nodiscard
+local function __component_simple_construct(default, prototype)
+    local component = prototype
+
+    if component == nil then
+        component = default
+    end
+
+    return component == nil and true or component
+end
+
+---@param default? evolved.component
+---@param duplicate? evolved.duplicate
+---@param prototype? evolved.component
+---@return evolved.component
+---@nodiscard
+local function __component_duplicate_construct(default, duplicate, prototype)
+    local component = prototype
+
+    if component == nil then
+        component = default
+    end
+
+    if component ~= nil and duplicate then
+        component = duplicate(component)
+    end
+
+    return component == nil and true or component
+end
+
 ---@param fragment evolved.fragment
 ---@return evolved.storage
 ---@nodiscard
@@ -1738,22 +1799,31 @@ local function __spawn_entity_at(entity, chunk, fragment_list, fragment_count, c
     if chunk_has_defaults_or_constructs then
         for component_index = 1, chunk_component_count do
             local fragment = chunk_component_fragments[component_index]
-            local component_storage = chunk_component_storages[component_index]
 
-            local new_component = __evolved_get(fragment, __DEFAULT)
+            ---@type evolved.default?, evolved.duplicate?
+            local fragment_default, fragment_duplicate =
+                __evolved_get(fragment, __DEFAULT, __DUPLICATE)
+
+            local new_component = fragment_default
+
+            if new_component ~= nil and fragment_duplicate then
+                new_component = fragment_duplicate(new_component)
+            end
 
             if new_component == nil then
                 new_component = true
             end
 
+            local component_storage = chunk_component_storages[component_index]
+
             component_storage[place] = new_component
         end
     else
         for component_index = 1, chunk_component_count do
-            local component_storage = chunk_component_storages[component_index]
-
             local new_component = true
 
+            local component_storage = chunk_component_storages[component_index]
+
             component_storage[place] = new_component
         end
     end
@@ -1764,19 +1834,21 @@ local function __spawn_entity_at(entity, chunk, fragment_list, fragment_count, c
             local component_index = chunk_component_indices[fragment]
 
             if component_index then
-                local component_storage = chunk_component_storages[component_index]
+                ---@type evolved.duplicate?
+                local fragment_duplicate =
+                    __evolved_get(fragment, __DUPLICATE)
 
                 local new_component = component_list[i]
 
-                if new_component == nil then
-                    new_component = __evolved_get(fragment, __DEFAULT)
+                if new_component ~= nil and fragment_duplicate then
+                    new_component = fragment_duplicate(new_component)
                 end
 
-                if new_component == nil then
-                    new_component = true
-                end
+                if new_component ~= nil then
+                    local component_storage = chunk_component_storages[component_index]
 
-                component_storage[place] = new_component
+                    component_storage[place] = new_component
+                end
             end
         end
     else
@@ -1785,15 +1857,13 @@ local function __spawn_entity_at(entity, chunk, fragment_list, fragment_count, c
             local component_index = chunk_component_indices[fragment]
 
             if component_index then
-                local component_storage = chunk_component_storages[component_index]
-
                 local new_component = component_list[i]
 
-                if new_component == nil then
-                    new_component = true
-                end
+                if new_component ~= nil then
+                    local component_storage = chunk_component_storages[component_index]
 
-                component_storage[place] = new_component
+                    component_storage[place] = new_component
+                end
             end
         end
     end
@@ -1806,7 +1876,8 @@ local function __spawn_entity_at(entity, chunk, fragment_list, fragment_count, c
             local fragment = chunk_fragment_list[chunk_fragment_index]
 
             ---@type evolved.set_hook?, evolved.insert_hook?
-            local fragment_on_set, fragment_on_insert = __evolved_get(fragment, __ON_SET, __ON_INSERT)
+            local fragment_on_set, fragment_on_insert =
+                __evolved_get(fragment, __ON_SET, __ON_INSERT)
 
             local component_index = chunk_component_indices[fragment]
 
@@ -1874,18 +1945,26 @@ local function __spawn_entity_with(entity, chunk, fragment_list, fragment_count,
             local component_index = chunk_component_indices[fragment]
 
             if component_index then
-                local component_storage = chunk_component_storages[component_index]
+                ---@type evolved.default?, evolved.duplicate?
+                local fragment_default, fragment_duplicate =
+                    __evolved_get(fragment, __DEFAULT, __DUPLICATE)
 
                 local new_component = component_list[i]
 
                 if new_component == nil then
-                    new_component = __evolved_get(fragment, __DEFAULT)
+                    new_component = fragment_default
+                end
+
+                if new_component ~= nil and fragment_duplicate then
+                    new_component = fragment_duplicate(new_component)
                 end
 
                 if new_component == nil then
                     new_component = true
                 end
 
+                local component_storage = chunk_component_storages[component_index]
+
                 component_storage[place] = new_component
             end
         end
@@ -1895,14 +1974,14 @@ local function __spawn_entity_with(entity, chunk, fragment_list, fragment_count,
             local component_index = chunk_component_indices[fragment]
 
             if component_index then
-                local component_storage = chunk_component_storages[component_index]
-
                 local new_component = component_list[i]
 
                 if new_component == nil then
                     new_component = true
                 end
 
+                local component_storage = chunk_component_storages[component_index]
+
                 component_storage[place] = new_component
             end
         end
@@ -1916,7 +1995,8 @@ local function __spawn_entity_with(entity, chunk, fragment_list, fragment_count,
             local fragment = chunk_fragment_list[chunk_fragment_index]
 
             ---@type evolved.set_hook?, evolved.insert_hook?
-            local fragment_on_set, fragment_on_insert = __evolved_get(fragment, __ON_SET, __ON_INSERT)
+            local fragment_on_set, fragment_on_insert =
+                __evolved_get(fragment, __ON_SET, __ON_INSERT)
 
             local component_index = chunk_component_indices[fragment]
 
@@ -2086,12 +2166,12 @@ __chunk_set = function(old_chunk, fragment, ...)
         local old_chunk_has_defaults_or_constructs = old_chunk.__has_defaults_or_constructs
         local old_chunk_has_set_or_assign_hooks = old_chunk.__has_set_or_assign_hooks
 
-        ---@type evolved.default?, evolved.construct?, evolved.set_hook?, evolved.assign_hook?
-        local fragment_default, fragment_construct, fragment_on_set, fragment_on_assign
+        ---@type evolved.default?, evolved.construct?, evolved.duplicate?, evolved.set_hook?, evolved.assign_hook?
+        local fragment_default, fragment_construct, fragment_duplicate, fragment_on_set, fragment_on_assign
 
         if old_chunk_has_defaults_or_constructs or old_chunk_has_set_or_assign_hooks then
-            fragment_default, fragment_construct, fragment_on_set, fragment_on_assign = __evolved_get(fragment,
-                __DEFAULT, __CONSTRUCT, __ON_SET, __ON_ASSIGN)
+            fragment_default, fragment_construct, fragment_duplicate, fragment_on_set, fragment_on_assign =
+                __evolved_get(fragment, __DEFAULT, __CONSTRUCT, __DUPLICATE, __ON_SET, __ON_ASSIGN)
         end
 
         if fragment_on_set or fragment_on_assign then
@@ -2100,17 +2180,15 @@ __chunk_set = function(old_chunk, fragment, ...)
             if old_component_index then
                 local old_component_storage = old_component_storages[old_component_index]
 
-                if fragment_default ~= nil or fragment_construct then
-                    for place = 1, old_entity_count do
-                        local entity = old_entity_list[place]
-                        local old_component = old_component_storage[place]
+                if fragment_construct or fragment_duplicate then
+                    for old_place = 1, old_entity_count do
+                        local entity = old_entity_list[old_place]
 
-                        local new_component = ...
-                        if fragment_construct then new_component = fragment_construct(...) end
-                        if new_component == nil then new_component = fragment_default end
-                        if new_component == nil then new_component = true end
+                        local new_component = __component_common_construct(
+                            fragment_default, fragment_construct, fragment_duplicate, ...)
 
-                        old_component_storage[place] = new_component
+                        local old_component = old_component_storage[old_place]
+                        old_component_storage[old_place] = new_component
 
                         if fragment_on_set then
                             __defer_call_hook(fragment_on_set, entity, fragment, new_component, old_component)
@@ -2121,14 +2199,14 @@ __chunk_set = function(old_chunk, fragment, ...)
                         end
                     end
                 else
-                    local new_component = ...
-                    if new_component == nil then new_component = true end
+                    local new_component = __component_simple_construct(
+                        fragment_default, ...)
 
-                    for place = 1, old_entity_count do
-                        local entity = old_entity_list[place]
-                        local old_component = old_component_storage[place]
+                    for old_place = 1, old_entity_count do
+                        local entity = old_entity_list[old_place]
 
-                        old_component_storage[place] = new_component
+                        local old_component = old_component_storage[old_place]
+                        old_component_storage[old_place] = new_component
 
                         if fragment_on_set then
                             __defer_call_hook(fragment_on_set, entity, fragment, new_component, old_component)
@@ -2140,8 +2218,8 @@ __chunk_set = function(old_chunk, fragment, ...)
                     end
                 end
             else
-                for place = 1, old_entity_count do
-                    local entity = old_entity_list[place]
+                for old_place = 1, old_entity_count do
+                    local entity = old_entity_list[old_place]
 
                     if fragment_on_set then
                         __defer_call_hook(fragment_on_set, entity, fragment)
@@ -2158,20 +2236,17 @@ __chunk_set = function(old_chunk, fragment, ...)
             if old_component_index then
                 local old_component_storage = old_component_storages[old_component_index]
 
-                if fragment_default ~= nil or fragment_construct then
-                    for place = 1, old_entity_count do
-                        local new_component = ...
-                        if fragment_construct then new_component = fragment_construct(...) end
-                        if new_component == nil then new_component = fragment_default end
-                        if new_component == nil then new_component = true end
-                        old_component_storage[place] = new_component
+                if fragment_construct or fragment_duplicate then
+                    for old_place = 1, old_entity_count do
+                        old_component_storage[old_place] = __component_common_construct(
+                            fragment_default, fragment_construct, fragment_duplicate, ...)
                     end
                 else
-                    local new_component = ...
-                    if new_component == nil then new_component = true end
+                    local new_component = __component_simple_construct(
+                        fragment_default, ...)
 
-                    for place = 1, old_entity_count do
-                        old_component_storage[place] = new_component
+                    for old_place = 1, old_entity_count do
+                        old_component_storage[old_place] = new_component
                     end
                 end
             else
@@ -2188,12 +2263,12 @@ __chunk_set = function(old_chunk, fragment, ...)
         local new_chunk_has_defaults_or_constructs = new_chunk.__has_defaults_or_constructs
         local new_chunk_has_set_or_insert_hooks = new_chunk.__has_set_or_insert_hooks
 
-        ---@type evolved.default?, evolved.construct?, evolved.set_hook?, evolved.insert_hook?
-        local fragment_default, fragment_construct, fragment_on_set, fragment_on_insert
+        ---@type evolved.default?, evolved.construct?, evolved.duplicate?, evolved.set_hook?, evolved.insert_hook?
+        local fragment_default, fragment_construct, fragment_duplicate, fragment_on_set, fragment_on_insert
 
         if new_chunk_has_defaults_or_constructs or new_chunk_has_set_or_insert_hooks then
-            fragment_default, fragment_construct, fragment_on_set, fragment_on_insert = __evolved_get(fragment,
-                __DEFAULT, __CONSTRUCT, __ON_SET, __ON_INSERT)
+            fragment_default, fragment_construct, fragment_duplicate, fragment_on_set, fragment_on_insert =
+                __evolved_get(fragment, __DEFAULT, __CONSTRUCT, __DUPLICATE, __ON_SET, __ON_INSERT)
         end
 
         if new_entity_count == 0 then
@@ -2247,14 +2322,12 @@ __chunk_set = function(old_chunk, fragment, ...)
             if new_component_index then
                 local new_component_storage = new_component_storages[new_component_index]
 
-                if fragment_default ~= nil or fragment_construct then
+                if fragment_construct or fragment_duplicate then
                     for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
                         local entity = new_entity_list[new_place]
 
-                        local new_component = ...
-                        if fragment_construct then new_component = fragment_construct(...) end
-                        if new_component == nil then new_component = fragment_default end
-                        if new_component == nil then new_component = true end
+                        local new_component = __component_common_construct(
+                            fragment_default, fragment_construct, fragment_duplicate, ...)
 
                         new_component_storage[new_place] = new_component
 
@@ -2267,8 +2340,8 @@ __chunk_set = function(old_chunk, fragment, ...)
                         end
                     end
                 else
-                    local new_component = ...
-                    if new_component == nil then new_component = true end
+                    local new_component = __component_simple_construct(
+                        fragment_default, ...)
 
                     for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
                         local entity = new_entity_list[new_place]
@@ -2303,17 +2376,14 @@ __chunk_set = function(old_chunk, fragment, ...)
             if new_component_index then
                 local new_component_storage = new_component_storages[new_component_index]
 
-                if fragment_default ~= nil or fragment_construct then
+                if fragment_construct or fragment_duplicate then
                     for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
-                        local new_component = ...
-                        if fragment_construct then new_component = fragment_construct(...) end
-                        if new_component == nil then new_component = fragment_default end
-                        if new_component == nil then new_component = true end
-                        new_component_storage[new_place] = new_component
+                        new_component_storage[new_place] = __component_common_construct(
+                            fragment_default, fragment_construct, fragment_duplicate, ...)
                     end
                 else
-                    local new_component = ...
-                    if new_component == nil then new_component = true end
+                    local new_component = __component_simple_construct(
+                        fragment_default, ...)
 
                     for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
                         new_component_storage[new_place] = new_component
@@ -2658,12 +2728,12 @@ __chunk_multi_set = function(old_chunk, fragments, fragment_count, components)
         for i = 1, fragment_count do
             local fragment = fragments[i]
 
-            ---@type evolved.default?, evolved.set_hook?, evolved.assign_hook?
-            local fragment_default, fragment_on_set, fragment_on_assign
+            ---@type evolved.default?, evolved.duplicate?, evolved.set_hook?, evolved.assign_hook?
+            local fragment_default, fragment_duplicate, fragment_on_set, fragment_on_assign
 
             if old_chunk_has_defaults_or_constructs or old_chunk_has_set_or_assign_hooks then
-                fragment_default, fragment_on_set, fragment_on_assign = __evolved_get(fragment,
-                    __DEFAULT, __ON_SET, __ON_ASSIGN)
+                fragment_default, fragment_duplicate, fragment_on_set, fragment_on_assign =
+                    __evolved_get(fragment, __DEFAULT, __DUPLICATE, __ON_SET, __ON_ASSIGN)
             end
 
             if fragment_on_set or fragment_on_assign then
@@ -2672,27 +2742,46 @@ __chunk_multi_set = function(old_chunk, fragments, fragment_count, components)
                 if old_component_index then
                     local old_component_storage = old_component_storages[old_component_index]
 
-                    local new_component = components[i]
-                    if new_component == nil then new_component = fragment_default end
-                    if new_component == nil then new_component = true end
+                    if fragment_duplicate then
+                        for old_place = 1, old_entity_count do
+                            local entity = old_entity_list[old_place]
 
-                    for place = 1, old_entity_count do
-                        local entity = old_entity_list[place]
-                        local old_component = old_component_storage[place]
+                            local new_component = __component_duplicate_construct(
+                                fragment_default, fragment_duplicate, components[i])
 
-                        old_component_storage[place] = new_component
+                            local old_component = old_component_storage[old_place]
+                            old_component_storage[old_place] = new_component
 
-                        if fragment_on_set then
-                            __defer_call_hook(fragment_on_set, entity, fragment, new_component, old_component)
+                            if fragment_on_set then
+                                __defer_call_hook(fragment_on_set, entity, fragment, new_component, old_component)
+                            end
+
+                            if fragment_on_assign then
+                                __defer_call_hook(fragment_on_assign, entity, fragment, new_component, old_component)
+                            end
                         end
+                    else
+                        local new_component = __component_simple_construct(
+                            fragment_default, components[i])
 
-                        if fragment_on_assign then
-                            __defer_call_hook(fragment_on_assign, entity, fragment, new_component, old_component)
+                        for old_place = 1, old_entity_count do
+                            local entity = old_entity_list[old_place]
+
+                            local old_component = old_component_storage[old_place]
+                            old_component_storage[old_place] = new_component
+
+                            if fragment_on_set then
+                                __defer_call_hook(fragment_on_set, entity, fragment, new_component, old_component)
+                            end
+
+                            if fragment_on_assign then
+                                __defer_call_hook(fragment_on_assign, entity, fragment, new_component, old_component)
+                            end
                         end
                     end
                 else
-                    for place = 1, old_entity_count do
-                        local entity = old_entity_list[place]
+                    for old_place = 1, old_entity_count do
+                        local entity = old_entity_list[old_place]
 
                         if fragment_on_set then
                             __defer_call_hook(fragment_on_set, entity, fragment)
@@ -2709,12 +2798,18 @@ __chunk_multi_set = function(old_chunk, fragments, fragment_count, components)
                 if old_component_index then
                     local old_component_storage = old_component_storages[old_component_index]
 
-                    local new_component = components[i]
-                    if new_component == nil then new_component = fragment_default end
-                    if new_component == nil then new_component = true end
+                    if fragment_duplicate then
+                        for old_place = 1, old_entity_count do
+                            old_component_storage[old_place] = __component_duplicate_construct(
+                                fragment_default, fragment_duplicate, components[i])
+                        end
+                    else
+                        local new_component = __component_simple_construct(
+                            fragment_default, components[i])
 
-                    for place = 1, old_entity_count do
-                        old_component_storage[place] = new_component
+                        for old_place = 1, old_entity_count do
+                            old_component_storage[old_place] = new_component
+                        end
                     end
                 else
                     -- nothing
@@ -2783,37 +2878,56 @@ __chunk_multi_set = function(old_chunk, fragments, fragment_count, components)
         for i = 1, fragment_count do
             local fragment = fragments[i]
 
+            ---@type evolved.default?, evolved.duplicate?, evolved.set_hook?, evolved.assign_hook?, evolved.insert_hook?
+            local fragment_default, fragment_duplicate, fragment_on_set, fragment_on_assign, fragment_on_insert
+
+            if new_chunk_has_defaults_or_constructs or new_chunk_has_set_or_assign_hooks or new_chunk_has_set_or_insert_hooks then
+                fragment_default, fragment_duplicate, fragment_on_set, fragment_on_assign, fragment_on_insert =
+                    __evolved_get(fragment, __DEFAULT, __DUPLICATE, __ON_SET, __ON_ASSIGN, __ON_INSERT)
+            end
+
             if inserted_set[fragment] or old_fragment_set[fragment] then
-                ---@type evolved.default?, evolved.set_hook?, evolved.assign_hook?
-                local fragment_default, fragment_on_set, fragment_on_assign
-
-                if new_chunk_has_defaults_or_constructs or new_chunk_has_set_or_assign_hooks then
-                    fragment_default, fragment_on_set, fragment_on_assign = __evolved_get(fragment,
-                        __DEFAULT, __ON_SET, __ON_ASSIGN)
-                end
-
                 if fragment_on_set or fragment_on_assign then
                     local new_component_index = new_component_indices[fragment]
 
                     if new_component_index then
                         local new_component_storage = new_component_storages[new_component_index]
 
-                        local new_component = components[i]
-                        if new_component == nil then new_component = fragment_default end
-                        if new_component == nil then new_component = true end
+                        if fragment_duplicate then
+                            for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
+                                local entity = new_entity_list[new_place]
 
-                        for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
-                            local entity = new_entity_list[new_place]
-                            local old_component = new_component_storage[new_place]
+                                local new_component = __component_duplicate_construct(
+                                    fragment_default, fragment_duplicate, components[i])
 
-                            new_component_storage[new_place] = new_component
+                                local old_component = new_component_storage[new_place]
+                                new_component_storage[new_place] = new_component
 
-                            if fragment_on_set then
-                                __defer_call_hook(fragment_on_set, entity, fragment, new_component, old_component)
+                                if fragment_on_set then
+                                    __defer_call_hook(fragment_on_set, entity, fragment, new_component, old_component)
+                                end
+
+                                if fragment_on_assign then
+                                    __defer_call_hook(fragment_on_assign, entity, fragment, new_component, old_component)
+                                end
                             end
+                        else
+                            local new_component = __component_simple_construct(
+                                fragment_default, components[i])
 
-                            if fragment_on_assign then
-                                __defer_call_hook(fragment_on_assign, entity, fragment, new_component, old_component)
+                            for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
+                                local entity = new_entity_list[new_place]
+
+                                local old_component = new_component_storage[new_place]
+                                new_component_storage[new_place] = new_component
+
+                                if fragment_on_set then
+                                    __defer_call_hook(fragment_on_set, entity, fragment, new_component, old_component)
+                                end
+
+                                if fragment_on_assign then
+                                    __defer_call_hook(fragment_on_assign, entity, fragment, new_component, old_component)
+                                end
                             end
                         end
                     else
@@ -2835,12 +2949,18 @@ __chunk_multi_set = function(old_chunk, fragments, fragment_count, components)
                     if new_component_index then
                         local new_component_storage = new_component_storages[new_component_index]
 
-                        local new_component = components[i]
-                        if new_component == nil then new_component = fragment_default end
-                        if new_component == nil then new_component = true end
+                        if fragment_duplicate then
+                            for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
+                                new_component_storage[new_place] = __component_duplicate_construct(
+                                    fragment_default, fragment_duplicate, components[i])
+                            end
+                        else
+                            local new_component = __component_simple_construct(
+                                fragment_default, components[i])
 
-                        for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
-                            new_component_storage[new_place] = new_component
+                            for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
+                                new_component_storage[new_place] = new_component
+                            end
                         end
                     else
                         -- nothing
@@ -2849,35 +2969,45 @@ __chunk_multi_set = function(old_chunk, fragments, fragment_count, components)
             else
                 inserted_set[fragment] = true
 
-                ---@type evolved.default?, evolved.set_hook?, evolved.insert_hook?
-                local fragment_default, fragment_on_set, fragment_on_insert
-
-                if new_chunk_has_defaults_or_constructs or new_chunk_has_set_or_insert_hooks then
-                    fragment_default, fragment_on_set, fragment_on_insert = __evolved_get(fragment,
-                        __DEFAULT, __ON_SET, __ON_INSERT)
-                end
-
                 if fragment_on_set or fragment_on_insert then
                     local new_component_index = new_component_indices[fragment]
 
                     if new_component_index then
                         local new_component_storage = new_component_storages[new_component_index]
 
-                        local new_component = components[i]
-                        if new_component == nil then new_component = fragment_default end
-                        if new_component == nil then new_component = true end
+                        if fragment_duplicate then
+                            for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
+                                local entity = new_entity_list[new_place]
 
-                        for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
-                            local entity = new_entity_list[new_place]
+                                local new_component = __component_duplicate_construct(
+                                    fragment_default, fragment_duplicate, components[i])
 
-                            new_component_storage[new_place] = new_component
+                                new_component_storage[new_place] = new_component
 
-                            if fragment_on_set then
-                                __defer_call_hook(fragment_on_set, entity, fragment, new_component)
+                                if fragment_on_set then
+                                    __defer_call_hook(fragment_on_set, entity, fragment, new_component)
+                                end
+
+                                if fragment_on_insert then
+                                    __defer_call_hook(fragment_on_insert, entity, fragment, new_component)
+                                end
                             end
+                        else
+                            local new_component = __component_simple_construct(
+                                fragment_default, components[i])
 
-                            if fragment_on_insert then
-                                __defer_call_hook(fragment_on_insert, entity, fragment, new_component)
+                            for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
+                                local entity = new_entity_list[new_place]
+
+                                new_component_storage[new_place] = new_component
+
+                                if fragment_on_set then
+                                    __defer_call_hook(fragment_on_set, entity, fragment, new_component)
+                                end
+
+                                if fragment_on_insert then
+                                    __defer_call_hook(fragment_on_insert, entity, fragment, new_component)
+                                end
                             end
                         end
                     else
@@ -2899,12 +3029,18 @@ __chunk_multi_set = function(old_chunk, fragments, fragment_count, components)
                     if new_component_index then
                         local new_component_storage = new_component_storages[new_component_index]
 
-                        local new_component = components[i]
-                        if new_component == nil then new_component = fragment_default end
-                        if new_component == nil then new_component = true end
+                        if fragment_duplicate then
+                            for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
+                                new_component_storage[new_place] = __component_duplicate_construct(
+                                    fragment_default, fragment_duplicate, components[i])
+                            end
+                        else
+                            local new_component = __component_simple_construct(
+                                fragment_default, components[i])
 
-                        for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
-                            new_component_storage[new_place] = new_component
+                            for new_place = new_entity_count + 1, new_entity_count + old_entity_count do
+                                new_component_storage[new_place] = new_component
+                            end
                         end
                     else
                         -- nothing
@@ -2975,8 +3111,8 @@ __chunk_multi_remove = function(old_chunk, fragments, fragment_count)
                             __defer_call_hook(fragment_on_remove, entity, fragment, old_component)
                         end
                     else
-                        for place = 1, old_entity_count do
-                            local entity = old_entity_list[place]
+                        for old_place = 1, old_entity_count do
+                            local entity = old_entity_list[old_place]
                             __defer_call_hook(fragment_on_remove, entity, fragment)
                         end
                     end
@@ -4575,12 +4711,12 @@ __evolved_set = function(entity, fragment, ...)
         local old_chunk_has_defaults_or_constructs = old_chunk.__has_defaults_or_constructs
         local old_chunk_has_set_or_assign_hooks = old_chunk.__has_set_or_assign_hooks
 
-        ---@type evolved.default?, evolved.construct?, evolved.set_hook?, evolved.assign_hook?
-        local fragment_default, fragment_construct, fragment_on_set, fragment_on_assign
+        ---@type evolved.default?, evolved.construct?, evolved.duplicate?, evolved.set_hook?, evolved.assign_hook?
+        local fragment_default, fragment_construct, fragment_duplicate, fragment_on_set, fragment_on_assign
 
         if old_chunk_has_defaults_or_constructs or old_chunk_has_set_or_assign_hooks then
-            fragment_default, fragment_construct, fragment_on_set, fragment_on_assign = __evolved_get(fragment,
-                __DEFAULT, __CONSTRUCT, __ON_SET, __ON_ASSIGN)
+            fragment_default, fragment_construct, fragment_duplicate, fragment_on_set, fragment_on_assign =
+                __evolved_get(fragment, __DEFAULT, __CONSTRUCT, __DUPLICATE, __ON_SET, __ON_ASSIGN)
         end
 
         local old_component_index = old_component_indices[fragment]
@@ -4588,25 +4724,18 @@ __evolved_set = function(entity, fragment, ...)
         if old_component_index then
             local old_component_storage = old_component_storages[old_component_index]
 
-            local new_component = ...
-            if fragment_construct then new_component = fragment_construct(...) end
-            if new_component == nil then new_component = fragment_default end
-            if new_component == nil then new_component = true end
+            local new_component = __component_common_construct(
+                fragment_default, fragment_construct, fragment_duplicate, ...)
 
-            if fragment_on_set or fragment_on_assign then
-                local old_component = old_component_storage[old_place]
+            local old_component = old_component_storage[old_place]
+            old_component_storage[old_place] = new_component
 
-                old_component_storage[old_place] = new_component
+            if fragment_on_set then
+                __defer_call_hook(fragment_on_set, entity, fragment, new_component, old_component)
+            end
 
-                if fragment_on_set then
-                    __defer_call_hook(fragment_on_set, entity, fragment, new_component, old_component)
-                end
-
-                if fragment_on_assign then
-                    __defer_call_hook(fragment_on_assign, entity, fragment, new_component, old_component)
-                end
-            else
-                old_component_storage[old_place] = new_component
+            if fragment_on_assign then
+                __defer_call_hook(fragment_on_assign, entity, fragment, new_component, old_component)
             end
         else
             if fragment_on_set then
@@ -4627,12 +4756,12 @@ __evolved_set = function(entity, fragment, ...)
         local new_chunk_has_defaults_or_constructs = new_chunk.__has_defaults_or_constructs
         local new_chunk_has_set_or_insert_hooks = new_chunk.__has_set_or_insert_hooks
 
-        ---@type evolved.default?, evolved.construct?, evolved.set_hook?, evolved.insert_hook?
-        local fragment_default, fragment_construct, fragment_on_set, fragment_on_insert
+        ---@type evolved.default?, evolved.construct?, evolved.duplicate?, evolved.set_hook?, evolved.insert_hook?
+        local fragment_default, fragment_construct, fragment_duplicate, fragment_on_set, fragment_on_insert
 
         if new_chunk_has_defaults_or_constructs or new_chunk_has_set_or_insert_hooks then
-            fragment_default, fragment_construct, fragment_on_set, fragment_on_insert = __evolved_get(fragment,
-                __DEFAULT, __CONSTRUCT, __ON_SET, __ON_INSERT)
+            fragment_default, fragment_construct, fragment_duplicate, fragment_on_set, fragment_on_insert =
+                __evolved_get(fragment, __DEFAULT, __CONSTRUCT, __DUPLICATE, __ON_SET, __ON_INSERT)
         end
 
         local new_place = new_entity_count + 1
@@ -4669,10 +4798,8 @@ __evolved_set = function(entity, fragment, ...)
             if new_component_index then
                 local new_component_storage = new_component_storages[new_component_index]
 
-                local new_component = ...
-                if fragment_construct then new_component = fragment_construct(...) end
-                if new_component == nil then new_component = fragment_default end
-                if new_component == nil then new_component = true end
+                local new_component = __component_common_construct(
+                    fragment_default, fragment_construct, fragment_duplicate, ...)
 
                 new_component_storage[new_place] = new_component
 
@@ -5011,12 +5138,12 @@ __evolved_multi_set = function(entity, fragments, components)
         for i = 1, fragment_count do
             local fragment = fragments[i]
 
-            ---@type evolved.default?, evolved.set_hook?, evolved.assign_hook?
-            local fragment_default, fragment_on_set, fragment_on_assign
+            ---@type evolved.default?, evolved.duplicate?, evolved.set_hook?, evolved.assign_hook?
+            local fragment_default, fragment_duplicate, fragment_on_set, fragment_on_assign
 
             if old_chunk_has_defaults_or_constructs or old_chunk_has_set_or_assign_hooks then
-                fragment_default, fragment_on_set, fragment_on_assign = __evolved_get(fragment,
-                    __DEFAULT, __ON_SET, __ON_ASSIGN)
+                fragment_default, fragment_duplicate, fragment_on_set, fragment_on_assign =
+                    __evolved_get(fragment, __DEFAULT, __DUPLICATE, __ON_SET, __ON_ASSIGN)
             end
 
             local old_component_index = old_component_indices[fragment]
@@ -5024,9 +5151,8 @@ __evolved_multi_set = function(entity, fragments, components)
             if old_component_index then
                 local old_component_storage = old_component_storages[old_component_index]
 
-                local new_component = components[i]
-                if new_component == nil then new_component = fragment_default end
-                if new_component == nil then new_component = true end
+                local new_component = __component_duplicate_construct(
+                    fragment_default, fragment_duplicate, components[i])
 
                 if fragment_on_set or fragment_on_assign then
                     local old_component = old_component_storage[old_place]
@@ -5100,23 +5226,22 @@ __evolved_multi_set = function(entity, fragments, components)
         for i = 1, fragment_count do
             local fragment = fragments[i]
 
+            ---@type evolved.default?, evolved.duplicate?, evolved.set_hook?, evolved.assign_hook?, evolved.insert_hook?
+            local fragment_default, fragment_duplicate, fragment_on_set, fragment_on_assign, fragment_on_insert
+
+            if new_chunk_has_defaults_or_constructs or new_chunk_has_set_or_assign_hooks or new_chunk_has_set_or_insert_hooks then
+                fragment_default, fragment_duplicate, fragment_on_set, fragment_on_assign, fragment_on_insert =
+                    __evolved_get(fragment, __DEFAULT, __DUPLICATE, __ON_SET, __ON_ASSIGN, __ON_INSERT)
+            end
+
             if inserted_set[fragment] or old_fragment_set[fragment] then
-                ---@type evolved.default?, evolved.set_hook?, evolved.assign_hook?
-                local fragment_default, fragment_on_set, fragment_on_assign
-
-                if new_chunk_has_defaults_or_constructs or new_chunk_has_set_or_assign_hooks then
-                    fragment_default, fragment_on_set, fragment_on_assign = __evolved_get(fragment,
-                        __DEFAULT, __ON_SET, __ON_ASSIGN)
-                end
-
                 local new_component_index = new_component_indices[fragment]
 
                 if new_component_index then
                     local new_component_storage = new_component_storages[new_component_index]
 
-                    local new_component = components[i]
-                    if new_component == nil then new_component = fragment_default end
-                    if new_component == nil then new_component = true end
+                    local new_component = __component_duplicate_construct(
+                        fragment_default, fragment_duplicate, components[i])
 
                     if fragment_on_set or fragment_on_assign then
                         local old_component = new_component_storage[new_place]
@@ -5145,22 +5270,13 @@ __evolved_multi_set = function(entity, fragments, components)
             else
                 inserted_set[fragment] = true
 
-                ---@type evolved.default?, evolved.set_hook?, evolved.insert_hook?
-                local fragment_default, fragment_on_set, fragment_on_insert
-
-                if new_chunk_has_defaults_or_constructs or new_chunk_has_set_or_insert_hooks then
-                    fragment_default, fragment_on_set, fragment_on_insert = __evolved_get(fragment,
-                        __DEFAULT, __ON_SET, __ON_INSERT)
-                end
-
                 local new_component_index = new_component_indices[fragment]
 
                 if new_component_index then
                     local new_component_storage = new_component_storages[new_component_index]
 
-                    local new_component = components[i]
-                    if new_component == nil then new_component = fragment_default end
-                    if new_component == nil then new_component = true end
+                    local new_component = __component_duplicate_construct(
+                        fragment_default, fragment_duplicate, components[i])
 
                     new_component_storage[new_place] = new_component
 
@@ -6019,14 +6135,12 @@ end
 ---@param ... any component arguments
 ---@return evolved.entity_builder builder
 function __builder_fns.entity_builder:set(fragment, ...)
-    ---@type evolved.default?, evolved.construct?
-    local fragment_default, fragment_construct = __evolved_get(fragment,
-        __DEFAULT, __CONSTRUCT)
+    ---@type evolved.default?, evolved.construct?, evolved.duplicate?
+    local fragment_default, fragment_construct, fragment_duplicate =
+        __evolved_get(fragment, __DEFAULT, __CONSTRUCT, __DUPLICATE)
 
-    local component = ...
-    if fragment_construct then component = fragment_construct(...) end
-    if component == nil then component = fragment_default end
-    if component == nil then component = true end
+    local component = __component_common_construct(
+        fragment_default, fragment_construct, fragment_duplicate, ...)
 
     local fragment_list = self.__fragment_list
     local component_list = self.__component_list
@@ -6890,21 +7004,29 @@ local function __update_chunk_tags_trace(chunk, fragment)
         component_count = component_count + 1
         chunk.__component_count = component_count
 
-        local storage = {}
+        local storage = __component_storage(fragment)
         local storage_index = component_count
 
         component_indices[fragment] = storage_index
         component_storages[storage_index] = storage
         component_fragments[storage_index] = fragment
 
-        local new_component = __evolved_get(fragment, __DEFAULT)
+        ---@type evolved.default?, evolved.duplicate?
+        local fragment_default, fragment_duplicate =
+            __evolved_get(fragment, __DEFAULT, __DUPLICATE)
 
-        if new_component == nil then
-            new_component = true
-        end
+        if fragment_duplicate then
+            for place = 1, chunk.__entity_count do
+                storage[place] = __component_duplicate_construct(
+                    fragment_default, fragment_duplicate)
+            end
+        else
+            local new_component = __component_simple_construct(
+                fragment_default)
 
-        for i = 1, chunk.__entity_count do
-            storage[i] = new_component
+            for place = 1, chunk.__entity_count do
+                storage[place] = new_component
+            end
         end
     end