@aura3d/ecs 1.0.6

package/src/components/ActiveComponent.ts

@@ -0,0 +1,56 @@
+import { ValidationError } from "@aura3d/core";
+import { type ComponentSchema } from "../Component.js";
+
+export interface SerializedActiveComponent {
+  readonly activeSelf: boolean;
+}
+
+export class ActiveComponent {
+  activeSelf: boolean;
+  activeInHierarchy: boolean;
+
+  constructor(active = true) {
+    if (typeof active !== "boolean") throw new ValidationError("ACTIVE_COMPONENT", "ActiveComponent expects a boolean active state.");
+    this.activeSelf = active;
+    this.activeInHierarchy = active;
+  }
+
+  get isActive(): boolean {
+    return this.activeSelf;
+  }
+
+  get isActiveInHierarchy(): boolean {
+    return this.activeInHierarchy;
+  }
+
+  setActive(active: boolean): void {
+    if (typeof active !== "boolean") throw new ValidationError("ACTIVE_COMPONENT", "Active state must be boolean.");
+    this.activeSelf = active;
+  }
+
+  toggle(): void {
+    this.activeSelf = !this.activeSelf;
+  }
+
+  toJSON(): SerializedActiveComponent {
+    return { activeSelf: this.activeSelf };
+  }
+
+  static readonly schema: ComponentSchema = {
+    version: 1,
+    serialize(component: object): SerializedActiveComponent {
+      const active = component as ActiveComponent;
+      return { activeSelf: active.activeSelf };
+    },
+    deserialize(data: unknown): ActiveComponent {
+      if (!isRecord(data) || typeof data.activeSelf !== "boolean") {
+        throw new ValidationError("ACTIVE_COMPONENT_DESERIALIZE", "ActiveComponent data requires activeSelf boolean.");
+      }
+      return new ActiveComponent(data.activeSelf);
+    }
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}

package/src/components/HierarchyComponent.ts

@@ -0,0 +1,124 @@
+import { ValidationError } from "@aura3d/core";
+import { type ComponentSchema } from "../Component.js";
+import { entityKey, sameEntity, type Entity } from "../Entity.js";
+
+export interface SerializedHierarchyComponent {
+  readonly parent: Entity | null;
+  readonly children: readonly Entity[];
+  readonly previousSibling: Entity | null;
+  readonly nextSibling: Entity | null;
+  readonly depth: number;
+}
+
+export class HierarchyComponent {
+  parent: Entity | null;
+  previousSibling: Entity | null = null;
+  nextSibling: Entity | null = null;
+  depth = 0;
+  private readonly childEntities: Entity[] = [];
+
+  constructor(parent: Entity | null = null) {
+    this.parent = parent;
+  }
+
+  get children(): readonly Entity[] {
+    return this.childEntities;
+  }
+
+  get childCount(): number {
+    return this.childEntities.length;
+  }
+
+  get firstChild(): Entity | null {
+    return this.childEntities[0] ?? null;
+  }
+
+  get lastChild(): Entity | null {
+    return this.childEntities[this.childEntities.length - 1] ?? null;
+  }
+
+  hasParent(): boolean {
+    return this.parent !== null;
+  }
+
+  hasChildren(): boolean {
+    return this.childEntities.length > 0;
+  }
+
+  includesChild(entity: Entity): boolean {
+    return this.childEntities.some((child) => sameEntity(child, entity));
+  }
+
+  forEachChild(callback: (child: Entity) => void): void {
+    for (const child of this.childEntities) callback(child);
+  }
+
+  getSiblingIndex(entity?: Entity): number {
+    if (!entity) return this.parent ? 0 : -1;
+    return this.childEntities.findIndex((child) => sameEntity(child, entity));
+  }
+
+  _setParent(parent: Entity | null): void {
+    this.parent = parent;
+  }
+
+  _addChild(child: Entity): void {
+    if (!this.includesChild(child)) this.childEntities.push(child);
+  }
+
+  _removeChild(child: Entity): boolean {
+    const index = this.childEntities.findIndex((entry) => sameEntity(entry, child));
+    if (index < 0) return false;
+    this.childEntities.splice(index, 1);
+    return true;
+  }
+
+  _clearChildren(): void {
+    this.childEntities.length = 0;
+  }
+
+  _moveChild(child: Entity, index: number): void {
+    const current = this.childEntities.findIndex((entry) => sameEntity(entry, child));
+    if (current < 0) throw new ValidationError("ECS_HIERARCHY_CHILD", `Entity is not a child: ${entityKey(child)}`);
+    const [entry] = this.childEntities.splice(current, 1);
+    this.childEntities.splice(Math.max(0, Math.min(index, this.childEntities.length)), 0, entry);
+  }
+
+  toJSON(): SerializedHierarchyComponent {
+    return {
+      parent: this.parent ? { ...this.parent } : null,
+      children: this.childEntities.map((child) => ({ ...child })),
+      previousSibling: this.previousSibling ? { ...this.previousSibling } : null,
+      nextSibling: this.nextSibling ? { ...this.nextSibling } : null,
+      depth: this.depth
+    };
+  }
+
+  static readonly schema: ComponentSchema = {
+    version: 1,
+    serialize(component: object): SerializedHierarchyComponent {
+      return (component as HierarchyComponent).toJSON();
+    },
+    deserialize(data: unknown): HierarchyComponent {
+      if (!isRecord(data) || !Array.isArray(data.children)) {
+        throw new ValidationError("HIERARCHY_COMPONENT_DESERIALIZE", "HierarchyComponent data requires children array.");
+      }
+      const hierarchy = new HierarchyComponent(isEntity(data.parent) ? data.parent : null);
+      for (const child of data.children) {
+        if (isEntity(child)) hierarchy._addChild(child);
+      }
+      hierarchy.previousSibling = isEntity(data.previousSibling) ? data.previousSibling : null;
+      hierarchy.nextSibling = isEntity(data.nextSibling) ? data.nextSibling : null;
+      hierarchy.depth = typeof data.depth === "number" && Number.isFinite(data.depth) ? Math.max(0, Math.floor(data.depth)) : 0;
+      return hierarchy;
+    }
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isEntity(value: unknown): value is Entity {
+  return isRecord(value) && Number.isSafeInteger(value.id) && Number.isSafeInteger(value.generation);
+}

package/src/components/NameComponent.ts

@@ -0,0 +1,7 @@
+import { ValidationError } from "@aura3d/core";
+
+export class NameComponent {
+  constructor(public name: string) {
+    if (!name) throw new ValidationError("NAME_COMPONENT", "NameComponent requires a non-empty name.");
+  }
+}

package/src/components/TagComponent.ts

@@ -0,0 +1,7 @@
+import { ValidationError } from "@aura3d/core";
+
+export class TagComponent {
+  constructor(public tag: string) {
+    if (!tag) throw new ValidationError("TAG_COMPONENT", "TagComponent requires a non-empty tag.");
+  }
+}

package/src/components/TransformComponent.ts

@@ -0,0 +1,34 @@
+import { Quaternion, Vector3 } from "@aura3d/math";
+
+export class TransformComponent {
+  position: [number, number, number];
+  rotation: [number, number, number, number];
+  scale: [number, number, number];
+
+  constructor(
+    position: Vector3 | readonly [number, number, number] = Vector3.zero.clone(),
+    rotation: Quaternion | readonly [number, number, number, number] = Quaternion.identity.clone(),
+    scale: Vector3 | readonly [number, number, number] = Vector3.one.clone()
+  ) {
+    this.position = position instanceof Vector3 ? position.toArray() : [...position];
+    const normalizedRotation = rotation instanceof Quaternion ? rotation.normalize() : new Quaternion(rotation[0], rotation[1], rotation[2], rotation[3]).normalize();
+    this.rotation = [normalizedRotation.x, normalizedRotation.y, normalizedRotation.z, normalizedRotation.w];
+    this.scale = scale instanceof Vector3 ? scale.toArray() : [...scale];
+  }
+
+  toJSON(): { position: [number, number, number]; rotation: [number, number, number, number]; scale: [number, number, number] } {
+    return {
+      position: [...this.position],
+      rotation: [...this.rotation],
+      scale: [...this.scale]
+    };
+  }
+
+  toMath(): { position: Vector3; rotation: Quaternion; scale: Vector3 } {
+    return {
+      position: new Vector3(this.position[0], this.position[1], this.position[2]),
+      rotation: new Quaternion(this.rotation[0], this.rotation[1], this.rotation[2], this.rotation[3]),
+      scale: new Vector3(this.scale[0], this.scale[1], this.scale[2])
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+export * from "./Entity.js";
+export * from "./EntityManager.js";
+export * from "./Component.js";
+export * from "./ComponentRegistry.js";
+export * from "./SparseSet.js";
+export * from "./Bitset.js";
+export * from "./ComponentStore.js";
+export * from "./Archetype.js";
+export * from "./Query.js";
+export * from "./CommandBuffer.js";
+export * from "./System.js";
+export * from "./SystemScheduler.js";
+export * from "./World.js";
+export * from "./ECSSerializer.js";
+export * from "./ECSProfiler.js";
+export * from "./components/TransformComponent.js";
+export * from "./components/NameComponent.js";
+export * from "./components/TagComponent.js";
+export * from "./components/ActiveComponent.js";
+export * from "./components/HierarchyComponent.js";
+export * from "./systems/index.js";

package/src/systems/ActiveSystem.ts

@@ -0,0 +1,64 @@
+import { type Entity } from "../Entity.js";
+import { type System, type SystemContext } from "../System.js";
+import { type World } from "../World.js";
+import { ActiveComponent } from "../components/ActiveComponent.js";
+import { HierarchyComponent } from "../components/HierarchyComponent.js";
+
+export class ActiveSystem implements System {
+  readonly name = "ActiveSystem";
+  readonly phase = "update";
+  readonly priority = -90;
+  onActiveChanged?: (entity: Entity, activeInHierarchy: boolean) => void;
+
+  update(world: World, _context: SystemContext): void {
+    const memo = new Map<string, boolean>();
+    const entities = world.query({ include: [ActiveComponent] }).toArray().sort((left, right) => {
+      return (world.get(left, HierarchyComponent)?.depth ?? 0) - (world.get(right, HierarchyComponent)?.depth ?? 0);
+    });
+    for (const entity of entities) {
+      const component = world.get(entity, ActiveComponent);
+      if (!component) continue;
+      const previous = component.activeInHierarchy;
+      component.activeInHierarchy = computeActiveInHierarchy(world, entity, memo);
+      if (previous !== component.activeInHierarchy) this.onActiveChanged?.(entity, component.activeInHierarchy);
+    }
+  }
+
+  setActive(world: World, entity: Entity, active: boolean): void {
+    let component = world.get(entity, ActiveComponent);
+    if (!component) {
+      component = new ActiveComponent(active);
+      world.add(entity, ActiveComponent, component);
+    } else {
+      component.setActive(active);
+    }
+    this.update(world, { deltaTime: 0, elapsedTime: 0, frame: 0 });
+  }
+
+  isActive(world: World, entity: Entity): boolean {
+    return world.get(entity, ActiveComponent)?.activeSelf ?? true;
+  }
+
+  isActiveInHierarchy(world: World, entity: Entity): boolean {
+    return world.get(entity, ActiveComponent)?.activeInHierarchy ?? true;
+  }
+
+  getActiveEntities(world: World): Entity[] {
+    return world.query({ include: [ActiveComponent] }).toArray().filter((entity) => this.isActiveInHierarchy(world, entity));
+  }
+
+  getInactiveEntities(world: World): Entity[] {
+    return world.query({ include: [ActiveComponent] }).toArray().filter((entity) => !this.isActiveInHierarchy(world, entity));
+  }
+}
+
+function computeActiveInHierarchy(world: World, entity: Entity, memo: Map<string, boolean>): boolean {
+  const key = `${entity.id}:${entity.generation}`;
+  const cached = memo.get(key);
+  if (cached !== undefined) return cached;
+  const activeSelf = world.get(entity, ActiveComponent)?.activeSelf ?? true;
+  const parent = world.get(entity, HierarchyComponent)?.parent ?? null;
+  const active = activeSelf && (parent ? computeActiveInHierarchy(world, parent, memo) : true);
+  memo.set(key, active);
+  return active;
+}

package/src/systems/HierarchySystem.ts

@@ -0,0 +1,182 @@
+import { ValidationError } from "@aura3d/core";
+import { entityKey, sameEntity, type Entity } from "../Entity.js";
+import { type System, type SystemContext } from "../System.js";
+import { type World } from "../World.js";
+import { HierarchyComponent } from "../components/HierarchyComponent.js";
+
+export class HierarchySystem implements System {
+  readonly name = "HierarchySystem";
+  readonly phase = "update";
+  readonly priority = -100;
+
+  update(world: World, _context: SystemContext): void {
+    for (const entity of world.query({ include: [HierarchyComponent] }).toArray()) {
+      const hierarchy = world.get(entity, HierarchyComponent);
+      if (!hierarchy) continue;
+      if (hierarchy.parent && !world.entities.isAlive(hierarchy.parent)) {
+        hierarchy._setParent(null);
+        hierarchy.depth = 0;
+      }
+    }
+    const cycles = this.detectCycles(world);
+    if (cycles.length > 0) throw new ValidationError("ECS_HIERARCHY_CYCLE", `Hierarchy cycle detected: ${cycles.map(entityKey).join(", ")}`);
+  }
+
+  setParent(world: World, child: Entity, parent: Entity | null): void {
+    world.assertAlive(child);
+    if (parent) world.assertAlive(parent);
+    if (parent && sameEntity(child, parent)) throw new ValidationError("ECS_HIERARCHY_SELF_PARENT", "Entity cannot be parented to itself.");
+    const childHierarchy = ensureHierarchy(world, child);
+    if (parent) ensureHierarchy(world, parent);
+    if (parent && this.isAncestorOf(world, child, parent)) {
+      throw new ValidationError("ECS_HIERARCHY_CYCLE", `Parenting ${entityKey(child)} to ${entityKey(parent)} would create a cycle.`);
+    }
+
+    const previousParent = childHierarchy.parent;
+    if (sameOptionalEntity(childHierarchy.parent, parent)) return;
+    if (previousParent) {
+      world.get(previousParent, HierarchyComponent)?._removeChild(child);
+      this.refreshChildSiblings(world, previousParent);
+    }
+
+    childHierarchy._setParent(parent ? { ...parent } : null);
+    childHierarchy.previousSibling = null;
+    childHierarchy.nextSibling = null;
+    if (parent) {
+      const parentHierarchy = ensureHierarchy(world, parent);
+      parentHierarchy._addChild(child);
+      this.refreshChildSiblings(world, parent);
+      childHierarchy.depth = parentHierarchy.depth + 1;
+    } else {
+      childHierarchy.depth = 0;
+    }
+    this.updateDescendantDepths(world, child);
+  }
+
+  addChild(world: World, parent: Entity, child: Entity): void {
+    this.setParent(world, child, parent);
+  }
+
+  removeFromParent(world: World, entity: Entity): void {
+    this.setParent(world, entity, null);
+  }
+
+  getParent(world: World, entity: Entity): Entity | null {
+    return world.get(entity, HierarchyComponent)?.parent ?? null;
+  }
+
+  getChildren(world: World, entity: Entity): readonly Entity[] {
+    return world.get(entity, HierarchyComponent)?.children ?? [];
+  }
+
+  getDepth(world: World, entity: Entity): number {
+    return world.get(entity, HierarchyComponent)?.depth ?? 0;
+  }
+
+  forEachDescendant(world: World, entity: Entity, callback: (descendant: Entity, depth: number) => void): void {
+    const hierarchy = world.get(entity, HierarchyComponent);
+    if (!hierarchy) return;
+    for (const child of hierarchy.children) {
+      const childHierarchy = world.get(child, HierarchyComponent);
+      callback(child, childHierarchy?.depth ?? hierarchy.depth + 1);
+      this.forEachDescendant(world, child, callback);
+    }
+  }
+
+  isAncestorOf(world: World, ancestor: Entity, descendant: Entity): boolean {
+    let cursor = world.get(descendant, HierarchyComponent)?.parent ?? null;
+    const guard = new Set<string>();
+    while (cursor) {
+      if (sameEntity(cursor, ancestor)) return true;
+      const key = entityKey(cursor);
+      if (guard.has(key)) return false;
+      guard.add(key);
+      cursor = world.get(cursor, HierarchyComponent)?.parent ?? null;
+    }
+    return false;
+  }
+
+  isDescendantOf(world: World, descendant: Entity, ancestor: Entity): boolean {
+    return this.isAncestorOf(world, ancestor, descendant);
+  }
+
+  setSiblingIndex(world: World, entity: Entity, index: number): void {
+    const hierarchy = world.get(entity, HierarchyComponent);
+    if (!hierarchy?.parent) return;
+    world.get(hierarchy.parent, HierarchyComponent)?._moveChild(entity, index);
+    this.refreshChildSiblings(world, hierarchy.parent);
+  }
+
+  detachChildren(world: World, entity: Entity): Entity[] {
+    const children = [...this.getChildren(world, entity)];
+    for (const child of children) this.setParent(world, child, null);
+    return children;
+  }
+
+  validateHierarchy(world: World): boolean {
+    return this.detectCycles(world).length === 0 && world.query({ include: [HierarchyComponent] }).toArray().every((entity) => {
+      const hierarchy = world.get(entity, HierarchyComponent);
+      if (!hierarchy?.parent) return true;
+      const parent = world.get(hierarchy.parent, HierarchyComponent);
+      return Boolean(parent?.includesChild(entity));
+    });
+  }
+
+  detectCycles(world: World): Entity[] {
+    const cycles: Entity[] = [];
+    const visiting = new Set<string>();
+    const visited = new Set<string>();
+    const visit = (entity: Entity): void => {
+      const key = entityKey(entity);
+      if (visiting.has(key)) {
+        cycles.push(entity);
+        return;
+      }
+      if (visited.has(key)) return;
+      visiting.add(key);
+      const parent = world.get(entity, HierarchyComponent)?.parent;
+      if (parent) visit(parent);
+      visiting.delete(key);
+      visited.add(key);
+    };
+    for (const entity of world.query({ include: [HierarchyComponent] }).toArray()) visit(entity);
+    return cycles;
+  }
+
+  private updateDescendantDepths(world: World, entity: Entity): void {
+    const hierarchy = world.get(entity, HierarchyComponent);
+    if (!hierarchy) return;
+    for (const child of hierarchy.children) {
+      const childHierarchy = world.get(child, HierarchyComponent);
+      if (!childHierarchy) continue;
+      childHierarchy.depth = hierarchy.depth + 1;
+      this.updateDescendantDepths(world, child);
+    }
+  }
+
+  private refreshChildSiblings(world: World, parent: Entity): void {
+    const parentHierarchy = world.get(parent, HierarchyComponent);
+    if (!parentHierarchy) return;
+    const children = parentHierarchy.children;
+    for (let index = 0; index < children.length; index += 1) {
+      const child = children[index];
+      const hierarchy = world.get(child, HierarchyComponent);
+      if (!hierarchy) continue;
+      hierarchy.previousSibling = children[index - 1] ? { ...children[index - 1] } : null;
+      hierarchy.nextSibling = children[index + 1] ? { ...children[index + 1] } : null;
+    }
+  }
+}
+
+function ensureHierarchy(world: World, entity: Entity): HierarchyComponent {
+  if (!world.registry.get(HierarchyComponent)) world.registerComponent(HierarchyComponent);
+  const existing = world.get(entity, HierarchyComponent);
+  if (existing) return existing;
+  world.add(entity, HierarchyComponent, new HierarchyComponent());
+  return world.get(entity, HierarchyComponent) as HierarchyComponent;
+}
+
+function sameOptionalEntity(left: Entity | null, right: Entity | null): boolean {
+  if (!left || !right) return left === right;
+  return sameEntity(left, right);
+}

package/src/systems/index.ts

@@ -0,0 +1,2 @@
+export * from "./ActiveSystem.js";
+export * from "./HierarchySystem.js";

package/tests/ecs.test.ts

@@ -0,0 +1,134 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  CommandBuffer,
+  NameComponent,
+  SystemScheduler,
+  TagComponent,
+  TransformComponent,
+  World,
+  deserializeWorld,
+  profileWorld,
+  serializeWorld,
+  type System
+} from "../src/index.js";
+
+class VelocityComponent {
+  constructor(public value: [number, number, number]) {}
+}
+
+test("entities reject stale handles after destroy and reuse", () => {
+  const world = new World();
+  const first = world.createEntity();
+  assert.equal(world.destroyEntity(first), true);
+  const second = world.createEntity();
+
+  assert.equal(first.id, second.id);
+  assert.notEqual(first.generation, second.generation);
+  assert.throws(() => world.get(first, NameComponent), /not alive/);
+});
+
+test("component registration is deterministic per world", () => {
+  const a = new World();
+  const b = new World();
+  a.registerComponent(TransformComponent);
+  a.registerComponent(NameComponent);
+  b.registerComponent(TransformComponent);
+  b.registerComponent(NameComponent);
+
+  assert.equal(a.registry.require(TransformComponent).id, 0);
+  assert.equal(a.registry.require(NameComponent).id, 1);
+  assert.equal(b.registry.require(TransformComponent).id, 0);
+  assert.equal(b.registry.require(NameComponent).id, 1);
+});
+
+test("query include and exclude masks update after component transitions", () => {
+  const world = new World();
+  const moving = world.createEntity();
+  const named = world.createEntity();
+  world.add(moving, TransformComponent, new TransformComponent());
+  world.add(moving, VelocityComponent, new VelocityComponent([1, 0, 0]));
+  world.add(named, TransformComponent, new TransformComponent());
+  world.add(named, NameComponent, new NameComponent("stationary"));
+
+  assert.deepEqual(world.query({ include: [TransformComponent], exclude: [NameComponent] }).toArray(), [moving]);
+
+  world.remove(moving, VelocityComponent);
+  world.add(moving, NameComponent, new NameComponent("moving"));
+
+  assert.deepEqual(world.query({ include: [TransformComponent], exclude: [NameComponent] }).toArray(), []);
+});
+
+test("command buffer supports create/add/destroy during query iteration", () => {
+  const world = new World();
+  const original = world.createEntity();
+  world.add(original, TransformComponent, new TransformComponent());
+  const commands = new CommandBuffer();
+
+  world.query({ include: [TransformComponent] }).forEach((entity) => {
+    const temp = commands.createEntity();
+    commands.add(temp, TransformComponent, new TransformComponent([1, 2, 3]));
+    commands.destroyEntity(entity);
+  });
+  const created = commands.flush(world);
+
+  assert.equal(created.length, 1);
+  assert.deepEqual(world.query({ include: [TransformComponent] }).toArray(), created);
+  assert.deepEqual(world.get(created[0], TransformComponent)?.position, [1, 2, 3]);
+});
+
+test("system scheduler orders dependencies and rejects cycles", () => {
+  const order: string[] = [];
+  const make = (name: string, after: string[] = []): System => ({
+    name,
+    after,
+    update: () => order.push(name)
+  });
+  const scheduler = new SystemScheduler();
+  scheduler.add(make("input"));
+  scheduler.add(make("movement", ["input"]));
+  scheduler.add(make("commit", ["movement"]));
+
+  assert.deepEqual(scheduler.order().map((system) => system.name), ["input", "movement", "commit"]);
+
+  const cycle = new SystemScheduler();
+  cycle.add(make("a", ["b"]));
+  cycle.add(make("b", ["a"]));
+  assert.throws(() => cycle.order(), /cycle rejected/);
+});
+
+test("world update runs fixed, update, and late phases in explicit order", () => {
+  const world = new World();
+  const order: string[] = [];
+  world.systems.add({ name: "late", phase: "late", update: () => order.push("late") });
+  world.systems.add({ name: "fixed", phase: "fixed", update: () => order.push("fixed") });
+  world.systems.add({ name: "update", phase: "update", update: () => order.push("update") });
+
+  world.update({ deltaTime: 1 / 60, elapsedTime: 1, frame: 1 });
+
+  assert.deepEqual(order, ["fixed", "update", "late"]);
+});
+
+test("ECS serialization roundtrips registered component data and remaps entities", () => {
+  const world = new World();
+  world.registerComponent(TransformComponent);
+  world.registerComponent(NameComponent);
+  const entity = world.createEntity();
+  world.add(entity, TransformComponent, new TransformComponent([1, 2, 3]));
+  world.add(entity, NameComponent, new NameComponent("hero"));
+
+  const { world: restored, remap } = deserializeWorld(serializeWorld(world), [TransformComponent, NameComponent]);
+  const restoredEntity = remap.get(`${entity.id}:${entity.generation}`);
+
+  assert.ok(restoredEntity);
+  assert.deepEqual(restored.get(restoredEntity, TransformComponent), { position: [1, 2, 3], rotation: [0, 0, 0, 1], scale: [1, 1, 1] });
+  assert.deepEqual(restored.get(restoredEntity, NameComponent), { name: "hero" });
+});
+
+test("profiler reports entity and component counts", () => {
+  const world = new World();
+  const entity = world.createEntity();
+  world.add(entity, TagComponent, new TagComponent("player"));
+
+  assert.deepEqual(profileWorld(world).components.map((entry) => [entry.name, entry.count]), [["TagComponent", 1]]);
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "dist",
+    "emitDeclarationOnly": true
+  },
+  "include": ["src/**/*.ts"]
+}