@codehz/ecs 0.5.1 → 0.5.3

package/{world.d.mts → builder.d.mts}

@@ -1,4 +1,4 @@
-//#region src/entity.d.ts
+//#region src/core/entity-types.d.ts
 /**
  * Unique symbol brand for associating component type information with EntityId
  */
@@ -23,17 +23,6 @@ type EntityRelationId<T = void> = EntityId<T, "entity-relation">;
 type ComponentRelationId<T = void> = EntityId<T, "component-relation">;
 type WildcardRelationId<T = void> = EntityId<T, "wildcard-relation">;
 type RelationId<T = void> = EntityRelationId<T> | ComponentRelationId<T> | WildcardRelationId<T>;
-/**
- * Type for relation ID based on component and target types
- */
-type RelationIdType<T, R> = R extends ComponentId<infer U> ? U extends void ? ComponentRelationId<T> : ComponentRelationId<T extends void ? U : T> : R extends EntityId<any> ? EntityRelationId<T> : never;
-/**
- * Create a relation ID by associating a component with another ID (entity or component)
- * @param componentId The component ID (0-1023)
- * @param targetId The target ID (entity, component, or '*' for wildcard)
- */
-declare function relation<T>(componentId: ComponentId<T>, targetId: "*"): WildcardRelationId<T>;
-declare function relation<T, R extends EntityId<any>>(componentId: ComponentId<T>, targetId: R): RelationIdType<T, R>;
 /**
  * Check if an ID is a component ID
  */
@@ -46,6 +35,19 @@ declare function isEntityId<T>(id: EntityId<T>): id is EntityId<T>;
  * Check if an ID is a relation ID
  */
 declare function isRelationId<T>(id: EntityId<T>): id is RelationId<T>;
+//#endregion
+//#region src/core/entity-relation.d.ts
+/**
+ * Type for relation ID based on component and target types
+ */
+type RelationIdType<T, R> = R extends ComponentId<infer U> ? U extends void ? ComponentRelationId<T> : ComponentRelationId<T extends void ? U : T> : R extends EntityId<any> ? EntityRelationId<T> : never;
+/**
+ * Create a relation ID by associating a component with another ID (entity or component)
+ * @param componentId The component ID (0-1023)
+ * @param targetId The target ID (entity, component, or '*' for wildcard)
+ */
+declare function relation<T>(componentId: ComponentId<T>, targetId: "*"): WildcardRelationId<T>;
+declare function relation<T, R extends EntityId<any>>(componentId: ComponentId<T>, targetId: R): RelationIdType<T, R>;
 /**
  * Check if an ID is a wildcard relation id
  */
@@ -60,6 +62,8 @@ declare function decodeRelationId(relationId: RelationId<any>): {
   targetId: EntityId<any>;
   type: "entity" | "component" | "wildcard";
 };
+//#endregion
+//#region src/core/component-registry.d.ts
 /**
  * Component options that define intrinsic properties
  */
@@ -117,7 +121,57 @@ declare function getComponentIdByName(name: string): ComponentId<any> | undefine
  */
 declare function getComponentNameById(id: ComponentId<any>): string | undefined;
 //#endregion
-//#region src/types.d.ts
+//#region src/commands/changeset.d.ts
+/**
+ * @internal Represents a set of component changes to be applied to an entity
+ */
+declare class ComponentChangeset {
+  readonly adds: Map<EntityId<any>, any>;
+  readonly removes: Set<EntityId<any>>;
+  /**
+   * Add a component to the changeset
+   */
+  set<T>(componentType: EntityId<T>, component: T): void;
+  /**
+   * Remove a component from the changeset
+   */
+  delete<T>(componentType: EntityId<T>): void;
+  /**
+   * Check if the changeset has any changes
+   */
+  hasChanges(): boolean;
+  /**
+   * Clear all changes
+   */
+  clear(): void;
+  /**
+   * Merge another changeset into this one
+   */
+  merge(other: ComponentChangeset): void;
+  /**
+   * Apply the changeset to existing components and return the final state
+   */
+  applyTo(existingComponents: Map<EntityId<any>, any>): Map<EntityId<any>, any>;
+  /**
+   * Get the final component types after applying the changeset
+   * @param existingComponentTypes - The current component types on the entity
+   * @returns The final component types or undefined if no changes
+   */
+  getFinalComponentTypes(existingComponentTypes: EntityId<any>[]): EntityId<any>[] | undefined;
+}
+//#endregion
+//#region src/commands/command-buffer.d.ts
+/**
+ * Command for deferred execution
+ */
+interface Command {
+  type: "set" | "delete" | "destroy";
+  entityId: EntityId;
+  componentType?: EntityId<any>;
+  component?: any;
+}
+//#endregion
+//#region src/core/types.d.ts
 /**
  * Hook types for component lifecycle events
  */
@@ -140,6 +194,16 @@ interface MultiLifecycleHook<T extends readonly ComponentType<any>[]> {
   on_set?: (entityId: EntityId, componentTypes: T, components: ComponentTuple<T>) => void;
   on_remove?: (entityId: EntityId, componentTypes: T, components: ComponentTuple<T>) => void;
 }
+/**
+ * Convenience function type for single component lifecycle events
+ * Combines on_init, on_set, and on_remove into a single callback
+ */
+type LifecycleCallback<T = unknown> = (type: "init" | "set" | "remove", entityId: EntityId, componentType: EntityId<T>, component: T) => void;
+/**
+ * Convenience function type for multi-component lifecycle events
+ * Combines on_init, on_set, and on_remove into a single callback
+ */
+type MultiLifecycleCallback<T extends readonly ComponentType<any>[]> = (type: "init" | "set" | "remove", entityId: EntityId, componentTypes: T, components: ComponentTuple<T>) => void;
 type ComponentType<T> = EntityId<T> | OptionalEntityId<T>;
 type OptionalEntityId<T> = {
   optional: EntityId<T>;
@@ -154,7 +218,7 @@ type ComponentTypeToData<T> = T extends {
  */
 type ComponentTuple<T extends readonly ComponentType<any>[]> = { readonly [K in keyof T]: ComponentTypeToData<T[K]> };
 //#endregion
-//#region src/archetype.d.ts
+//#region src/core/archetype.d.ts
 /**
  * Archetype class for ECS architecture
  * Represents a group of entities that share the same set of components
@@ -186,224 +250,46 @@ declare class Archetype {
   private dontFragmentRelations;
   /**
    * Cache for pre-computed component data sources to avoid repeated calculations
-   * For regular components: data array
-   * For wildcards: matching relation types array
    */
   private componentDataSourcesCache;
-  /**
-   * Create a new archetype with the specified component types
-   * @param componentTypes The component types that define this archetype
-   * @param dontFragmentRelations Reference to the World's dontFragmentRelations storage
-   */
   constructor(componentTypes: EntityId<any>[], dontFragmentRelations: Map<EntityId, Map<EntityId<any>, any>>);
-  /**
-   * Get the number of entities in this archetype
-   */
   get size(): number;
-  /**
-   * Check if this archetype matches the given component types
-   * @param componentTypes The component types to check
-   */
   matches(componentTypes: EntityId<any>[]): boolean;
-  /**
-   * Add an entity to this archetype with initial component data
-   * @param entityId The entity to add
-   * @param componentData Map of component type to component data (includes both regular and dontFragment components)
-   */
   addEntity(entityId: EntityId, componentData: Map<EntityId<any>, any>): void;
-  /**
-   * Get all component data for a specific entity
-   * @param entityId The entity to get data for
-   * @returns Map of component type to component data (includes both regular and dontFragment components)
-   */
+  private addDontFragmentRelations;
   getEntity(entityId: EntityId): Map<EntityId<any>, any> | undefined;
-  /**
-   * Dump all entities and their component data in this archetype
-   * @returns Array of objects with entity and component data (includes both regular and dontFragment components)
-   */
   dump(): Array<{
     entity: EntityId;
     components: Map<EntityId<any>, any>;
   }>;
-  /**
-   * Remove an entity from this archetype
-   * @param entityId The entity to remove
-   * @returns The component data of the removed entity (includes both regular and dontFragment components)
-   */
   removeEntity(entityId: EntityId): Map<EntityId<any>, any> | undefined;
-  /**
-   * Check if an entity is in this archetype
-   * @param entityId The entity to check
-   */
   exists(entityId: EntityId): boolean;
-  /**
-   * Get component data for a specific entity and wildcard relation type
-   * Returns an array of all matching relation instances
-   * @param entityId The entity
-   * @param componentType The wildcard relation type
-   */
   get<T>(entityId: EntityId, componentType: WildcardRelationId<T>): [EntityId<unknown>, any][];
-  /**
-   * Get component data for a specific entity and component type
-   * @param entityId The entity
-   * @param componentType The component type
-   */
   get<T>(entityId: EntityId, componentType: EntityId<T>): T;
-  /**
-   * Get optional component data for a specific entity and component type
-   * @param entityId The entity
-   * @param componentType The component type
-   * @returns { value: T } if component exists, undefined otherwise
-   */
+  private getWildcardRelations;
+  private getRegularComponent;
   getOptional<T>(entityId: EntityId, componentType: EntityId<T>): {
     value: T;
   } | undefined;
-  /**
-   * Set component data for a specific entity and component type
-   * @param entityId The entity
-   * @param componentType The component type
-   * @param data The component data
-   */
   set<T>(entityId: EntityId, componentType: EntityId<T>, data: T): void;
-  /**
-   * Get all entities in this archetype
-   */
   getEntities(): EntityId[];
-  /**
-   * Get the mapping of entities to their indices in this archetype
-   */
   getEntityToIndexMap(): Map<EntityId, number>;
-  /**
-   * Get component data for all entities of a specific component type
-   * @param componentType The component type
-   */
   getComponentData<T>(componentType: EntityId<T>): T[];
-  /**
-   * Get optional component data for all entities of a specific component type
-   * @param componentType The component type
-   * @returns An array of component data or undefined if not present
-   */
   getOptionalComponentData<T>(componentType: EntityId<T>): T[] | undefined;
-  /**
-   * Helper: compute or return cached data sources for provided componentTypes
-   */
   private getCachedComponentDataSources;
-  /**
-   * Build cache key for component types
-   */
-  private buildCacheKey;
-  /**
-   * Get data source for a single component type
-   */
   private getComponentDataSource;
-  /**
-   * Get data source for wildcard relations
-   */
-  private getWildcardRelationDataSource;
-  /**
-   * Helper: build component tuples for a specific entity index using precomputed data sources
-   */
   private buildComponentsForIndex;
-  /**
-   * Build a single component value from its data source
-   */
-  private buildSingleComponent;
-  /**
-   * Build wildcard relation value from matching relations
-   */
-  private buildWildcardRelationValue;
-  /**
-   * Build regular component value from data source
-   */
-  private buildRegularComponentValue;
-  /**
-   * Get entities with their component data for specified component types
-   * Optimized for bulk component access with pre-computed indices
-   * @param componentTypes Array of component types to retrieve
-   * @returns Array of objects with entity and component data
-   */
   getEntitiesWithComponents<const T extends readonly ComponentType<any>[]>(componentTypes: T): Array<{
     entity: EntityId;
     components: ComponentTuple<T>;
   }>;
-  /**
-   * Iterate over entities with their component data for specified component types
-   * implemented as a generator returning each entity/components pair lazily
-   * @param componentTypes Array of component types to retrieve
-   */
   iterateWithComponents<const T extends readonly ComponentType<any>[]>(componentTypes: T): IterableIterator<[EntityId, ...ComponentTuple<T>]>;
-  /**
-   * Iterate over entities with their component data for specified component types
-   * Optimized for bulk component access
-   * @param componentTypes Array of component types to retrieve
-   * @param callback Function called for each entity with its components
-   */
   forEachWithComponents<const T extends readonly ComponentType<any>[]>(componentTypes: T, callback: (entity: EntityId, ...components: ComponentTuple<T>) => void): void;
-  /**
-   * Iterate over all entities with their component data
-   * @param callback Function called for each entity with its component data
-   */
   forEach(callback: (entityId: EntityId, components: Map<EntityId<any>, any>) => void): void;
-  /**
-   * Check if any entity in this archetype has a relation matching the given component ID
-   * This includes both regular relations in componentTypes and dontFragment relations
-   * @param componentId The component ID to match
-   * @returns true if any entity has a matching relation
-   */
   hasRelationWithComponentId(componentId: EntityId<any>): boolean;
 }
 //#endregion
-//#region src/changeset.d.ts
-/**
- * @internal Represents a set of component changes to be applied to an entity
- */
-declare class ComponentChangeset {
-  readonly adds: Map<EntityId<any>, any>;
-  readonly removes: Set<EntityId<any>>;
-  /**
-   * Add a component to the changeset
-   */
-  set<T>(componentType: EntityId<T>, component: T): void;
-  /**
-   * Remove a component from the changeset
-   */
-  delete<T>(componentType: EntityId<T>): void;
-  /**
-   * Check if the changeset has any changes
-   */
-  hasChanges(): boolean;
-  /**
-   * Clear all changes
-   */
-  clear(): void;
-  /**
-   * Merge another changeset into this one
-   */
-  merge(other: ComponentChangeset): void;
-  /**
-   * Apply the changeset to existing components and return the final state
-   */
-  applyTo(existingComponents: Map<EntityId<any>, any>): Map<EntityId<any>, any>;
-  /**
-   * Get the final component types after applying the changeset
-   * @param existingComponentTypes - The current component types on the entity
-   * @returns The final component types or undefined if no changes
-   */
-  getFinalComponentTypes(existingComponentTypes: EntityId<any>[]): EntityId<any>[] | undefined;
-}
-//#endregion
-//#region src/command-buffer.d.ts
-/**
- * Command for deferred execution
- */
-interface Command {
-  type: "set" | "delete" | "destroy";
-  entityId: EntityId;
-  componentType?: EntityId<any>;
-  component?: any;
-}
-//#endregion
-//#region src/query-filter.d.ts
+//#region src/query/filter.d.ts
 /**
  * Filter options for queries
  */
@@ -411,7 +297,7 @@ interface QueryFilter {
   negativeComponentTypes?: EntityId<any>[];
 }
 //#endregion
-//#region src/query.d.ts
+//#region src/query/query.d.ts
 /**
  * Query class for efficient entity queries with cached archetypes
  */
@@ -421,6 +307,8 @@ declare class Query {
   private filter;
   private cachedArchetypes;
   private isDisposed;
+  /** Cached wildcard component types for faster entity filtering */
+  private wildcardTypes;
   constructor(world: World, componentTypes: EntityId<any>[], filter?: QueryFilter);
   /**
    * Check if query is disposed and throw error if so
@@ -430,6 +318,10 @@ declare class Query {
    * Get all entities matching the query
    */
   getEntities(): EntityId[];
+  /**
+   * Check if entity has all required wildcard relations
+   */
+  private entityHasAllWildcards;
   /**
    * Get entities with their component data
    * @param componentTypes Array of component types to retrieve
@@ -469,9 +361,6 @@ declare class Query {
    * Remove an archetype from the cached archetypes
    */
   removeArchetype(archetype: Archetype): void;
-  /**
-   * Dispose the query and disconnect from world
-   */
   /**
    * Request disposal of this query.
    * This will decrement the world's reference count for the query.
@@ -492,331 +381,90 @@ declare class Query {
   get disposed(): boolean;
 }
 //#endregion
-//#region src/world.d.ts
+//#region src/core/serialization.d.ts
 type SerializedEntityId = number | string | {
   component: string;
   target: number | string | "*";
 };
+type SerializedWorld = {
+  version: number;
+  entityManager: any;
+  entities: SerializedEntity[];
+};
+type SerializedEntity = {
+  id: SerializedEntityId;
+  components: SerializedComponent[];
+};
+type SerializedComponent = {
+  type: SerializedEntityId;
+  value: any;
+};
+//#endregion
+//#region src/core/world.d.ts
 /**
  * World class for ECS architecture
  * Manages entities and components
  */
 declare class World {
-  /** Manages allocation and deallocation of entity IDs */
   private entityIdManager;
-  /** Array of all archetypes in the world */
   private archetypes;
-  /** Maps archetype signatures (component type signatures) to archetype instances */
   private archetypeBySignature;
-  /** Maps entity IDs to their current archetype */
   private entityToArchetype;
-  /** Maps component types to arrays of archetypes that contain them */
   private archetypesByComponent;
-  /** Tracks which entities reference each entity as a component type */
   private entityReferences;
-  /** Storage for dontFragment relations - maps entity ID to a map of relation type to component data */
   private dontFragmentRelations;
-  /** Array of all active queries for archetype change notifications */
   private queries;
-  /** Cache for queries keyed by component types and filter signatures */
   private queryCache;
-  /** Buffers structural changes for deferred execution */
   private commandBuffer;
-  /** Stores lifecycle hooks for component and relation events */
   private hooks;
-  /** Stores multi-component lifecycle hooks */
   private multiHooks;
-  /**
-   * Create a new World.
-   * If an optional snapshot object is provided (previously produced by `world.serialize()`),
-   * the world will be restored from that snapshot. The snapshot may contain non-JSON values.
-   */
   constructor(snapshot?: SerializedWorld);
-  /**
-   * Generate a signature string for component types array
-   * @returns A string signature for the component types
-   */
+  private deserializeSnapshot;
   private createArchetypeSignature;
-  /**
-   * Create a new entity
-   * @returns The ID of the newly created entity
-   */
   new<T = void>(): EntityId<T>;
-  /**
-   * Destroy an entity and remove all its components (immediate execution)
-   */
   private destroyEntityImmediate;
-  /**
-   * Check if an entity exists
-   */
   exists(entityId: EntityId): boolean;
-  /**
-   * Add a component to an entity (deferred)
-   */
   set(entityId: EntityId, componentType: EntityId<void>): void;
   set<T>(entityId: EntityId, componentType: EntityId<T>, component: NoInfer<T>): void;
-  /**
-   * Remove a component from an entity (deferred)
-   */
   remove<T>(entityId: EntityId, componentType: EntityId<T>): void;
-  /**
-   * Destroy an entity and remove all its components (deferred)
-   */
   delete(entityId: EntityId): void;
-  /**
-   * Check if an entity has a specific component
-   */
   has<T>(entityId: EntityId, componentType: EntityId<T>): boolean;
-  /**
-   * Get component data for a specific entity and wildcard relation type
-   * Returns an array of all matching relation instances
-   * @param entityId The entity
-   * @param componentType The wildcard relation type
-   * @returns Array of [targetEntityId, componentData] pairs for all matching relations
-   */
   get<T>(entityId: EntityId, componentType: WildcardRelationId<T>): [EntityId<unknown>, T][];
-  /**
-   * Get component data for a specific entity and component type
-   * @param entityId The entity
-   * @param componentType The component type
-   * @returns The component data
-   */
   get<T>(entityId: EntityId, componentType: EntityId<T>): T;
-  /**
-   * Get optional component data for a specific entity and component type
-   * @param entityId The entity
-   * @param componentType The component type
-   * @returns { value: T } if component exists, undefined otherwise
-   */
   getOptional<T>(entityId: EntityId, componentType: EntityId<T>): {
     value: T;
   } | undefined;
-  /**
-   * Register a lifecycle hook for component or wildcard relation events
-   */
-  hook<T>(componentType: EntityId<T>, hook: LifecycleHook<T>): void;
-  hook<const T extends readonly ComponentType<any>[]>(componentTypes: T, hook: MultiLifecycleHook<T>): void;
-  /**
-   * Unregister a lifecycle hook for component or wildcard relation events
-   */
+  hook<T>(componentType: EntityId<T>, hook: LifecycleHook<T> | LifecycleCallback<T>): void;
+  hook<const T extends readonly ComponentType<any>[]>(componentTypes: T, hook: MultiLifecycleHook<T> | MultiLifecycleCallback<T>): void;
   unhook<T>(componentType: EntityId<T>, hook: LifecycleHook<T>): void;
   unhook<const T extends readonly ComponentType<any>[]>(componentTypes: T, hook: MultiLifecycleHook<T>): void;
-  /**
-   * Execute all deferred commands immediately
-   */
   sync(): void;
-  /**
-   * Create a cached query for efficient entity lookups
-   * @returns A Query object for the specified component types and filter
-   */
   createQuery(componentTypes: EntityId<any>[], filter?: QueryFilter): Query;
-  /**
-   * Create an EntityBuilder for convenient entity creation.
-   * @returns EntityBuilder
-   */
   spawn(): EntityBuilder;
-  /**
-   * Spawn multiple entities using an EntityBuilder configuration callback
-   * @param count number of entities
-   * @param configure builder configuration callback
-   * @returns Created entity IDs
-   */
   spawnMany(count: number, configure: (builder: EntityBuilder, index: number) => EntityBuilder): EntityId[];
-  /**
-   * @internal Register a query for archetype update notifications
-   */
   _registerQuery(query: Query): void;
-  /**
-   * @internal Unregister a query
-   */
   _unregisterQuery(query: Query): void;
-  /**
-   * Release a query reference obtained from createQuery.
-   * Decrements the refCount and fully disposes the query when it reaches zero.
-   */
   releaseQuery(query: Query): void;
-  /**
-   * @internal Get archetypes that match specific component types (for internal use by queries)
-   */
   getMatchingArchetypes(componentTypes: EntityId<any>[]): Archetype[];
-  /**
-   * Query entities with specific components
-   * @returns Array of entity IDs that have all the specified components
-   */
+  private getArchetypesWithComponents;
   query(componentTypes: EntityId<any>[]): EntityId[];
   query<const T extends readonly EntityId<any>[]>(componentTypes: T, includeComponents: true): Array<{
     entity: EntityId;
     components: ComponentTuple<T>;
   }>;
-  /**
-   * @internal Execute commands for a single entity (for internal use by CommandBuffer)
-   * @returns ComponentChangeset describing the changes made
-   */
   executeEntityCommands(entityId: EntityId, commands: Command[]): ComponentChangeset;
-  /**
-   * Process commands and populate the changeset
-   */
-  private processCommands;
-  /**
-   * Process a set command, handling exclusive relations
-   */
-  private processSetCommand;
-  /**
-   * Remove all relations with the same base component (for exclusive relations)
-   */
-  private removeExclusiveRelations;
-  private isRelationWithComponent;
-  /**
-   * Process a delete command, handling wildcard relations
-   */
-  private processDeleteCommand;
-  /**
-   * Remove all relations matching a wildcard component ID
-   */
-  private removeWildcardRelations;
-  /**
-   * Remove a single component from an entity immediately, handling dontFragment relations correctly.
-   * Used by destroyEntityImmediate for non-cascade relation cleanup.
-   */
+  private createHooksContext;
   private removeComponentImmediate;
-  /**
-   * Apply changeset to entity, moving to new archetype if needed
-   * @returns Map of removed components with their data
-   */
-  private applyChangeset;
-  /**
-   * Move entity to a new archetype with updated components
-   */
-  private moveEntityToNewArchetype;
-  /**
-   * Update entity in same archetype (no archetype change needed)
-   */
-  private updateEntityInSameArchetype;
-  /**
-   * Apply dontFragment relation changes directly to World's storage
-   * This is much more efficient than the removeEntity + addEntity approach
-   */
-  private applyDontFragmentChanges;
-  /**
-   * Update entity reference tracking based on changeset
-   */
   private updateEntityReferences;
-  /**
-   * Get or create an archetype for the given component types
-   * Filters out dontFragment relations from the archetype signature
-   * @returns The archetype for the given component types (excluding dontFragment relations)
-   */
   private ensureArchetype;
-  /**
-   * Compare two arrays of component types for equality (order-independent)
-   */
-  private areComponentTypesEqual;
-  /**
-   * Filter out dontFragment relations from component types, but keep wildcard markers
-   */
-  private filterRegularComponentTypes;
-  /**
-   * Create a new archetype and register it with all tracking structures
-   */
   private createNewArchetype;
-  /**
-   * Register archetype in the component-to-archetype index
-   */
-  private registerArchetypeInComponentIndex;
-  /**
-   * Notify all queries to check the new archetype
-   */
-  private notifyQueriesOfNewArchetype;
-  /**
-   * Add a component reference to the reverse index when an entity is used as a component type
-   * @param sourceEntityId The entity that has the component
-   * @param componentType The component type (which may be an entity ID used as component type)
-   * @param targetEntityId The entity being used as component type
-   */
-  private trackEntityReference;
-  /**
-   * Remove a component reference from the reverse index
-   * @param sourceEntityId The entity that has the component
-   * @param componentType The component type
-   * @param targetEntityId The entity being used as component type
-   */
-  private untrackEntityReference;
-  /**
-   * Get all component references where a target entity is used as a component type
-   * @param targetEntityId The target entity
-   * @returns A MultiMap of sourceEntityId to componentTypes that reference the target entity
-   */
-  private getEntityReferences;
-  /**
-   * Check if an archetype's signature references a specific entity
-   * (via entity-relation targeting the entity, or using entity as component type)
-   */
   private archetypeReferencesEntity;
-  /**
-   * Cleanup empty archetypes that reference a specific deleted entity
-   * Only removes archetypes whose component types reference the entity
-   */
   private cleanupArchetypesReferencingEntity;
-  /**
-   * Remove archetype from the main archetypes list
-   */
-  private removeArchetypeFromList;
-  /**
-   * Remove archetype from the signature-to-archetype map
-   */
-  private removeArchetypeFromSignatureMap;
-  /**
-   * Remove archetype from the component-to-archetypes index
-   */
-  private removeArchetypeFromComponentIndex;
-  /**
-   * Remove archetype from all queries
-   */
-  private removeArchetypeFromQueries;
-  /**
-   * Execute component lifecycle hooks for added and removed components
-   */
-  private triggerLifecycleHooks;
-  /**
-   * Trigger multi-component hooks based on changes
-   */
-  private triggerMultiComponentHooks;
-  /**
-   * Check if entity currently has all required components
-   */
-  private entityHasAllComponents;
-  /**
-   * Check if entity had all required components before removal
-   */
-  private entityHadAllComponentsBefore;
-  /**
-   * Collect component values for multi-component hook (current state)
-   */
-  private collectMultiHookComponents;
-  /**
-   * Collect component values for multi-component hook with removed components (snapshot before removal)
-   */
-  private collectMultiHookComponentsWithRemoved;
-  /**
-   * Convert the world into a plain snapshot object.
-   * This returns an in-memory structure and does not perform JSON stringification.
-   * Component values are stored as-is (they may be non-JSON-serializable).
-   */
+  private removeArchetype;
   serialize(): SerializedWorld;
 }
-type SerializedWorld = {
-  version: number;
-  entityManager: any;
-  entities: SerializedEntity[];
-};
-type SerializedEntity = {
-  id: SerializedEntityId;
-  components: SerializedComponent[];
-};
-type SerializedComponent = {
-  type: SerializedEntityId;
-  value: any;
-};
+//#endregion
+//#region src/core/builder.d.ts
 /**
  * A component definition for entity building, supporting both regular components and relations
  */
@@ -847,5 +495,5 @@ declare class EntityBuilder {
   build(): EntityId;
 }
 //#endregion
-export { isComponentId as C, relation as D, isWildcardRelationId as E, getComponentNameById as S, isRelationId as T, RelationId as _, SerializedEntityId as a, decodeRelationId as b, Query as c, LifecycleHook as d, ComponentId as f, EntityRelationId as g, EntityId as h, SerializedEntity as i, ComponentTuple as l, ComponentRelationId as m, EntityBuilder as n, SerializedWorld as o, ComponentOptions as p, SerializedComponent as r, World as s, ComponentDef as t, ComponentType as u, WildcardRelationId as v, isEntityId as w, getComponentIdByName as x, component as y };
-//# sourceMappingURL=world.d.mts.map
+export { isRelationId as A, ComponentRelationId as C, WildcardRelationId as D, RelationId as E, isComponentId as O, ComponentId as S, EntityRelationId as T, getComponentIdByName as _, SerializedEntity as a, isWildcardRelationId as b, Query as c, LifecycleCallback as d, LifecycleHook as f, component as g, ComponentOptions as h, SerializedComponent as i, isEntityId as k, ComponentTuple as l, MultiLifecycleHook as m, EntityBuilder as n, SerializedEntityId as o, MultiLifecycleCallback as p, World as r, SerializedWorld as s, ComponentDef as t, ComponentType as u, getComponentNameById as v, EntityId as w, relation as x, decodeRelationId as y };
+//# sourceMappingURL=builder.d.mts.map