Add typed, plugin-declared indexes to the ECS database (#107)

* Add typed, plugin-declared indexes to the ECS database

Plugins now declare `indexes` alongside `components` / `archetypes`. The
runtime maintains them eagerly per mutation at the Store layer, so
`db.indexes.<name>` and `t.indexes.<name>` lookups are always fresh —
including inside the same transaction that just mutated a row. Unique
conflicts pre-check before any column mutation and surface from the
offending insert/update call, so store and index stay consistent under
rollback.

Public API additions:
- `Database.Index<C, Keys, Unique>` and `Database.Index.Handle<C, I>`
  (compile-time-checked component keys; `get` exposed only on unique).
- 9th generic `IX` on `Database<...>`; 4th generic `IX` on
  `Store<...>` / `ReadonlyStore<...>` / `TransactionContext<...>` /
  `TransactionDeclaration<...>`. All defaults are `{}` so existing call
  sites keep type-checking unchanged.
- `Store.Schema.indexes` (optional) and plugin descriptor `indexes`,
  slotted between `archetypes` and `computed` in the property order.

Auto-routing:
- `db.select(include, { where })` and `db.observe.select(...)` route
  through a matching index when `where` is pure equality on the index's
  full key tuple and no order is given. Other shapes fall back to the
  archetype scan unchanged.

Registration strictness (matches the `===` rule `combinePlugins`
already enforces for components / transactions, plus one new rule):
- Same name + different decl object → throws.
- Different name + same shape → throws (almost always an unintentional
  duplicate; error names both indexes so the author can pick one).

Architecture:
- `Core` stays untouched; the Store layer owns the `IndexRegistry`
  and wraps `archetype.insert` / `store.update` / `store.delete` to
  maintain indexes. TransactionalStore / Observed / Reconciling only
  forward the new `IX` generic; their runtime is unchanged because
  mutations flow through Store methods.
- `db.indexes` is `store.indexes` by reference. Rollback in
  `applyWriteOperations` goes back through the same Store methods,
  so index undo is free.

Tests: 38 new index tests (66 total in the index suite); full data
package suite 2276 passing.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* Seed each index from its own archetypes, not every entity

The previous rebuild path walked every live entity in the database via
a generator over `queryArchetypes([])`, then called `store.read` per
entity. That ignored what archetypes are for: an index over `["email"]`
can only ever be populated by archetypes whose component set contains
`email`. Every other archetype's rows are skipped at `idx.add` time
anyway — but only after we already walked them and did a redundant
`locate` from `read`.

Now:
- `createIndexRegistry` no longer takes an `EntityIterator`. `register`
  returns the new `RuntimeIndex` (or null on a benign identity-equal
  re-register) so the caller can seed it. `rebuild()` is replaced by
  `clear()` — the registry zeros its buckets, seeding is the store's
  job.
- `createStore` adds `seedIndexFromArchetypes(idx)`. It calls
  `core.queryArchetypes(idx.components)` to narrow to the archetypes
  that could contribute, then reads values directly from each
  archetype's dense column buffers per row. No `read`, no `locate`.
- `reset()` and `fromData()` call `indexRegistry.clear()` and then
  seed each index via the same targeted walk. Each index sees only
  the archetypes containing its components.

Also: dropped one gratuitous cast in `create-database.ts`
(`partialDatabase` is already `any`; the `as { indexes: unknown }`
narrowed for an assignment that didn't need narrowing).

All 2276 tests still pass; tsc -b clean.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* Add computed, multi-value, and sorted indexes

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Redesign index declaration API around a unified `key` union

Replaces the V1 `components`/`compute` split with a single `key` field
that accepts four shapes — bare column, column tuple, function, or slot
map — and an `order: { by, compare? }` for within-bucket sorting.
`get` now returns `Entity | null` (known absent), never `undefined`.

- `IndexKey<C>` constrains the `key` declaration to columns of C; the
  inlined `IndexDeclarations` shape makes typo-keys a compile error.
- `findRange` accepts comparison-operator filters (`<,<=,>,>=,==,!=`)
  on the bucket key, scalar or per-field.
- Auto-router dispatches a raw-equality `where` through the matching
  index's `handle.find` (spies + instrumentation see the call).
- README catalogues all 12 patterns with their handle signatures.
- 92 runtime tests + 2 type-only proof files exercise every shape.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* Defer within-bucket sorting to first read after writes

Sorted indexes now append on insert and mark the bucket dirty; the first
find/findRange that touches a dirty bucket pays one O(n log n) sort,
subsequent reads are free until the next write. Optimizes the batched-
write-then-read workload from O(k·n) to O(k + n log n) per batch of `k`
inserts. Public interface unchanged.

Bucket-key Map stays eager so the uniqueness pre-check fires before any
column mutation and t.indexes.x.get(...) inside a transaction still sees
just-written rows.

- Strengthen unique-conflict tests to snapshot store + index pre-throw and
  assert no drift after rollback.
- New database.index.performance.test.ts: nine inserts-are-linear-in-N
  tests across every catalogue shape, plus a "second read is free" check.
- README: per-insert and read-after-write big-O tables.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* Make single-entity index writes O(1) in bucket size

Non-unique bucket payload is now Set<Entity> instead of Entity[]. Removes
the arr.indexOf scan from remove/update-with-bucket-change, so a single-
row write touches O(b) buckets at O(1) each — never proportional to
bucket size or total entities in the index.

For sorted indexes, the materialized + sorted array is cached per bucket
and dropped on any write touching that bucket. First read after writes
pays the O(n log n) sort once; subsequent reads slice the cached array.

Red/green: three new perf tests in database.index.performance.test.ts
under "Single-entity write is O(1) in bucket size" — non-unique delete,
update-with-bucket-change, sorted-index delete. Each compares 4k vs 40k
bucket and asserts ratio < 3×. All three failed with array-based storage,
pass after the Set refactor. They stay in the suite to catch regressions
(any reintroduction of arr.indexOf in the bucket hot path makes them red
again).

Insertion tests get warmThenMeasure to absorb JIT cold-start variance
when running alongside the full repo suite; QUADRATIC_FLOOR lifted to 5×
to still catch real O(n²) but tolerate noise on size-doubling tests.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: krisnye

packages/data/src/ecs/README.md

@@ -135,6 +135,203 @@ const worldPlugin = Database.Plugin.create({
 });
 ```
 
+## Indexes
+
+Indexes give O(1) lookup by some derived or column-valued key. Declare them on the plugin alongside components and archetypes; the runtime maintains them automatically on every insert/update/delete and exposes typed lookup handles at `db.indexes.<name>` and `t.indexes.<name>` (inside transactions).
+
+### Declaration shape
+
+| Field | Required | Shape |
+|---|---|---|
+| `key` | yes | `string` ∣ `string[]` ∣ `(args) => Value` ∣ `{ slot: string ∣ (args) => Value }` |
+| `order` | no | `{ by: string[]; compare?: (a, b) => number }` |
+| `unique` | no | `boolean` — when `true`, exposes `get(key) → Entity \| null` |
+| `components` | only when an extractor function reads a column not already implied by an identity string in `key`/`order` | `string[]` |
+
+`find(key) → readonly Entity[]` returns every entity in the matching bucket (sorted if `order` is declared). `get(key) → Entity | null` is exposed only on unique indexes; `null` means "we know this key has no entity," never `undefined`. Array values (a `T[]` column, or a `compute` return that is `T[]`) auto-fan-out into one bucket entry per element.
+
+### Pattern catalogue
+
+#### Raw indexes (identity reads from columns)
+
+**Single-column unique lookup**
+```ts
+indexes: {
+    byEmail: { key: "email", unique: true },
+}
+// db.indexes.byEmail.get("alice@x.com") → Entity | null
+```
+
+**Multi-column compound unique** — `MappedChildOf` style when both parts are top-level columns:
+```ts
+indexes: {
+    playerSlot: { key: ["team", "position"], unique: true },
+}
+// db.indexes.playerSlot.get({ team: T, position: "qb" }) → Entity | null
+```
+
+**Non-unique by single column** — `ChildOf` style:
+```ts
+indexes: {
+    childrenOf: { key: "parent" },
+}
+// db.indexes.childrenOf.find(P) → readonly Entity[]
+```
+
+**Sorted children** — `OrderedChildOf` style with top-level columns:
+```ts
+indexes: {
+    orderedChildrenOf: { key: "parent", order: { by: ["fractIndex"] } },
+}
+// db.indexes.orderedChildrenOf.find(P) → readonly Entity[]   // sorted by fractIndex
+```
+
+**Multi-value (array column)** — per-element fan-out is automatic:
+```ts
+indexes: {
+    tasksByAssignee: { key: "assigned" },   // assigned: string[]
+}
+// db.indexes.tasksByAssignee.find("joe") → all tasks where assigned includes "joe"
+```
+
+#### Computed indexes (function-derived)
+
+**Scalar derived key** (case-insensitive lookup):
+```ts
+indexes: {
+    byEmailCi: { components: ["email"], key: (email) => email.toLowerCase() },
+}
+// db.indexes.byEmailCi.find("ALICE@x.com") → readonly Entity[]
+```
+
+**Multi-value computed** — `compute` returns an array, each element becomes a bucket entry:
+```ts
+indexes: {
+    docsByKeyword: { components: ["body"], key: (body) => extractTags(body) },
+}
+// db.indexes.docsByKeyword.find("typescript")
+```
+
+**Compound key from nested data** — `MappedChildOf` when the relationship data lives in one nested component:
+```ts
+// player: { parent: Team, key: Position }
+indexes: {
+    playerByRoster: {
+        components: ["player"],
+        key: { team: (p) => p.parent, position: (p) => p.key },
+        unique: true,
+    },
+}
+// db.indexes.playerByRoster.get({ team: T, position: "qb" }) → Entity | null
+```
+
+**Sorted from nested data** — `OrderedChildOf` with nested struct:
+```ts
+// foo: { parent: Entity, order: FractionalIndex }
+indexes: {
+    orderedChildrenOfFoo: {
+        components: ["foo"],
+        key: (f) => f.parent,
+        order: {
+            by: ["foo"],
+            compare: (a, b) => a.foo.order < b.foo.order ? -1 : 1,
+        },
+    },
+}
+// db.indexes.orderedChildrenOfFoo.find(T) → readonly Entity[]   // sorted by foo.order
+```
+
+#### Combined / advanced
+
+**Mixed identity + derived parts in one compound key**:
+```ts
+indexes: {
+    playerByTeamRole: {
+        components: ["player"],
+        key: {
+            team: "team",                // identity from top-level `team` column
+            role: (p) => p.position,     // derived from nested player.position
+        },
+        unique: true,
+    },
+}
+// db.indexes.playerByTeamRole.get({ team: T, role: "qb" }) → Entity | null
+```
+
+**Computed mapped *and* sorted** — full `SortedMappedChildOf`:
+```ts
+indexes: {
+    orderedRoster: {
+        components: ["item"],
+        key: { team: (i) => i.parent, role: (i) => i.key },
+        order: {
+            by: ["item"],
+            compare: (a, b) => a.item.fractIndex.localeCompare(b.item.fractIndex),
+        },
+        unique: true,
+    },
+}
+// db.indexes.orderedRoster.get({ team: T, role: "qb" }) → Entity | null
+```
+
+**Custom comparator** — descending, mixed direction, locale-aware, semver, etc.:
+```ts
+indexes: {
+    tasksByPriority: {
+        key: "owner",
+        order: {
+            by: ["priority", "due"],
+            compare: (a, b) => b.priority - a.priority || a.due - b.due,   // priority desc, due asc
+        },
+    },
+}
+// db.indexes.tasksByPriority.find(ownerEntity) → readonly Entity[]   // ordered per comparator
+```
+
+### Order semantics
+
+- `order` is always a single object: `{ by, compare? }`. `by` declares which columns are read into the per-entity sort cache; `compare` (if present) is the comparator over `Pick<C, by>`. When `compare` is omitted, the default is ascending across `by` left-to-right with positional tie-break.
+- All direction control happens through the comparator — there are no `asc: true | false` booleans. Descending, mixed direction, case-insensitive, semver, and natural-sort comparators are all written the same way.
+
+### Auto-routing of `select`
+
+When `db.select(include, { where })` or `db.observe.select(...)` is called with a `where` clause that exactly matches the `key` of a declared raw index by equality, the query is served from the index instead of scanning archetypes. No code-site change required — declare the index and the planner picks it up. Other query shapes fall through to the archetype scan unchanged.
+
+### Maintenance and atomicity
+
+- Indexes are maintained *eagerly* per mutation, so `t.indexes.<name>` inside a transaction sees rows the transaction has just written.
+- Unique constraints are pre-checked before any column mutation. A conflict throws *from the offending insert/update call*; the existing transaction rollback path restores both the store and the index together. No partial mutation lands in either the store or the index.
+
+### Performance characteristics
+
+Index maintenance is **O(b)** per change, where `b` is the number of buckets the affected entity occupies (usually 1, more for multi-value fan-out). It is *never* proportional to total entities in the index or to a bucket's size. Sorting (when an `order` is declared) is deferred to the first read that touches a dirty bucket.
+
+| Declaration | Per-insert cost | Per-delete cost | Notes |
+|---|---|---|---|
+| `key: "col"` (non-unique) | `O(1)` | `O(1)` | `Set<Entity>` per bucket. |
+| `key: "col"`, `unique: true` | `O(1)` | `O(1)` | Map set; throws on duplicate. |
+| `key: ["a", "b", …]` | `O(k)` where `k` = key arity | `O(k)` | One serialized key per row. |
+| `key: (...) => v` (scalar) | `O(1 + compute)` | `O(1)` | Compute runs once per row. |
+| `key: "arr"` where `arr: T[]` | `O(m)` where `m` = array length | `O(m)` | One bucket per array element. |
+| `key: (...) => T[]` (multi) | `O(m + compute)` | `O(m)` | Same fan-out, derived. |
+| `key: { slot: ..., ... }` | `O(s + Π array sizes)` | `O(s + Π array sizes)` | `s` = slot count; cartesian fan-out across array-valued slots. |
+| `+ order: { by, compare? }` | adds `O(b)` for the snapshot | adds `O(b)` for cache invalidation. No comparator calls. |
+
+The crucial property: removing one entity from a non-unique bucket holding `N` entities is `O(1)`, not `O(N)`. Non-unique buckets are stored as `Set<Entity>` so `Set.delete` is the hot path — no `arr.indexOf` scan. Verified by `database.index.performance.test.ts`: deleting from a 40 000-entity bucket has the same per-delete cost as deleting from a 4 000-entity bucket.
+
+Reads pay one catch-up sort the first time they touch a dirty bucket:
+
+| Read | First call after writes | Subsequent calls |
+|---|---|---|
+| `find(key)` (unsorted) | `O(1)` Map lookup + `O(n)` slice | same |
+| `find(key)` (sorted, dirty) | `O(n log n)` sort, then slice | `O(1)` Map lookup + `O(n)` slice |
+| `findRange(filter)` | `O(B)` walk + per-matched-bucket sort if dirty | per-matched-bucket sort only on first read after a write |
+| `get(key)` (unique) | `O(1)` Map lookup | same |
+
+`B` = total bucket count for the index. A `find` against a bucket that has not received any writes since the previous `find` is free (clean buckets aren't re-sorted).
+
+**Unique-conflict timing:** the conflict check runs *before* the column store mutates. The throw originates from the insert/update call; the rollback path restores any state the transaction touched. Verified by `database.index.test.ts` ("unique conflict on insert is caught up-front — no partial store or index mutation") and `database.index.performance.test.ts`.
+
 ## Transactions
 
 Transactions are synchronous, deterministic functions that mutate the store. They automatically produce undo/redo operations and notify observers.

packages/data/src/ecs/database/combine-plugins.ts

@@ -26,15 +26,16 @@ export type CombinePlugins<Plugins extends readonly Database.Plugin[]> = Databas
   >,
   {} & IntersectAll<{ [K in keyof Plugins]: Plugins[K]['actions'] }>,
   {} & IntersectAll<{ [K in keyof Plugins]: Plugins[K]['services'] }>,
-  {} & IntersectAll<{ [K in keyof Plugins]: Plugins[K]['computed'] }>
+  {} & IntersectAll<{ [K in keyof Plugins]: Plugins[K]['computed'] }>,
+  {} & IntersectAll<{ [K in keyof Plugins]: Plugins[K]['indexes'] }>
 >;
 
 
 /**
  * Combines multiple plugins into a single plugin.
- * All plugin properties (components, resources, archetypes, computed, transactions, systems, actions, services)
+ * All plugin properties (components, resources, archetypes, indexes, computed, transactions, systems, actions, services)
  * require identity (===) when the same key exists across plugins.
- * 
+ *
  * IMPORTANT: Services are merged in order, preserving the initialization order
  * so that extended plugin services are initialized before current plugin services.
  */
@@ -48,9 +49,10 @@ export function combinePlugins<
   Extract<UnionAll<{ [K in keyof Plugins]: StringKeyof<Plugins[K]['systems']> }>, string>,
   {} & IntersectAll<{ [K in keyof Plugins]: Plugins[K]['actions'] }>,
   {} & IntersectAll<{ [K in keyof Plugins]: Plugins[K]['services'] }>,
-  {} & IntersectAll<{ [K in keyof Plugins]: Plugins[K]['computed'] }>
+  {} & IntersectAll<{ [K in keyof Plugins]: Plugins[K]['computed'] }>,
+  {} & IntersectAll<{ [K in keyof Plugins]: Plugins[K]['indexes'] }>
 > {
-  const keys = ['services', 'components', 'resources', 'archetypes', 'computed', 'transactions', 'actions', 'systems'] as const;
+  const keys = ['services', 'components', 'resources', 'archetypes', 'indexes', 'computed', 'transactions', 'actions', 'systems'] as const;
 
   const merge = (base: any, next: any) =>
     Object.fromEntries(keys.map(key => {
@@ -70,7 +72,7 @@ export function combinePlugins<
       return [key, merged];
     }));
 
-  const emptyPlugin = { components: {}, resources: {}, archetypes: {}, computed: {}, transactions: {}, actions: {}, systems: {}, services: {} };
+  const emptyPlugin = { components: {}, resources: {}, archetypes: {}, indexes: {}, computed: {}, transactions: {}, actions: {}, systems: {}, services: {} };
 
   // Merge all plugins together
   const result = plugins.reduce(merge, emptyPlugin);

packages/data/src/ecs/database/create-plugin.ts

@@ -1,6 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import { Database, SystemFunction, ServiceFactories, FromServiceFactories, FromComputedFactories, type PluginComputedFactories } from "./database.js";
+import { Database, SystemFunction, ServiceFactories, FromServiceFactories, FromComputedFactories, type PluginComputedFactories, type IndexDeclarations } from "./database.js";
 import type { ComponentSchemas } from "../component-schemas.js";
 import type { ResourceSchemas } from "../resource-schemas.js";
 import type { ArchetypeComponents } from "../store/archetype-components.js";
@@ -11,6 +11,7 @@ import type { StringKeyof, NoInfer, RemoveIndex } from "../../types/types.js";
 import { combinePlugins } from "./combine-plugins.js";
 import { Store } from "../store/store.js";
 
+
 /**
  * Direct-intersection return type for createPlugin.
  *
@@ -20,7 +21,7 @@ import { Store } from "../store/store.js";
  */
 type CreatePluginResult<
     XP extends Database.Plugin,
-    CS, RS, A, TD, S extends string, AD, SVF, CVF
+    CS, RS, A, TD, S extends string, AD, SVF, CVF, IX
 > = Database.Plugin<
     XP['components'] & CS,
     XP['resources'] & RS,
@@ -29,7 +30,8 @@ type CreatePluginResult<
     S | StringKeyof<XP['systems']>,
     XP['actions'] & AD,
     XP['services'] & SVF,
-    XP['computed'] & CVF
+    XP['computed'] & CVF,
+    XP['indexes'] & IX
 >;
 
 /**
@@ -49,7 +51,7 @@ type DatabaseWithServices<
 >;
 
 function validatePropertyOrder(plugins: Record<string, unknown>): void {
-    const expectedOrder = ['extends', 'services', 'components', 'resources', 'archetypes', 'computed', 'transactions', 'actions', 'systems'];
+    const expectedOrder = ['extends', 'services', 'components', 'resources', 'archetypes', 'indexes', 'computed', 'transactions', 'actions', 'systems'];
     const actualKeys = Object.keys(plugins);
     const definedKeys = actualKeys.filter(key => key in plugins);
 
@@ -84,11 +86,12 @@ function validatePropertyOrder(plugins: Record<string, unknown>): void {
  * 3. components (optional) - Component schema definitions
  * 4. resources (optional) - Resource schema definitions
  * 5. archetypes (optional) - Archetype definitions
- * 6. computed (optional) - Computed observe factories (each returns Observe<unknown>)
- * 7. transactions (optional) - Transaction declarations
- * 8. actions (optional) - Action declarations
- * 9. systems (optional) - System declarations
- * 
+ * 6. indexes (optional) - Index declarations over components
+ * 7. computed (optional) - Computed observe factories (each returns Observe<unknown>)
+ * 8. transactions (optional) - Transaction declarations
+ * 9. actions (optional) - Action declarations
+ * 10. systems (optional) - System declarations
+ *
  * Example:
  * ```ts
  * Database.Plugin.create({
@@ -99,10 +102,11 @@ function validatePropertyOrder(plugins: Record<string, unknown>): void {
  *   components: { ... },     // 3. components
  *   resources: { ... },      // 4. resources
  *   archetypes: { ... },     // 5. archetypes
- *   computed: { ... },       // 6. computed
- *   transactions: { ... },   // 7. transactions
- *   actions: { ... },        // 8. actions
- *   systems: { ... },        // 9. systems
+ *   indexes: { ... },        // 6. indexes
+ *   computed: { ... },       // 7. computed
+ *   transactions: { ... },   // 8. transactions
+ *   actions: { ... },        // 9. actions
+ *   systems: { ... },        // 10. systems
  * })
  * ```
  * 
@@ -131,11 +135,12 @@ type FullDBForPlugin<
 >;
 
 export function createPlugin<
-    const XP extends Database.Plugin<{}, {}, {}, {}, never, {}, {}, {}>,
+    const XP extends Database.Plugin<{}, {}, {}, {}, never, {}, {}, {}, {}>,
     const CS extends ComponentSchemas,
     const RS extends ResourceSchemas,
     const A extends ArchetypeComponents<StringKeyof<RemoveIndex<CS> & XP['components']>>,
-    const TD extends TransactionDeclarations<FromSchemas<RemoveIndex<CS> & XP['components']>, FromSchemas<RemoveIndex<RS> & XP['resources']>, RemoveIndex<A> & XP['archetypes']>,
+    const IX extends IndexDeclarations<FromSchemas<RemoveIndex<CS> & XP['components']>>,
+    const TD extends TransactionDeclarations<FromSchemas<RemoveIndex<CS> & XP['components']>, FromSchemas<RemoveIndex<RS> & XP['resources']>, RemoveIndex<A> & XP['archetypes'], RemoveIndex<IX> & XP['indexes']>,
     const AD,
     const S extends string = never,
     const SVF extends ServiceFactories<Database.FromPlugin<XP>> = {},
@@ -149,6 +154,7 @@ export function createPlugin<
         components?: CS,
         resources?: RS,
         archetypes?: A,
+        indexes?: IX,
         computed?: CVF & PluginComputedFactories<FullDBForPlugin<RemoveIndex<CS>, RemoveIndex<RS>, RemoveIndex<A>, {}, string, RemoveIndex<AD> & XP['actions'], XP, RemoveIndex<SVF>>>,
         transactions?: TD,
         actions?: AD & {
@@ -160,7 +166,8 @@ export function createPlugin<
                 S | StringKeyof<XP['systems']>,
                 ToActionFunctions<XP['actions']>,
                 FromServiceFactories<RemoveIndex<SVF> & XP['services']>,
-                FromComputedFactories<RemoveIndex<CVF> & XP['computed']>
+                FromComputedFactories<RemoveIndex<CVF> & XP['computed']>,
+                RemoveIndex<IX> & XP['indexes']
             >, input?: any) => any
         }
         systems?: { readonly [K in S]: {
@@ -172,7 +179,8 @@ export function createPlugin<
                 S | StringKeyof<XP['systems']>,
                 ToActionFunctions<RemoveIndex<AD> & XP['actions']>,
                 FromServiceFactories<RemoveIndex<SVF> & XP['services']>,
-                FromComputedFactories<RemoveIndex<CVF> & XP['computed']>
+                FromComputedFactories<RemoveIndex<CVF> & XP['computed']>,
+                RemoveIndex<IX> & XP['indexes']
             > & {
                 readonly store: Store<
                     FromSchemas<RemoveIndex<CS> & XP['components']>,
@@ -189,7 +197,7 @@ export function createPlugin<
         }
         },
     },
-): CreatePluginResult<XP, RemoveIndex<CS>, RemoveIndex<RS>, RemoveIndex<A>, RemoveIndex<TD>, S, AD, RemoveIndex<SVF>, RemoveIndex<CVF>> {
+): CreatePluginResult<XP, RemoveIndex<CS>, RemoveIndex<RS>, RemoveIndex<A>, RemoveIndex<TD>, S, AD, RemoveIndex<SVF>, RemoveIndex<CVF>, RemoveIndex<IX>> {
     validatePropertyOrder(plugins);
 
     // Normalize plugins descriptor to a plugin object in correct order
@@ -198,6 +206,7 @@ export function createPlugin<
         components: plugins.components ?? {},
         resources: plugins.resources ?? {},
         archetypes: plugins.archetypes ?? {},
+        indexes: plugins.indexes ?? {},
         computed: plugins.computed ?? {},
         transactions: plugins.transactions ?? {},
         actions: plugins.actions ?? {},