test(entity): add tests for dontFragment and cascadeDelete relations

* Implement tests to verify dontFragment behavior in relations.
* Ensure cascadeDelete and dontFragment can be set simultaneously.
* Validate that entities remain in the same archetype with dontFragment.

Author: codehz

src/entity.test.ts

@@ -21,6 +21,7 @@ import {
   getComponentOptions,
   isExclusiveComponent,
   isCascadeDeleteComponent,
+  isDontFragmentComponent,
   getComponentNameById,
   getComponentIdByName,
 } from "./entity";
@@ -455,11 +456,11 @@ describe("Component Options", () => {
 
   it("should support name in options object", () => {
     const namedComp = component({ name: "TestComponent", exclusive: true });
-    
+
     const options = getComponentOptions(namedComp);
     expect(options?.name).toBe("TestComponent");
     expect(options?.exclusive).toBe(true);
-    
+
     expect(getComponentNameById(namedComp)).toBe("TestComponent");
     expect(getComponentIdByName("TestComponent")).toBe(namedComp);
   });
@@ -479,4 +480,23 @@ describe("Component Options", () => {
     expect(isCascadeDeleteComponent(cascadeComp)).toBe(true);
     expect(isCascadeDeleteComponent(normalComp)).toBe(false);
   });
+
+  it("should check if component is dontFragment", () => {
+    const dontFragmentComp = component({ dontFragment: true });
+    const normalComp = component();
+
+    expect(isDontFragmentComponent(dontFragmentComp)).toBe(true);
+    expect(isDontFragmentComponent(normalComp)).toBe(false);
+  });
+
+  it("should support cascadeDelete and dontFragment set simultaneously", () => {
+    const combinedComp = component({ cascadeDelete: true, dontFragment: true });
+
+    const options = getComponentOptions(combinedComp);
+    expect(options?.cascadeDelete).toBe(true);
+    expect(options?.dontFragment).toBe(true);
+
+    expect(isCascadeDeleteComponent(combinedComp)).toBe(true);
+    expect(isDontFragmentComponent(combinedComp)).toBe(true);
+  });
 });

src/world.test.ts

@@ -244,6 +244,74 @@ describe("World", () => {
       expect(world.exists(b)).toBe(false);
     });
 
+    it("should prevent archetype fragmentation with dontFragment relations", () => {
+      const world = new World();
+      const entity1 = world.new();
+      const entity2 = world.new();
+      const target1 = world.new();
+      const target2 = world.new();
+
+      // Create Follows component with dontFragment option
+      const Follows = component<{ strength: number }>({ dontFragment: true });
+
+      const followsTarget1 = relation(Follows, target1);
+      const followsTarget2 = relation(Follows, target2);
+
+      // Add different relations to different entities
+      world.set(entity1, followsTarget1, { strength: 1 });
+      world.set(entity2, followsTarget2, { strength: 2 });
+      world.sync();
+
+      // Both entities should exist and have their relations
+      expect(world.has(entity1, followsTarget1)).toBe(true);
+      expect(world.has(entity2, followsTarget2)).toBe(true);
+
+      // They should be in the same archetype despite having different relation targets
+      // (this is the key behavior of dontFragment)
+      const archetype1 = (world as any).entityToArchetype.get(entity1);
+      const archetype2 = (world as any).entityToArchetype.get(entity2);
+      expect(archetype1).toBe(archetype2);
+
+      // Verify the wildcard marker is present
+      const wildcardMarker = relation(Follows, "*");
+      expect(archetype1.componentTypes).toContain(wildcardMarker);
+    });
+
+    it("should support cascadeDelete and dontFragment simultaneously", () => {
+      const world = new World();
+      const parent = world.new();
+      const child1 = world.new();
+      const child2 = world.new();
+
+      // Create ChildOf component with both cascadeDelete and dontFragment options
+      const ChildOf = component<{ priority: number }>({ cascadeDelete: true, dontFragment: true });
+
+      const childOfParent1 = relation(ChildOf, parent);
+      const childOfParent2 = relation(ChildOf, parent);
+
+      // Add relations to children
+      world.set(child1, childOfParent1, { priority: 1 });
+      world.set(child2, childOfParent2, { priority: 2 });
+      world.sync();
+
+      // Verify relations exist
+      expect(world.has(child1, childOfParent1)).toBe(true);
+      expect(world.has(child2, childOfParent2)).toBe(true);
+
+      // Both children should be in the same archetype (dontFragment behavior)
+      const archetype1 = (world as any).entityToArchetype.get(child1);
+      const archetype2 = (world as any).entityToArchetype.get(child2);
+      expect(archetype1).toBe(archetype2);
+
+      // Delete parent - should cascade delete both children (cascadeDelete behavior)
+      world.delete(parent);
+      world.sync();
+
+      expect(world.exists(parent)).toBe(false);
+      expect(world.exists(child1)).toBe(false);
+      expect(world.exists(child2)).toBe(false);
+    });
+
     it("should handle multiple components", () => {
       const world = new World();
       const entity = world.new();