Dense entity arrays: efficient, or a micro-optimization?

[ExoticMatter]

Since entities have a lazily-generated ID, it is possible to store these IDs in a TypedArray. With a wrapper class this can be done without sacrificing ergonomic-ness.

const NULL_ID = 0xFFFFFFFF;

// A very quick and dirty example
class DenseEntityArray<Entity> {
    private ids: Uint32Array;
    private lookup: Pick<World<Entity>, "id" | "entity">; // allow users to use custom ID management

    constructor() { /* ... */ }

    get(index: number) {
        const id = this.lookup.entity(this.ids[index]);
        return id !== NULL_ID ? id : undefined;
    }

    set(index: number, entity: Entity | undefined) {
        // we assume, possibly wrongly, that 0 ≤ id(entity) < NULL_ID.
        this.ids[index] = this.lookup.id(entity) ?? NULL_ID;
    }

    /* ... */
}

In theory, this should use less memory than Entity[]. The downside is that we need to look up the entity ID in order to return an Entity, which means in theory indexing into it will be no faster than, and possibly slower than, indexing into Entity[].

Note: World.id() uses Map<number, Entity> for id -> Entity, which benchmarks suggest has the same performance as Entity[]. However, we first have to index into the array of IDs, and then look up the entity in the Map.