@adobe/data 0.1.2 → 0.2.0

package/src/old-ecs/transaction-ecs/transactions.ts

@@ -0,0 +1,243 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+
+import { DELETE } from "../core-ecs/core-ecs.js";
+import {
+  Archetype,
+  ECS,
+  ECSArchetypes,
+  ECSComponents,
+  ECSResources,
+  ECSWrite,
+} from "../ecs/ecs-types.js";
+import {
+  EntityCreateValues,
+  Entity,
+  EntityUpdateValues,
+} from "../core-ecs/core-ecs-types.js";
+import {
+  Transaction,
+  TransactionCancel,
+  TransactionChanges,
+  TransactionCommit,
+  TransactionComplete,
+  TransactionECS,
+  TransactionOptions,
+  TransactionUpdateOperation,
+  TransactionWriteOperation,
+} from "./transaction-types.js";
+
+export function createECSTransaction<
+  C extends ECSComponents, //  name => Component Value Type
+  A extends ECSArchetypes, //  name => Entity Values Type
+  R extends ECSResources, //  name => Resource Value Type
+>(
+  tecs: TransactionECS<C, A, R>,
+  ecs: ECS<C, A, R>,
+  options: Required<TransactionOptions>,
+  transactionCommmitted: (
+    value: TransactionCommit<C>,
+    changes: TransactionChanges<C>
+  ) => void,
+  parent?: Transaction<C, A, R>
+): Transaction<C, A, R> {
+  const write: ECSWrite<C> = parent ?? ecs;
+  const redoOperations: TransactionWriteOperation<C>[] = [];
+  const undoOperationsInReverseOrder: TransactionWriteOperation<C>[] = [];
+
+  const changed = {
+    entities: new Set<Entity>(),
+    components: new Set<keyof C>(),
+    archetypes: new Set<Archetype>(),
+  };
+
+  function createEntity(): Entity;
+  function createEntity<T>(
+    archetype: Archetype<T>,
+    values: EntityCreateValues<T>
+  ): Entity;
+  function createEntity<T>(
+    archetype?: Archetype<T>,
+    values?: EntityCreateValues<T>
+  ): Entity {
+    const entity =
+      archetype && values
+        ? write.createEntity(archetype, values)
+        : write.createEntity();
+    redoOperations.push({
+      type: "create",
+      values: (values ?? {}) as unknown as EntityCreateValues<C>,
+    });
+    undoOperationsInReverseOrder.push({ type: "delete", entity });
+    changed.entities.add(entity);
+    changed.archetypes.add(ecs.getEntityArchetype(entity));
+    for (const key in values) {
+      changed.components.add(key as keyof C);
+    }
+    return entity;
+  }
+
+  function updateEntity(entity: Entity, values: EntityUpdateValues<C>) {
+    const oldValues = ecs.getEntityValues(entity)!;
+    const replacedValues: any = {};
+    for (const name in values) {
+      const newValue = (values as any)[name];
+      let oldValue = (oldValues as any)[name];
+      if (newValue !== oldValue) {
+        if (oldValue === undefined) {
+          oldValue = DELETE;
+        }
+        replacedValues[name] = oldValue;
+        changed.components.add(name as keyof C);
+      }
+    }
+
+    changed.entities.add(entity);
+    changed.archetypes.add(ecs.getEntityArchetype(entity));
+    write.updateEntity(entity, values);
+    //  archetype may have changed after update so we need to add new one.
+    changed.archetypes.add(ecs.getEntityArchetype(entity));
+
+    // maybe collapse adjacent updates to same entity.
+    const lastUndoOperation: TransactionWriteOperation<C> | undefined =
+      undoOperationsInReverseOrder[undoOperationsInReverseOrder.length - 1];
+    if (
+      lastUndoOperation?.type === "update" &&
+      lastUndoOperation.entity === entity
+    ) {
+      const lastRedoOperation = redoOperations[
+        redoOperations.length - 1
+      ] as TransactionUpdateOperation<C>;
+      lastRedoOperation.values = { ...lastRedoOperation.values, ...values };
+      lastUndoOperation.values = {
+        ...replacedValues,
+        ...lastUndoOperation.values,
+      };
+    } else {
+      redoOperations.push({ type: "update", entity, values });
+      undoOperationsInReverseOrder.push({
+        type: "update",
+        entity,
+        values: replacedValues,
+      });
+    }
+  }
+
+  function deleteEntity(entity: Entity) {
+    changed.archetypes.add(ecs.getEntityArchetype(entity));
+    changed.entities.add(entity);
+
+    const { id: _ignore, ...oldValues } = ecs.getEntityValues(entity) as any;
+    for (const key in oldValues) {
+      changed.components.add(key as keyof C);
+    }
+    write.deleteEntity(entity);
+    redoOperations.push({ type: "delete", entity });
+    undoOperationsInReverseOrder.push({ type: "create", values: oldValues });
+  }
+
+  function batch(operations: TransactionWriteOperation<C>[]) {
+    for (const operation of operations) {
+      switch (operation.type) {
+        case "create": {
+          const archetype = ecs.getArchetype(
+            "id",
+            ...(Object.keys(operation.values) as (keyof C)[])
+          );
+          createEntity(archetype, operation.values);
+          break;
+        }
+        case "update":
+          updateEntity(operation.entity, operation.values);
+          break;
+        case "delete":
+          deleteEntity(operation.entity);
+          break;
+      }
+    }
+    return transaction;
+  }
+
+  function complete(committed: true): TransactionCommit<C>;
+  function complete(committed: false): TransactionCancel;
+  function complete(committed: boolean): TransactionComplete<C> {
+    const undoOperations = undoOperationsInReverseOrder.slice(0).reverse();
+
+    if (!committed) {
+      batch(undoOperations);
+    }
+
+    if (committed) {
+      const result = { committed, options, redoOperations, undoOperations };
+      if (!parent && committed) {
+        transactionCommmitted(result, changed);
+      }
+      return result;
+    } else {
+      return { committed, options };
+    }
+  }
+
+  const setComponentValue = <Name extends keyof C>(
+    id: Entity,
+    component: Name,
+    value: C[Name] | undefined
+  ) => {
+    updateEntity(id, { [component]: value } as EntityUpdateValues<C>);
+  };
+
+  const transaction: Transaction<C, A, R> = {
+    ecs: tecs,
+    options,
+    resources: new Proxy(ecs.resources, {
+      set: (
+        _target: typeof ecs.resources,
+        p: string | symbol,
+        value: any,
+        _receiver: any
+      ): boolean => {
+        const archetype = ecs.getArchetype("id", p as keyof C);
+        const [table] = ecs.getTables(archetype, { mode: "read", exact: true });
+        const id = table.columns.id.get(0);
+        updateEntity(id, { [p as keyof C]: value } as any);
+        return true;
+      },
+    }),
+    setComponentValue,
+    createTransaction: () =>
+      createECSTransaction(
+        tecs,
+        ecs,
+        options,
+        transactionCommmitted,
+        transaction
+      ),
+    batch,
+    commit: () => complete(true),
+    cancel: () => complete(false),
+    createEntity,
+    updateEntity,
+    deleteEntity,
+  };
+
+  return transaction;
+}

package/src/perftest/ecs-perf.ts

@@ -0,0 +1,255 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { Column, createECS } from "../old-ecs/index.js";
+import { F32Schema, TrueSchema, U32Schema } from "../schema/index.js";
+import { PerformanceTest } from "./perf-test.js";
+import * as assembly from "../../dist/assembly/index.js";
+import { createWasmMemoryAllocator } from "../cache/memory-allocator.js";
+import { TypedArray } from "../internal/typed-array/index.js";
+
+// const COUNT = 1_000_000;
+// const SIZEOF_F32 = 4;
+// const SIZEOF_BOOLEAN = 1;
+// const OBJECT_OVERHEAD = 16;
+// //  Expected 50 Mb
+// const EXPECTED_MEMORY = (8 * SIZEOF_F32 + 2 * SIZEOF_BOOLEAN + OBJECT_OVERHEAD) * COUNT;
+
+function createECSWithParticles(count: number, batch = true) {
+  const ecs = createECS({
+    allocator: createWasmMemoryAllocator(assembly.memory),
+  })
+    .withComponents({
+      color: U32Schema,
+      enabled: TrueSchema,
+      mass: F32Schema,
+      positionX: F32Schema,
+      positionY: F32Schema,
+      positionZ: F32Schema,
+      velocityX: F32Schema,
+      velocityY: F32Schema,
+      velocityZ: F32Schema,
+      visible: TrueSchema,
+    })
+    .withArchetypes({
+      VisibleEnabled: [
+        "id",
+        "color",
+        "enabled",
+        "mass",
+        "positionX",
+        "positionY",
+        "positionZ",
+        "velocityX",
+        "velocityY",
+        "velocityZ",
+        "visible",
+      ],
+      InvisibleEnabled: [
+        "id",
+        "color",
+        "enabled",
+        "mass",
+        "positionX",
+        "positionY",
+        "positionZ",
+        "velocityX",
+        "velocityY",
+        "velocityZ",
+      ],
+      VisibleDisabled: [
+        "id",
+        "color",
+        "mass",
+        "positionX",
+        "positionY",
+        "positionZ",
+        "velocityX",
+        "velocityY",
+        "velocityZ",
+        "visible",
+      ],
+      InvisibleDisabled: [
+        "id",
+        "color",
+        "mass",
+        "positionX",
+        "positionY",
+        "positionZ",
+        "velocityX",
+        "velocityY",
+        "velocityZ",
+      ]
+    });
+
+  const particle_archetypes = [
+    ecs.archetypes.VisibleEnabled,
+    ecs.archetypes.VisibleDisabled,
+    ecs.archetypes.InvisibleEnabled,
+    ecs.archetypes.InvisibleDisabled,
+  ] as const;
+
+  if (batch) {
+
+    const particle_count_per_table = Math.ceil(count / 4);
+    const particle_tables = particle_archetypes.map(archetype => ecs.createBatch(archetype, particle_count_per_table));
+
+    for (let tableIndex = 0; tableIndex < particle_tables.length; tableIndex++) {
+      const table = particle_tables[tableIndex];
+      const positionX = table.columns.positionX.native as TypedArray;
+      const positionY = table.columns.positionY.native as TypedArray;
+      const positionZ = table.columns.positionZ.native as TypedArray;
+      const velocityX = table.columns.velocityX.native as TypedArray;
+      const velocityY = table.columns.velocityY.native as TypedArray;
+      const velocityZ = table.columns.velocityZ.native as TypedArray;
+      const color = table.columns.color.native!;
+      const mass = table.columns.mass.native!;
+      for (let k = 0; k < particle_count_per_table; k++) {
+        const i = tableIndex + k * 4;
+        color[k] = 0xff00ff;
+        mass[k] = 10;
+        positionX[k] = i + 1;
+        positionY[k] = i + 1;
+        positionZ[k] = i + 1;
+        velocityX[k] = -i;
+        velocityY[k] = -i;
+        velocityZ[k] = -i;
+      }
+    }
+  }
+  else {
+    for (let i = 0; i < count; i++) {
+      ecs.createEntity(particle_archetypes[i % 4], {
+        color: 0xff00ff,
+        mass: 10,
+        positionX: i + 1,
+        positionY: i + 1,
+        positionZ: i + 1,
+        velocityX: -i,
+        velocityY: -i,
+        velocityZ: -i,
+        visible: (i >> 0) % 2 === 0 ? true : false,
+        enabled: (i >> 1) % 2 === 0 ? true : false,
+      } as any);
+    }
+  }
+
+  return ecs;
+}
+
+const create = (batch: boolean) => {
+  let count = 0;
+  const setup = async (n: number) => {
+    count = n;
+  };
+  const run = () => {
+    createECSWithParticles(count, batch);
+  };
+  const cleanup = async () => { };
+  return { setup, run: run, cleanup, type: "create" } satisfies PerformanceTest;
+};
+
+function addManagedArrays(
+  a: Column<number>,
+  b: Column<number>,
+  rows: number,
+  addWasm: typeof assembly.addF32Arrays
+) {
+  const aptr = (a.native as unknown as Float32Array).byteOffset.valueOf();
+  const bptr = (b.native as unknown as Float32Array).byteOffset.valueOf();
+  addWasm(aptr, bptr, rows);
+}
+
+function createMoveParticlesPerformanceTest(options: {
+  mode: "column" | "native" | typeof assembly.addF32Arrays;
+}) {
+  let ecs: ReturnType<typeof createECSWithParticles>;
+  const setup = async (n: number) => {
+    ecs = createECSWithParticles(n);
+  };
+  const run = () => {
+    let total = 0;
+    const addWasm = typeof options.mode === "function" ? options.mode : null;
+    for (const table of ecs.getTables(ecs.archetypes.VisibleEnabled, {
+      mode: "write",
+    })) {
+      const { rows, columns } = table;
+      total += rows;
+      if (addWasm) {
+        addManagedArrays(columns.positionX, columns.velocityX, rows, addWasm);
+        addManagedArrays(columns.positionY, columns.velocityY, rows, addWasm);
+        addManagedArrays(columns.positionZ, columns.velocityZ, rows, addWasm);
+      } else if (options.mode === "column") {
+        const {
+          positionX,
+          positionY,
+          positionZ,
+          velocityX,
+          velocityY,
+          velocityZ,
+        } = columns;
+        for (let i = 0; i < rows; i++) {
+          positionX.set(i, positionX.get(i) + velocityX.get(i));
+          positionY.set(i, positionY.get(i) + velocityY.get(i));
+          positionZ.set(i, positionZ.get(i) + velocityZ.get(i));
+        }
+      } else if (options.mode === "native") {
+        const positionX = columns.positionX.native!;
+        const positionY = columns.positionY.native!;
+        const positionZ = columns.positionZ.native!;
+        const velocityX = columns.velocityX.native!;
+        const velocityY = columns.velocityY.native!;
+        const velocityZ = columns.velocityZ.native!;
+        for (let i = 0; i < rows; i++) {
+          positionX[i] += velocityX[i];
+          positionY[i] += velocityY[i];
+          positionZ[i] += velocityZ[i];
+        }
+      }
+    }
+  };
+  const getVisibleEnabledPositions = () => {
+    const values: number[] = [];
+    for (const table of ecs.getTables(ecs.archetypes.VisibleEnabled, {
+      mode: "read",
+    })) {
+      const { rows, columns } = table;
+      const { positionX, positionY, positionZ } = columns;
+      for (let i = 0; i < rows; i++) {
+        values.push(positionX.get(i), positionY.get(i), positionZ.get(i));
+      }
+    }
+    return values;
+  }
+
+  const cleanup = async () => { };
+  return { setup, run: run, cleanup, getVisibleEnabledPositions, type: "move" } satisfies PerformanceTest;
+}
+
+export const ec2s = {
+  create: create(false),
+  create_batch: create(true),
+  move_column: createMoveParticlesPerformanceTest({ mode: "column" }),
+  move_native: createMoveParticlesPerformanceTest({ mode: "native" }),
+  move_wasm: createMoveParticlesPerformanceTest({ mode: assembly.addF32Arrays }),
+  move_wasm_simd4: createMoveParticlesPerformanceTest({ mode: assembly.addF32ArraysSimd4 }),
+  move_wasm_simd4_unrolled: createMoveParticlesPerformanceTest({ mode: assembly.addF32ArraysSimd4Unrolled }),
+};

package/src/perftest/helper-functions.ts

@@ -0,0 +1,31 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+export function shuffleArray<T>(array: T[]) {
+  for (let i = array.length - 1; i > 0; i--) {
+    // Generate a random index lower than the current element
+    const j = Math.floor(Math.random() * (i + 1));
+
+    // Swap elements at indices i and j
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+}

package/src/perftest/horizon-perf.ts

@@ -0,0 +1,132 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { shuffleArray } from "./helper-functions.js";
+import { PerformanceTest } from "./perf-test.js";
+
+function uuidv4(): string {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+    const r = (Math.random() * 16) | 0;
+    const v = c === "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+// uuid-imports.d.ts
+async function createParticles(count: number) {
+  const particlesIds: string[] = [];
+  const components: Map<string, Map<string, any>> = new Map();
+  const setComponent = (name: string, key: string, value: any) => {
+    let component = components.get(name);
+    if (!component) {
+      component = new Map();
+      components.set(name, component);
+    }
+    component.set(key, value);
+  };
+  const getComponent = (name: string, key: string) => {
+    const component = components.get(name);
+    if (!component) {
+      return undefined;
+    }
+    return component.get(key);
+  };
+  const particles: any[] = [];
+  for (let i = 0; i < count; i++) {
+    const entity = uuidv4();
+    particlesIds.push(entity);
+    setComponent(entity, "color", { value: 0xff00ff });
+    setComponent(entity, "mass", { value: 10 });
+    setComponent(entity, "position", { x: i + 1, y: i + 1, z: i + 1 });
+    setComponent(entity, "velocity", { x: - i, y: - i, z: - i });
+    if ((i >> 0) % 2 === 0) {
+      setComponent(entity, "visible", true);
+    }
+    if ((i >> 1) % 2 === 0) {
+      setComponent(entity, "enabled", true);
+    }
+  }
+  const enabledVisibleParticles = particlesIds.filter((id, i) => {
+    return getComponent(id, "enabled") && getComponent(id, "visible");
+  });
+
+  return {
+    particles,
+    components,
+    setComponent,
+    getComponent,
+    enabledVisibleParticles,
+  };
+}
+
+const create = (() => {
+  let count = 0;
+  const setup = async (n: number) => {
+    count = n;
+  };
+  const run = () => {
+    createParticles(count);
+  };
+  const cleanup = async () => {};
+  return { setup, run: run, cleanup, type: "create" } satisfies PerformanceTest;
+})();
+
+function createMoveParticlesPerformanceTest(options: { shuffle: boolean }) {
+  let ecs: any;
+  const setup = async (n: number) => {
+    ecs = await createParticles(n);
+    if (options.shuffle) {
+      shuffleArray(ecs.particles);
+    }
+  };
+  const run = () => {
+    for (let i = 0; i < ecs.enabledVisibleParticles.length; i++) {
+      const p = ecs.enabledVisibleParticles[i];
+      const position = ecs.getComponent(p, "position");
+      const velocity = ecs.getComponent(p, "velocity");
+      const newPosition = { 
+        x: position.x + velocity.x,
+        y: position.y + velocity.y,
+        z: position.z + velocity.z,
+      };
+      ecs.setComponent(p, "position", newPosition);
+    }
+  };
+  const getVisibleEnabledPositions = () => {
+    const values: number[] = [];
+    for (let i = 0; i < ecs.enabledVisibleParticles.length; i++) {
+      const p = ecs.enabledVisibleParticles[i];
+      const position = ecs.getComponent(p, "position");
+      values.push(position.x, position.y, position.z);
+    }
+    return values;
+  }
+  const cleanup = async () => {};
+  return { setup, run: run, cleanup, getVisibleEnabledPositions, type: "move" } satisfies PerformanceTest;
+}
+
+const move_best = createMoveParticlesPerformanceTest({ shuffle: false });
+const move_worst = createMoveParticlesPerformanceTest({ shuffle: true });
+
+export const horizon = {
+  create,
+  move_best,
+  move_worst,
+};

package/{perftest/index.js → src/perftest/index.ts}

@@ -20,16 +20,18 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.*/
 import * as vanilla_tests from "./vanilla-perf.js";
+import * as horizon_tests from "./horizon-perf.js";
 import * as ecs_tests from "./ecs-perf.js";
 import { runTests } from "./perf-test.js";
+
 export function run() {
-    runTests({
-        ...ecs_tests,
-        ...vanilla_tests,
-        // ...horizon_tests,
-    });
+  runTests({
+    ...ecs_tests,
+    ...vanilla_tests,
+    // ...horizon_tests,
+  });
 }
+
 if (typeof globalThis.process === "object" && import.meta.url === `file://${process?.argv[1]}`) {
-    run();
+  run();
 }
-//# sourceMappingURL=index.js.map