archetype-ecs 1.4.2 → 1.5.0

package/src/EntityManager.ts

@@ -1,11 +1,13 @@
-import { TYPED, componentSchemas, toSym, type ComponentDef, type TypeSpec } from './ComponentRegistry.js';
+import { TYPED, componentSchemas, toSym, type ComponentDef, type TypeSpec, type FieldRef } from './ComponentRegistry.js';
+import { WasmArena, type NumericTypedArrayConstructor } from './WasmArena.js';
+import { instantiateKernelsSync, isWasmSimdAvailable, type IterateKernels } from './wasm-kernels.js';
+
+export type { FieldRef } from './ComponentRegistry.js';
 
 export type EntityId = number;
 
-export interface FieldRef {
-  readonly _sym: symbol;
-  readonly _field: string;
-}
+export type SoAArrayValue = Float32Array | Float64Array | Int8Array | Int16Array | Int32Array
+  | Uint8Array | Uint16Array | Uint32Array | unknown[];
 
 export interface ArchetypeView {
   readonly id: number;
@@ -15,6 +17,8 @@ export interface ArchetypeView {
   readonly snapshotCount: number;
   field(ref: FieldRef): any;
   fieldStride(ref: FieldRef): number;
+  fieldOffset(ref: FieldRef): number;
+  fieldAdd(target: FieldRef, source: FieldRef): void;
   snapshot(ref: FieldRef): any;
 }
 
@@ -24,14 +28,16 @@ export interface SerializedData {
   components: Record<string, Record<string, unknown>>;
 }
 
+export type ComponentData = Record<string, number | string | ArrayLike<number>> | null | undefined;
+
 export interface EntityManager {
   createEntity(): EntityId;
   destroyEntity(id: EntityId): void;
-  addComponent(entityId: EntityId, type: ComponentDef, data?: any): void;
+  addComponent(entityId: EntityId, type: ComponentDef, data?: ComponentData): void;
   removeComponent(entityId: EntityId, type: ComponentDef): void;
-  getComponent(entityId: EntityId, type: ComponentDef): any;
-  get(entityId: EntityId, fieldRef: FieldRef): any;
-  set(entityId: EntityId, fieldRef: FieldRef, value: any): void;
+  getComponent(entityId: EntityId, type: ComponentDef): Record<string, number | string | number[]> | undefined;
+  get(entityId: EntityId, fieldRef: FieldRef): number | string | undefined;
+  set(entityId: EntityId, fieldRef: FieldRef, value: number | string | ArrayLike<number>): void;
   hasComponent(entityId: EntityId, type: ComponentDef): boolean;
   query(include: ComponentDef[], exclude?: ComponentDef[]): EntityId[];
   getAllEntities(): EntityId[];
@@ -41,6 +47,7 @@ export interface EntityManager {
   onAdd(type: ComponentDef, callback: (entityId: EntityId) => void): () => void;
   onRemove(type: ComponentDef, callback: (entityId: EntityId) => void): () => void;
   flushHooks(): void;
+  commitRemovals(): void;
   enableTracking(filterComponent: ComponentDef): void;
   flushChanges(): { created: Set<EntityId>; destroyed: Set<EntityId> };
   flushSnapshots(): void;
@@ -55,6 +62,7 @@ export interface EntityManager {
     nameToSymbol: Record<string, ComponentDef>,
     options?: { deserializers?: Map<string, (data: unknown) => unknown> }
   ): void;
+  readonly wasmMemory: WebAssembly.Memory | null;
 }
 
 // ── Internal types ───────────────────────────────────────
@@ -64,10 +72,10 @@ interface SoAStore {
   _schema: Record<string, TypeSpec>;
   _capacity: number;
   _arraySizes: Record<string, number>;
-  [field: string]: any;
+  _fields: Record<string, SoAArrayValue>;
 }
 
-type SnapshotStore = Record<string, any>;
+type SnapshotStore = Record<string, SoAArrayValue>;
 
 interface Archetype {
   key: Uint32Array;
@@ -151,78 +159,93 @@ function maskKey(mask: Uint32Array): string {
 
 // ── SoA helpers ──────────────────────────────────────────
 
-function unpackSpec(spec: TypeSpec): [any, number] {
+function unpackSpec(spec: TypeSpec): [{ new(len: number): SoAArrayValue }, number] {
   if (Array.isArray(spec)) return spec;
   return [spec, 0];
 }
 
-function createSoAStore(schema: Record<string, TypeSpec>, capacity: number): SoAStore {
-  const store: any = { [TYPED]: true, _schema: schema, _capacity: capacity, _arraySizes: {} };
+function createSoAStore(schema: Record<string, TypeSpec>, capacity: number, arena?: WasmArena): SoAStore {
+  const fields: Record<string, SoAArrayValue> = {};
+  const arraySizes: Record<string, number> = {};
   for (const [field, spec] of Object.entries(schema)) {
     const [Ctor, size] = unpackSpec(spec);
-    if (size > 0) {
-      store[field] = new Ctor(capacity * size);
-      store._arraySizes[field] = size;
+    const count = size > 0 ? capacity * size : capacity;
+    if (size > 0) arraySizes[field] = size;
+    if (arena && Ctor !== Array) {
+      const NumCtor = Ctor as unknown as NumericTypedArrayConstructor;
+      const offset = arena.alloc(count * NumCtor.BYTES_PER_ELEMENT);
+      arena.createView(NumCtor, offset, count, fields, field);
     } else {
-      store[field] = new Ctor(capacity);
+      fields[field] = new Ctor(count);
     }
   }
-  return store;
+  return { [TYPED]: true, _schema: schema, _capacity: capacity, _arraySizes: arraySizes, _fields: fields };
 }
 
-function growSoAStore(store: SoAStore, newCapacity: number): void {
+function growSoAStore(store: SoAStore, newCapacity: number, arena?: WasmArena): void {
   store._capacity = newCapacity;
   for (const [field, spec] of Object.entries(store._schema)) {
     const [Ctor, size] = unpackSpec(spec);
-    const old = store[field];
+    const old = store._fields[field];
     const allocSize = size > 0 ? newCapacity * size : newCapacity;
-    store[field] = new Ctor(allocSize);
-    if (Ctor === Array) {
-      for (let i = 0; i < old.length; i++) store[field][i] = old[i];
+    if (arena && Ctor !== Array) {
+      const NumCtor = Ctor as unknown as NumericTypedArrayConstructor;
+      const offset = arena.alloc(allocSize * NumCtor.BYTES_PER_ELEMENT);
+      arena.updateView(store._fields, field, offset, NumCtor, allocSize);
+      (store._fields[field] as Exclude<SoAArrayValue, unknown[]>).set(old as Exclude<SoAArrayValue, unknown[]>);
     } else {
-      store[field].set(old);
+      const grown = new Ctor(allocSize);
+      if (Ctor === Array) {
+        for (let i = 0; i < old.length; i++) (grown as unknown[])[i] = (old as unknown[])[i];
+      } else {
+        (grown as Exclude<SoAArrayValue, unknown[]>).set(old as Exclude<SoAArrayValue, unknown[]>);
+      }
+      store._fields[field] = grown;
     }
   }
 }
 
-function soaWrite(store: SoAStore, idx: number, data: any): void {
+function soaWrite(store: SoAStore, idx: number, data: ComponentData): void {
   if (!data) {
     for (const field in store._schema) {
+      const arr = store._fields[field];
       const size = store._arraySizes[field] || 0;
       if (size > 0) {
         const base = idx * size;
-        for (let j = 0; j < size; j++) store[field][base + j] = 0;
+        for (let j = 0; j < size; j++) (arr as never[])[base + j] = 0 as never;
       } else {
-        store[field][idx] = 0;
+        (arr as never[])[idx] = 0 as never;
       }
     }
     return;
   }
   for (const field in store._schema) {
+    const arr = store._fields[field];
     const size = store._arraySizes[field] || 0;
     if (size > 0) {
       const base = idx * size;
       const src = data[field];
       if (src) {
         for (let j = 0; j < size; j++) {
-          store[field][base + j] = src[j] ?? 0;
+          (arr as never[])[base + j] = ((src as ArrayLike<number>)[j] ?? 0) as never;
         }
       }
     } else {
-      store[field][idx] = data[field];
+      (arr as never[])[idx] = data[field] as never;
     }
   }
 }
 
-function soaRead(store: SoAStore, idx: number): Record<string, any> {
-  const obj: Record<string, any> = {};
+function soaRead(store: SoAStore, idx: number): Record<string, number | string | number[]> {
+  const obj: Record<string, number | string | number[]> = {};
   for (const field in store._schema) {
+    const arr = store._fields[field];
     const size = store._arraySizes[field] || 0;
     if (size > 0) {
       const base = idx * size;
-      obj[field] = Array.from(store[field].subarray(base, base + size));
+      obj[field] = Array.from((arr as Float32Array).subarray(base, base + size));
     } else {
-      obj[field] = store[field][idx];
+      obj[field] = (arr as never[])[idx];
     }
   }
   return obj;
@@ -230,7 +253,7 @@ function soaRead(store: SoAStore, idx: number): Record<string, any> {
 
 function soaSwap(store: SoAStore, idxA: number, idxB: number): void {
   for (const field in store._schema) {
-    const arr = store[field];
+    const arr = store._fields[field] as never[];
     const size = store._arraySizes[field] || 0;
     if (size > 0) {
       const baseA = idxA * size;
@@ -248,36 +271,51 @@ function soaSwap(store: SoAStore, idxA: number, idxB: number): void {
   }
 }
 
-function createSnapshotStore(schema: Record<string, TypeSpec>, capacity: number): SnapshotStore {
+function createSnapshotStore(schema: Record<string, TypeSpec>, capacity: number, arena?: WasmArena): SnapshotStore {
   const snap: SnapshotStore = {};
   for (const [field, spec] of Object.entries(schema)) {
     const [Ctor, size] = unpackSpec(spec);
-    snap[field] = new Ctor(size > 0 ? capacity * size : capacity);
+    const count = size > 0 ? capacity * size : capacity;
+    if (arena && Ctor !== Array) {
+      const NumCtor = Ctor as unknown as NumericTypedArrayConstructor;
+      const offset = arena.alloc(count * NumCtor.BYTES_PER_ELEMENT);
+      arena.createView(NumCtor, offset, count, snap, field);
+    } else {
+      snap[field] = new Ctor(count);
+    }
   }
   return snap;
 }
 
-function growSnapshotStore(snap: SnapshotStore, schema: Record<string, TypeSpec>, newCapacity: number): void {
+function growSnapshotStore(snap: SnapshotStore, schema: Record<string, TypeSpec>, newCapacity: number, arena?: WasmArena): void {
   for (const [field, spec] of Object.entries(schema)) {
     const [Ctor, size] = unpackSpec(spec);
     const old = snap[field];
-    snap[field] = new Ctor(size > 0 ? newCapacity * size : newCapacity);
-    if (Ctor === Array) {
-      for (let i = 0; i < old.length; i++) snap[field][i] = old[i];
+    const allocSize = size > 0 ? newCapacity * size : newCapacity;
+    if (arena && Ctor !== Array) {
+      const NumCtor = Ctor as unknown as NumericTypedArrayConstructor;
+      const offset = arena.alloc(allocSize * NumCtor.BYTES_PER_ELEMENT);
+      arena.updateView(snap, field, offset, NumCtor, allocSize);
+      (snap[field] as Exclude<SoAArrayValue, unknown[]>).set(old as Exclude<SoAArrayValue, unknown[]>);
     } else {
-      snap[field].set(old);
+      const grown = new Ctor(allocSize);
+      if (Ctor === Array) {
+        for (let i = 0; i < old.length; i++) (grown as unknown[])[i] = (old as unknown[])[i];
+      } else {
+        (grown as Exclude<SoAArrayValue, unknown[]>).set(old as Exclude<SoAArrayValue, unknown[]>);
+      }
+      snap[field] = grown;
     }
   }
 }
 
 // ── Entity Manager ───────────────────────────────────────
 
-type DeferredOp =
-  | { kind: 'add'; entityId: EntityId; comp: ComponentDef; data?: any }
-  | { kind: 'remove'; entityId: EntityId; comp: ComponentDef }
-  | { kind: 'destroy'; entityId: EntityId };
+export function createEntityManager(options?: { wasm?: boolean }): EntityManager {
+  const useWasm = options?.wasm ?? isWasmSimdAvailable();
+  const arena = useWasm ? new WasmArena() : undefined;
+  const kernels: IterateKernels | null = arena ? instantiateKernelsSync(arena.memory) : null;
 
-export function createEntityManager(): EntityManager {
   let nextId: EntityId = 1;
   let nextArchId = 1;
   const allEntityIds = new Set<EntityId>();
@@ -289,7 +327,13 @@ export function createEntityManager(): EntityManager {
 
   let hooks: Hooks | null = null;
 
+  const removedData = new Map<EntityId, Map<symbol, Record<string, number | string | number[]>>>();
+
   // Deferred structural changes during forEach iteration
+  type DeferredOp =
+    | { kind: 'add'; entityId: EntityId; comp: ComponentDef; data?: ComponentData }
+    | { kind: 'remove'; entityId: EntityId; comp: ComponentDef }
+    | { kind: 'destroy'; entityId: EntityId };
   let iterating = 0;
   const deferred: DeferredOp[] = [];
 
@@ -342,10 +386,10 @@ export function createEntityManager(): EntityManager {
       };
       for (const t of types) {
         const schema = componentSchemas.get(t);
-        const store = schema ? createSoAStore(schema, INITIAL_CAPACITY) : null;
+        const store = schema ? createSoAStore(schema, INITIAL_CAPACITY, arena) : null;
         arch.components.set(t, store);
         if (tracked && store) {
-          arch.snapshots!.set(t, createSnapshotStore(schema!, INITIAL_CAPACITY));
+          arch.snapshots!.set(t, createSnapshotStore(schema!, INITIAL_CAPACITY, arena));
         }
       }
       archetypes.set(key, arch);
@@ -361,22 +405,22 @@ export function createEntityManager(): EntityManager {
     arch.capacity = newCap;
     for (const [type, store] of arch.components) {
       if (store) {
-        growSoAStore(store, newCap);
+        growSoAStore(store, newCap, arena);
         if (arch.snapshots) {
           const snap = arch.snapshots.get(type);
-          if (snap) growSnapshotStore(snap, store._schema, newCap);
+          if (snap) growSnapshotStore(snap, store._schema, newCap, arena);
         }
       }
     }
   }
 
-  function addToArchetype(arch: Archetype, entityId: EntityId, componentMap: Record<symbol, any>): void {
+  function addToArchetype(arch: Archetype, entityId: EntityId, componentMap: Map<symbol, ComponentData>): void {
     ensureCapacity(arch);
     const idx = arch.count;
     arch.entityIds[idx] = entityId;
     for (const t of arch.types) {
       const store = arch.components.get(t);
-      if (store) soaWrite(store, idx, (componentMap as any)[t]);
+      if (store) soaWrite(store, idx, componentMap.get(t));
     }
     arch.entityToIndex.set(entityId, idx);
     arch.count++;
@@ -402,7 +446,7 @@ export function createEntityManager(): EntityManager {
     entityArchetype.delete(entityId);
   }
 
-  function readComponentData(arch: Archetype, type: symbol, idx: number): any {
+  function readComponentData(arch: Archetype, type: symbol, idx: number): Record<string, number | string | number[]> | undefined {
     const store = arch.components.get(type);
     if (!store) return undefined;
     return soaRead(store, idx);
@@ -430,8 +474,6 @@ export function createEntityManager(): EntityManager {
     return matching;
   }
 
-  // ── Internal structural change implementations ──────────
-
   function doDestroyEntity(id: EntityId): void {
     const arch = entityArchetype.get(id);
     if (arch) {
@@ -440,6 +482,19 @@ export function createEntityManager(): EntityManager {
           const pending = hooks.pendingRemove.get(type);
           if (pending) pending.push(id);
         }
+        if (hooks.removeCbs.size > 0) {
+          const idx = arch.entityToIndex.get(id)!;
+          let entitySnap: Map<symbol, Record<string, number | string | number[]>> | undefined;
+          for (const type of arch.types) {
+            if (hooks.removeCbs.has(type)) {
+              const store = arch.components.get(type);
+              if (store) {
+                if (!entitySnap) { entitySnap = new Map(); removedData.set(id, entitySnap); }
+                entitySnap.set(type, soaRead(store, idx));
+              }
+            }
+          }
+        }
       }
       if (destroyedSet && trackFilter && maskOverlaps(arch.key, trackFilter)) destroyedSet.add(id);
       removeFromArchetype(arch, id);
@@ -447,13 +502,13 @@ export function createEntityManager(): EntityManager {
     allEntityIds.delete(id);
   }
 
-  function doAddComponent(entityId: EntityId, comp: ComponentDef, data?: any): void {
+  function doAddComponent(entityId: EntityId, comp: ComponentDef, data?: ComponentData): void {
     const type = toSym(comp);
     const arch = entityArchetype.get(entityId);
 
     if (!arch) {
       const newArch = getOrCreateArchetype([type]);
-      addToArchetype(newArch, entityId, { [type as unknown as string]: data });
+      addToArchetype(newArch, entityId, new Map([[type, data]]));
       if (hooks) {
         const pending = hooks.pendingAdd.get(type);
         if (pending) pending.push(entityId);
@@ -474,9 +529,9 @@ export function createEntityManager(): EntityManager {
     const newArch = getOrCreateArchetype(newTypes);
 
     const idx = arch.entityToIndex.get(entityId)!;
-    const map: any = { [type as unknown as string]: data };
+    const map = new Map<symbol, ComponentData>([[type, data]]);
     for (const t of arch.types) {
-      map[t as unknown as string] = readComponentData(arch, t, idx);
+      map.set(t, readComponentData(arch, t, idx));
     }
 
     removeFromArchetype(arch, entityId);
@@ -495,6 +550,14 @@ export function createEntityManager(): EntityManager {
     if (hooks) {
       const pending = hooks.pendingRemove.get(type);
       if (pending) pending.push(entityId);
+      if (hooks.removeCbs.has(type)) {
+        const store = arch.components.get(type);
+        if (store) {
+          const idx = arch.entityToIndex.get(entityId)!;
+          if (!removedData.has(entityId)) removedData.set(entityId, new Map());
+          removedData.get(entityId)!.set(type, soaRead(store, idx));
+        }
+      }
     }
 
     if (destroyedSet && trackFilter && maskOverlaps(arch.key, trackFilter)) destroyedSet.add(entityId);
@@ -511,9 +574,9 @@ export function createEntityManager(): EntityManager {
     const newArch = getOrCreateArchetype(newTypes);
 
     const idx = arch.entityToIndex.get(entityId)!;
-    const map: any = {};
+    const map = new Map<symbol, ComponentData>();
     for (const t of newTypes) {
-      map[t as unknown as string] = readComponentData(arch, t, idx);
+      map.set(t, readComponentData(arch, t, idx));
     }
 
     removeFromArchetype(arch, entityId);
@@ -521,28 +584,19 @@ export function createEntityManager(): EntityManager {
   }
 
   function flushDeferred(): void {
-    // Process deferred ops in order. New ops may be added during flush
-    // (e.g. hooks triggering more structural changes), so use index loop.
-    while (deferred.length > 0) {
-      const ops = deferred.splice(0);
-      for (let i = 0; i < ops.length; i++) {
-        const op = ops[i];
-        switch (op.kind) {
-          case 'add':
-            doAddComponent(op.entityId, op.comp, op.data);
-            break;
-          case 'remove':
-            doRemoveComponent(op.entityId, op.comp);
-            break;
-          case 'destroy':
-            doDestroyEntity(op.entityId);
-            break;
-        }
+    const ops = deferred.splice(0);
+    for (const op of ops) {
+      switch (op.kind) {
+        case 'add': doAddComponent(op.entityId, op.comp, op.data); break;
+        case 'remove': doRemoveComponent(op.entityId, op.comp); break;
+        case 'destroy': doDestroyEntity(op.entityId); break;
       }
     }
   }
 
   return {
+    wasmMemory: arena ? arena.memory : null,
+
     createEntity(): EntityId {
       const id = nextId++;
       allEntityIds.add(id);
@@ -557,7 +611,7 @@ export function createEntityManager(): EntityManager {
       doDestroyEntity(id);
     },
 
-    addComponent(entityId: EntityId, comp: ComponentDef, data?: any): void {
+    addComponent(entityId: EntityId, comp: ComponentDef, data?: ComponentData): void {
       if (iterating > 0) {
         // In-place overwrite (entity already has component) is safe — no migration
         const type = toSym(comp);
@@ -585,30 +639,43 @@ export function createEntityManager(): EntityManager {
       doRemoveComponent(entityId, comp);
     },
 
-    getComponent(entityId: EntityId, comp: ComponentDef): any {
+    getComponent(entityId: EntityId, comp: ComponentDef): Record<string, number | string | number[]> | undefined {
       const type = toSym(comp);
       const arch = entityArchetype.get(entityId);
-      if (!arch) return undefined;
-      const idx = arch.entityToIndex.get(entityId);
-      if (idx === undefined) return undefined;
-      return readComponentData(arch, type, idx);
+      if (arch) {
+        const idx = arch.entityToIndex.get(entityId);
+        if (idx !== undefined) return readComponentData(arch, type, idx);
+      }
+      // Fallback: check recently-removed data (accessible during @OnRemoved hooks)
+      const removed = removedData.get(entityId);
+      if (removed) return removed.get(type);
+      return undefined;
     },
 
-    get(entityId: EntityId, fieldRef: FieldRef): any {
+    get(entityId: EntityId, fieldRef: FieldRef): number | string | undefined {
       const arch = entityArchetype.get(entityId);
-      if (!arch) return undefined;
-      const store = arch.components.get(fieldRef._sym);
-      if (!store) return undefined;
-      const idx = arch.entityToIndex.get(entityId)!;
-      const size = store._arraySizes[fieldRef._field] || 0;
-      if (size > 0) {
-        const base = idx * size;
-        return store[fieldRef._field].subarray(base, base + size);
+      if (arch) {
+        const store = arch.components.get(fieldRef._sym);
+        if (store) {
+          const idx = arch.entityToIndex.get(entityId)!;
+          const size = store._arraySizes[fieldRef._field] || 0;
+          if (size > 0) {
+            const base = idx * size;
+            return (store._fields[fieldRef._field] as Float32Array).subarray(base, base + size) as unknown as number;
+          }
+          return (store._fields[fieldRef._field] as never[])[idx];
+        }
+      }
+      // Fallback: check recently-removed data (accessible during @OnRemoved hooks)
+      const removed = removedData.get(entityId);
+      if (removed) {
+        const compData = removed.get(fieldRef._sym);
+        if (compData) return compData[fieldRef._field] as number | string;
       }
-      return store[fieldRef._field][idx];
+      return undefined;
     },
 
-    set(entityId: EntityId, fieldRef: FieldRef, value: any): void {
+    set(entityId: EntityId, fieldRef: FieldRef, value: number | string | ArrayLike<number>): void {
       const arch = entityArchetype.get(entityId);
       if (!arch) return;
       const store = arch.components.get(fieldRef._sym);
@@ -616,9 +683,9 @@ export function createEntityManager(): EntityManager {
       const idx = arch.entityToIndex.get(entityId)!;
       const size = store._arraySizes[fieldRef._field] || 0;
       if (size > 0) {
-        store[fieldRef._field].set(value, idx * size);
+        (store._fields[fieldRef._field] as Float32Array).set(value as ArrayLike<number>, idx * size);
       } else {
-        store[fieldRef._field][idx] = value;
+        (store._fields[fieldRef._field] as never[])[idx] = value as never;
       }
     },
 
@@ -650,11 +717,11 @@ export function createEntityManager(): EntityManager {
       allEntityIds.add(id);
 
       const types: symbol[] = [];
-      const map: any = {};
+      const map = new Map<symbol, ComponentData>();
       for (let i = 0; i < args.length; i += 2) {
         const sym = toSym(args[i] as ComponentDef);
         types.push(sym);
-        map[sym as unknown as string] = args[i + 1];
+        map.set(sym, args[i + 1] as ComponentData);
       }
       const arch = getOrCreateArchetype(types);
       addToArchetype(arch, id, map);
@@ -694,21 +761,40 @@ export function createEntityManager(): EntityManager {
             snapshotEntityIds: arch.snapshotEntityIds,
             snapshotCount: arch.snapshotCount,
             field(ref: FieldRef) {
-              const sym = ref._sym || ref;
-              const store = arch.components.get(sym as symbol);
+              const store = arch.components.get(ref._sym);
               if (!store) return undefined;
-              return store[ref._field];
+              return store._fields[ref._field];
             },
             fieldStride(ref: FieldRef) {
-              const sym = ref._sym || ref;
-              const store = arch.components.get(sym as symbol);
+              const store = arch.components.get(ref._sym);
               if (!store) return 1;
               return store._arraySizes[ref._field] || 1;
             },
+            fieldOffset(ref: FieldRef) {
+              if (!arena) return -1;
+              const store = arch.components.get(ref._sym);
+              if (!store) return -1;
+              const arr = store._fields[ref._field];
+              if (!arr || arr instanceof Array) return -1;
+              return (arr as Exclude<SoAArrayValue, unknown[]>).byteOffset;
+            },
+            fieldAdd(target: FieldRef, source: FieldRef) {
+              const tStore = arch.components.get(target._sym);
+              const sStore = arch.components.get(source._sym);
+              if (!tStore || !sStore) return;
+              const dst = tStore._fields[target._field];
+              const src = sStore._fields[source._field];
+              const stride = tStore._arraySizes[target._field] || 1;
+              const n = arch.count * stride;
+              if (kernels && dst instanceof Float32Array && src instanceof Float32Array) {
+                kernels.add_f32(dst.byteOffset, src.byteOffset, n);
+              } else {
+                for (let i = 0; i < n; i++) (dst as never[])[i] = ((dst as never[])[i] as number + ((src as never[])[i] as number)) as never;
+              }
+            },
             snapshot(ref: FieldRef) {
               if (!snaps) return undefined;
-              const sym = ref._sym || ref;
-              const snap = snaps.get(sym as symbol);
+              const snap = snaps.get(ref._sym);
               if (!snap) return undefined;
               return snap[ref._field];
             }
@@ -737,7 +823,7 @@ export function createEntityManager(): EntityManager {
           arch.snapshotCount = 0;
           for (const [t, store] of arch.components) {
             if (store) {
-              arch.snapshots.set(t, createSnapshotStore(store._schema, arch.capacity));
+              arch.snapshots.set(t, createSnapshotStore(store._schema, arch.capacity, arena));
             }
           }
           trackedArchetypes.push(arch);
@@ -765,14 +851,14 @@ export function createEntityManager(): EntityManager {
           const snap = arch.snapshots!.get(type);
           if (!snap) continue;
           for (const field in store._schema) {
-            const src = store[field];
+            const src = store._fields[field];
             const dst = snap[field];
             const size = store._arraySizes[field] || 0;
             const len = size > 0 ? count * size : count;
-            if (src.set) {
-              dst.set(src.subarray(0, len));
+            if ('set' in src) {
+              (dst as Exclude<SoAArrayValue, unknown[]>).set((src as Float32Array).subarray(0, len));
             } else {
-              for (let i = 0; i < len; i++) dst[i] = src[i];
+              for (let i = 0; i < len; i++) (dst as unknown[])[i] = (src as unknown[])[i];
             }
           }
         }
@@ -855,6 +941,10 @@ export function createEntityManager(): EntityManager {
       }
     },
 
+    commitRemovals(): void {
+      removedData.clear();
+    },
+
     serialize(
       symbolToName: Map<symbol, string>,
       stripComponents: ComponentDef[] = [],
@@ -934,11 +1024,11 @@ export function createEntityManager(): EntityManager {
 
       nextId = data.nextId;
 
-      const entityComponents = new Map<EntityId, any>();
+      const entityComponents = new Map<EntityId, Map<symbol, ComponentData>>();
 
       for (const id of data.entities) {
         allEntityIds.add(id);
-        entityComponents.set(id, {});
+        entityComponents.set(id, new Map());
       }
 
       for (const [name, store] of Object.entries(data.components)) {
@@ -954,16 +1044,16 @@ export function createEntityManager(): EntityManager {
           if (!obj) continue;
 
           if (customDeserializer) {
-            obj[sym] = customDeserializer(compData);
+            obj.set(sym, customDeserializer(compData) as ComponentData);
           } else {
-            obj[sym] = compData;
+            obj.set(sym, compData as ComponentData);
           }
         }
       }
 
-      const groupedByKey = new Map<string, { entityId: EntityId; compMap: any }[]>();
+      const groupedByKey = new Map<string, { entityId: EntityId; compMap: Map<symbol, ComponentData> }[]>();
       for (const [entityId, compMap] of entityComponents) {
-        const types = Object.getOwnPropertySymbols(compMap);
+        const types = [...compMap.keys()];
         if (types.length === 0) continue;
 
         const key = maskKey(computeMask(types));
@@ -974,7 +1064,7 @@ export function createEntityManager(): EntityManager {
       }
 
       for (const [, entries] of groupedByKey) {
-        const types = Object.getOwnPropertySymbols(entries[0].compMap);
+        const types = [...entries[0].compMap.keys()];
         const arch = getOrCreateArchetype(types);
 
         for (const { entityId, compMap } of entries) {