@oasys/oecs 0.5.4 → 0.6.0

package/dist/core/ecs/sparse_store.d.cts

@@ -1,6 +1,9 @@
 import { Brand, TypedArrayTag } from '../../type_primitives/index.cjs';
 import { ComponentSchema } from './component.cjs';
-/** Sparse-component handle id. A separate id space from `ComponentID` — it
+import { AccessorColumns } from './ref.cjs';
+import { SparseRestoreError } from '../restore_errors.cjs';
+export { SparseRestoreError };
+/** Sparse-component handle id. A separate id space from `ComponentID`. It
  * indexes `Store`'s `sparseStores`, never the archetype mask, which is the
  * mechanism by which sparse components escape the 128-bit identity cap. */
 export type SparseComponentID = Brand<number, "sparse_component_id">;
@@ -8,63 +11,118 @@ declare const __sparseSchema: unique symbol;
 export type SparseComponentDef<S extends ComponentSchema = ComponentSchema> = SparseComponentID & {
     readonly [__sparseSchema]: S;
 };
-/** Recover a sparse def's schema type — the sparse sibling of `SchemaOf`
+/** Recover a sparse def's schema type, the sparse sibling of `SchemaOf`
  * (component.ts), used by the typed `SystemContext` sparse surface. */
 export type SparseSchemaOf<D> = D extends SparseComponentDef<infer S extends ComponentSchema> ? S : never;
-/** One sparse component's membership + data. Pure data structure — the `Store`
- * owns liveness checks and dev-mode error throwing; this class only knows
- * entity indices and field rows. */
+/** One sparse component's membership + data. Pure data structure, the `Store`
+ * owns liveness checks and dev-mode error throwing. This class only knows
+ * entity indices and field values. */
 export declare class SparseComponentStore {
-    /** entity index → field-value row (length = field count; `[]` for a tag). */
-    private readonly _data;
     readonly fieldNames: string[];
     readonly fieldTypes: TypedArrayTag[];
     readonly fieldIndex: Record<string, number>;
+    /** The columns a ref or cursor reads through (ref.ts): the field columns at
+     * the global ids of their names, `NO_COLUMN` elsewhere. Refilled in place
+     * on every grow, so its identity is stable for the life of the store. */
+    readonly accCols: AccessorColumns;
+    /** One column for each field, indexed by entity index. All of one length,
+     * `_cap`. Replaced together on a grow. */
+    private _cols;
+    /** The numeric type tag of each field, for the kind-split element writes. */
+    private readonly _kinds;
+    /** True when every field is `f64`: the value writes then take one inline
+     * loop whose site sees `Float64Array` alone. */
+    private readonly _allF64;
+    /** The global name id of each field, in schema order. */
+    private readonly _gids;
+    /** The index capacity of `_cols` and `_pos`. */
+    private _cap;
+    /** Entity index → position in `_dense`, or `-1` when not a member. */
+    private _pos;
+    /** The member indices, valid in `[0, _size)`. */
+    private _dense;
+    private _size;
+    /** The row ticks, one for each entity index, or `null` until `trackTicks`.
+     * The row grain of change detection for a sparse component: `setField` and
+     * a mutable cursor's `at` stamp the member's entry, and a join zeroes it,
+     * because an add is structural. Grows with the columns. A scheduling
+     * artifact: not in the snapshot or the hash. */
+    ticks: Uint32Array | null;
+    /** The change tick of the last stamp on any member: the gate an entity-level
+     * onSet drain reads before it walks the members. */
+    changedTick: number;
+    /** The change tick below which every record was drained. See
+     * `Store.drainSparseSet`. */
+    drainTick: number;
+    /** The `run` of the last `Store.drainSparseSet`. A second drain at the same
+     * run returns the first one's array, so several consumers of the change
+     * feed share one drain instead of taking the members away from each
+     * other. */
+    lastDrainRun: number;
     constructor(fieldNames: string[], fieldTypes: TypedArrayTag[]);
     /** Number of entities holding this sparse component. */
     get size(): number;
-    /** Live entity indices that hold this component (dense, iteration order is
-     * SparseMap insertion/swap order — NOT canonical). Used by the hot query
-     * integration path; for the determinism surface use
-     * `canonicalIndices` instead. */
-    get indices(): readonly number[];
-    /** Live entity indices in **canonical** (ascending) order — the determinism
-     * ordering for `stateHash` + snapshot/restore. The native
-     * `indices` getter is insertion/swap order and would make two worlds with
-     * identical contents reached by different add/remove histories diverge, so
-     * the cold determinism paths sort here. Allocates a sorted copy each call;
-     * never call it on the hot query path. Indices are 20-bit entity indices,
+    /** Live entity indices that hold this component, as a view over the member
+     * list at the time of the call (iteration order is insertion and swap order.
+     * Not canonical). The view has a fixed length: a later add or remove is not
+     * visible through it, and a remove moves the last member into the hole. For
+     * a walk that must see its own mutations, loop `size` with `indexAt`, as the
+     * query driver does. For the determinism surface use `canonicalIndices`. */
+    get indices(): Uint32Array;
+    /** The member index at position `i` of the member list, `0 <= i < size`.
+     * Reads the live list, so a walk over `size` sees a swap-remove and an
+     * append made during the walk, exactly as a walk over a shrinking array
+     * did. */
+    indexAt(i: number): number;
+    /** Live entity indices in **canonical** (ascending) order, the determinism
+     * ordering for `stateHash`, snapshot and restore. The native
+     * `indices` order is insertion and swap order and would make two worlds with
+     * identical contents reached by different add and remove histories diverge, so
+     * the cold determinism paths sort here. Allocates a sorted copy each call,
+     * so never call it on the hot query path. Indices are 20-bit entity indices,
      * so the subtraction comparator can't overflow. */
     canonicalIndices(): number[];
-    /** The field-value row for `index` (length = field count; `[]` for a tag),
-     * or `undefined` if `index` isn't a member. Read-only view for the
-     * determinism paths (`stateHash`, snapshot); mutate via `setField`. */
+    /** The field-value row for `index` (length = field count, `[]` for a tag),
+     * or `undefined` if `index` isn't a member. A copy, read out of the columns
+     * for the determinism paths (`stateHash`, snapshot). Mutate via `setField`. */
     getRow(index: number): readonly number[] | undefined;
-    /** Drop all membership + data. Restore path only — `restoreSparseStores`
+    /** Drop all membership + data. Restore path only, `restoreSparseStores`
      * repopulates a cleared store from snapshot bytes. */
     clear(): void;
-    /** Insert the positional field-value `row` for `index`, taking ownership of
-     * the array. Restore path only; bypasses the name→index mapping `setRow`
-     * does, because snapshot bytes are already positional. */
-    setRawRow(index: number, row: number[]): void;
+    /** Insert the positional field-value `row` for `index`. Restore path only.
+     * It bypasses the name→index mapping `setRow` does, because snapshot bytes
+     * are already positional. Each value converts to its field's type. */
+    setRawRow(index: number, row: readonly number[]): void;
     has(index: number): boolean;
     /** Insert or overwrite the row for `index`, building it from `values`.
-     * Fields absent from `values` default to 0; a tag stores `[]`. */
-    setRow(index: number, values: Record<string, number>): void;
-    /** Drop `index`'s membership + data. Returns whether it was present. */
+     * Fields absent from `values` default to 0. A tag stores nothing. Each
+     * value converts to its field's type, as a typed array converts it. */
+    setRow(index: number, values: Record<string, number | undefined>): void;
+    /** Drop `index`'s membership. Returns whether it was present. The data at
+     * the index stays until the next add overwrites it. */
     remove(index: number): boolean;
     /** Read one field, or `undefined` if `index` doesn't hold this component. */
     getField(index: number, fieldIdx: number): number | undefined;
-    /** Write one field. Returns `false` (no-op) if `index` isn't a member. */
-    setField(index: number, fieldIdx: number, value: number): boolean;
+    /** Write one field, and stamp the row tick with `tick` when the store keeps
+     * one. Returns `false` (no-op) if `index` isn't a member. */
+    setField(index: number, fieldIdx: number, value: number, tick: number): boolean;
+    /** Keep a row tick for each entity index. Idempotent, never undone. */
+    trackTicks(): void;
+    /** Forget every record. A restore replaces the members and their values,
+     * so a tick that survived it would name a write that never happened. */
+    resetTicks(): void;
+    /** Make `index` a member, growing the columns to fit it. No-op for a
+     * member. */
+    private _join;
+    /** Double the index capacity until `index` fits, and move every column and
+     * the position map across. The accessor column array is refilled in place,
+     * so a held cursor keeps reading the live columns. */
+    private _growToFit;
 }
-export declare class SparseRestoreError extends Error {
-    constructor(message: string);
-}
-/** Serialize a registry of sparse stores into a self-contained byte buffer —
+/** Serialize a registry of sparse stores into a self-contained byte buffer,
  * the **sparse half** of a world snapshot (the dense half is the SAB snapshot,
- * `snapshotColumnStore`). Members are emitted in canonical (ascending
- * entity-index) order so the bytes are independent of insertion / removal
+ * `columnStoreBytesView`). Members are emitted in canonical (ascending
+ * entity-index) order so the bytes are independent of insertion and removal
  * history: two worlds with identical sparse contents reached by different
  * mutation orders serialize byte-for-byte the same.
  *
@@ -78,33 +136,32 @@ export declare class SparseRestoreError extends Error {
  *     u32 memberCount
  *     repeat memberCount times (canonical entity-index order):
  *       u32 entityIndex
- *       f64 × fieldCount   (the positional field row; none for a tag)
+ *       f64 × fieldCount   (the positional field row, none for a tag)
  *
  * `fieldCount` is redundant with the registered schema but is written so
  * `restoreSparseStores` can reject a snapshot whose shape doesn't match the
- * stores it's restoring into; `schemaHash` (a `schemaFingerprint` over the
+ * stores it's restoring into. `schemaHash` (a `schemaFingerprint` over the
  * field names + types) goes further and rejects a buffer whose shape matches
  * field-for-field but whose field **identity** doesn't. */
 export declare function snapshotSparseStores(stores: readonly SparseComponentStore[]): Uint8Array;
 /** Repopulate already-registered sparse stores from `snapshotSparseStores`
  * bytes, giving full-equality round-trip (membership + data). The `stores`
- * registry must already exist with the same shape the snapshot was taken from
- * — restore replays data into a world whose sparse components are registered
+ * registry must already exist with the same shape the snapshot was taken from.
+ * Restore replays data into a world whose sparse components are registered
  * in the same order (the registration is code, not snapshot state). Each store
  * is cleared first, so restoring is idempotent and drops any pre-existing rows.
  *
  * Throws `SparseRestoreError` on any shape or identity mismatch (store count,
  * field count, schema-hash field identity, an entity index past `MAX_INDEX`,
- * or a truncated / over-long buffer) rather than silently corrupting state.
- * The index bound matters because the index keys a `SparseMap` whose backing
- * array grows to `index` length — an unvalidated crafted u32 (up to ~4.29e9)
- * would allocate multi-GB. */
+ * or a truncated or over-long buffer) rather than silently corrupting state.
+ * The index bound matters because the columns of a store grow to fit the
+ * highest member index, an unvalidated crafted u32 (up to ~4.29e9) would ask
+ * for a multi-GB column for each field. */
 export declare function restoreSparseStores(stores: readonly SparseComponentStore[], bytes: Uint8Array): void;
 /** Read-only validation of a `snapshotSparseStores` buffer against the live
- * registry, WITHOUT mutating any store. Mirrors `restoreSparseStores`'s
- * shape/field-identity/index-bounds/frame checks so `Store.restoreInto` can fail
- * closed on a sparse-registration mismatch BEFORE the dense mount overwrites live
- * column data. Throws `SparseRestoreError` on any mismatch / malformed buffer. */
-export declare function validateSparseStores(stores: readonly SparseComponentStore[], bytes: Uint8Array): void;
-export {};
+ * registry, without mutating any store. Mirrors `restoreSparseStores`'s
+ * shape, field-identity, index-bounds and frame checks so `Store.restore` can fail
+ * closed on a sparse-registration mismatch before the dense mount overwrites live
+ * column data. Throws `SparseRestoreError` on any mismatch or malformed buffer. */
+export declare function assertSparseStores(stores: readonly SparseComponentStore[], bytes: Uint8Array): void;
 //# sourceMappingURL=sparse_store.d.ts.map

package/dist/core/ecs/sparse_store.d.ts

@@ -1,6 +1,9 @@
 import { Brand, TypedArrayTag } from '../../type_primitives/index.js';
 import { ComponentSchema } from './component.js';
-/** Sparse-component handle id. A separate id space from `ComponentID` — it
+import { AccessorColumns } from './ref.js';
+import { SparseRestoreError } from '../restore_errors.js';
+export { SparseRestoreError };
+/** Sparse-component handle id. A separate id space from `ComponentID`. It
  * indexes `Store`'s `sparseStores`, never the archetype mask, which is the
  * mechanism by which sparse components escape the 128-bit identity cap. */
 export type SparseComponentID = Brand<number, "sparse_component_id">;
@@ -8,63 +11,118 @@ declare const __sparseSchema: unique symbol;
 export type SparseComponentDef<S extends ComponentSchema = ComponentSchema> = SparseComponentID & {
     readonly [__sparseSchema]: S;
 };
-/** Recover a sparse def's schema type — the sparse sibling of `SchemaOf`
+/** Recover a sparse def's schema type, the sparse sibling of `SchemaOf`
  * (component.ts), used by the typed `SystemContext` sparse surface. */
 export type SparseSchemaOf<D> = D extends SparseComponentDef<infer S extends ComponentSchema> ? S : never;
-/** One sparse component's membership + data. Pure data structure — the `Store`
- * owns liveness checks and dev-mode error throwing; this class only knows
- * entity indices and field rows. */
+/** One sparse component's membership + data. Pure data structure, the `Store`
+ * owns liveness checks and dev-mode error throwing. This class only knows
+ * entity indices and field values. */
 export declare class SparseComponentStore {
-    /** entity index → field-value row (length = field count; `[]` for a tag). */
-    private readonly _data;
     readonly fieldNames: string[];
     readonly fieldTypes: TypedArrayTag[];
     readonly fieldIndex: Record<string, number>;
+    /** The columns a ref or cursor reads through (ref.ts): the field columns at
+     * the global ids of their names, `NO_COLUMN` elsewhere. Refilled in place
+     * on every grow, so its identity is stable for the life of the store. */
+    readonly accCols: AccessorColumns;
+    /** One column for each field, indexed by entity index. All of one length,
+     * `_cap`. Replaced together on a grow. */
+    private _cols;
+    /** The numeric type tag of each field, for the kind-split element writes. */
+    private readonly _kinds;
+    /** True when every field is `f64`: the value writes then take one inline
+     * loop whose site sees `Float64Array` alone. */
+    private readonly _allF64;
+    /** The global name id of each field, in schema order. */
+    private readonly _gids;
+    /** The index capacity of `_cols` and `_pos`. */
+    private _cap;
+    /** Entity index → position in `_dense`, or `-1` when not a member. */
+    private _pos;
+    /** The member indices, valid in `[0, _size)`. */
+    private _dense;
+    private _size;
+    /** The row ticks, one for each entity index, or `null` until `trackTicks`.
+     * The row grain of change detection for a sparse component: `setField` and
+     * a mutable cursor's `at` stamp the member's entry, and a join zeroes it,
+     * because an add is structural. Grows with the columns. A scheduling
+     * artifact: not in the snapshot or the hash. */
+    ticks: Uint32Array | null;
+    /** The change tick of the last stamp on any member: the gate an entity-level
+     * onSet drain reads before it walks the members. */
+    changedTick: number;
+    /** The change tick below which every record was drained. See
+     * `Store.drainSparseSet`. */
+    drainTick: number;
+    /** The `run` of the last `Store.drainSparseSet`. A second drain at the same
+     * run returns the first one's array, so several consumers of the change
+     * feed share one drain instead of taking the members away from each
+     * other. */
+    lastDrainRun: number;
     constructor(fieldNames: string[], fieldTypes: TypedArrayTag[]);
     /** Number of entities holding this sparse component. */
     get size(): number;
-    /** Live entity indices that hold this component (dense, iteration order is
-     * SparseMap insertion/swap order — NOT canonical). Used by the hot query
-     * integration path; for the determinism surface use
-     * `canonicalIndices` instead. */
-    get indices(): readonly number[];
-    /** Live entity indices in **canonical** (ascending) order — the determinism
-     * ordering for `stateHash` + snapshot/restore. The native
-     * `indices` getter is insertion/swap order and would make two worlds with
-     * identical contents reached by different add/remove histories diverge, so
-     * the cold determinism paths sort here. Allocates a sorted copy each call;
-     * never call it on the hot query path. Indices are 20-bit entity indices,
+    /** Live entity indices that hold this component, as a view over the member
+     * list at the time of the call (iteration order is insertion and swap order.
+     * Not canonical). The view has a fixed length: a later add or remove is not
+     * visible through it, and a remove moves the last member into the hole. For
+     * a walk that must see its own mutations, loop `size` with `indexAt`, as the
+     * query driver does. For the determinism surface use `canonicalIndices`. */
+    get indices(): Uint32Array;
+    /** The member index at position `i` of the member list, `0 <= i < size`.
+     * Reads the live list, so a walk over `size` sees a swap-remove and an
+     * append made during the walk, exactly as a walk over a shrinking array
+     * did. */
+    indexAt(i: number): number;
+    /** Live entity indices in **canonical** (ascending) order, the determinism
+     * ordering for `stateHash`, snapshot and restore. The native
+     * `indices` order is insertion and swap order and would make two worlds with
+     * identical contents reached by different add and remove histories diverge, so
+     * the cold determinism paths sort here. Allocates a sorted copy each call,
+     * so never call it on the hot query path. Indices are 20-bit entity indices,
      * so the subtraction comparator can't overflow. */
     canonicalIndices(): number[];
-    /** The field-value row for `index` (length = field count; `[]` for a tag),
-     * or `undefined` if `index` isn't a member. Read-only view for the
-     * determinism paths (`stateHash`, snapshot); mutate via `setField`. */
+    /** The field-value row for `index` (length = field count, `[]` for a tag),
+     * or `undefined` if `index` isn't a member. A copy, read out of the columns
+     * for the determinism paths (`stateHash`, snapshot). Mutate via `setField`. */
     getRow(index: number): readonly number[] | undefined;
-    /** Drop all membership + data. Restore path only — `restoreSparseStores`
+    /** Drop all membership + data. Restore path only, `restoreSparseStores`
      * repopulates a cleared store from snapshot bytes. */
     clear(): void;
-    /** Insert the positional field-value `row` for `index`, taking ownership of
-     * the array. Restore path only; bypasses the name→index mapping `setRow`
-     * does, because snapshot bytes are already positional. */
-    setRawRow(index: number, row: number[]): void;
+    /** Insert the positional field-value `row` for `index`. Restore path only.
+     * It bypasses the name→index mapping `setRow` does, because snapshot bytes
+     * are already positional. Each value converts to its field's type. */
+    setRawRow(index: number, row: readonly number[]): void;
     has(index: number): boolean;
     /** Insert or overwrite the row for `index`, building it from `values`.
-     * Fields absent from `values` default to 0; a tag stores `[]`. */
-    setRow(index: number, values: Record<string, number>): void;
-    /** Drop `index`'s membership + data. Returns whether it was present. */
+     * Fields absent from `values` default to 0. A tag stores nothing. Each
+     * value converts to its field's type, as a typed array converts it. */
+    setRow(index: number, values: Record<string, number | undefined>): void;
+    /** Drop `index`'s membership. Returns whether it was present. The data at
+     * the index stays until the next add overwrites it. */
     remove(index: number): boolean;
     /** Read one field, or `undefined` if `index` doesn't hold this component. */
     getField(index: number, fieldIdx: number): number | undefined;
-    /** Write one field. Returns `false` (no-op) if `index` isn't a member. */
-    setField(index: number, fieldIdx: number, value: number): boolean;
+    /** Write one field, and stamp the row tick with `tick` when the store keeps
+     * one. Returns `false` (no-op) if `index` isn't a member. */
+    setField(index: number, fieldIdx: number, value: number, tick: number): boolean;
+    /** Keep a row tick for each entity index. Idempotent, never undone. */
+    trackTicks(): void;
+    /** Forget every record. A restore replaces the members and their values,
+     * so a tick that survived it would name a write that never happened. */
+    resetTicks(): void;
+    /** Make `index` a member, growing the columns to fit it. No-op for a
+     * member. */
+    private _join;
+    /** Double the index capacity until `index` fits, and move every column and
+     * the position map across. The accessor column array is refilled in place,
+     * so a held cursor keeps reading the live columns. */
+    private _growToFit;
 }
-export declare class SparseRestoreError extends Error {
-    constructor(message: string);
-}
-/** Serialize a registry of sparse stores into a self-contained byte buffer —
+/** Serialize a registry of sparse stores into a self-contained byte buffer,
  * the **sparse half** of a world snapshot (the dense half is the SAB snapshot,
- * `snapshotColumnStore`). Members are emitted in canonical (ascending
- * entity-index) order so the bytes are independent of insertion / removal
+ * `columnStoreBytesView`). Members are emitted in canonical (ascending
+ * entity-index) order so the bytes are independent of insertion and removal
  * history: two worlds with identical sparse contents reached by different
  * mutation orders serialize byte-for-byte the same.
  *
@@ -78,33 +136,32 @@ export declare class SparseRestoreError extends Error {
  *     u32 memberCount
  *     repeat memberCount times (canonical entity-index order):
  *       u32 entityIndex
- *       f64 × fieldCount   (the positional field row; none for a tag)
+ *       f64 × fieldCount   (the positional field row, none for a tag)
  *
  * `fieldCount` is redundant with the registered schema but is written so
  * `restoreSparseStores` can reject a snapshot whose shape doesn't match the
- * stores it's restoring into; `schemaHash` (a `schemaFingerprint` over the
+ * stores it's restoring into. `schemaHash` (a `schemaFingerprint` over the
  * field names + types) goes further and rejects a buffer whose shape matches
  * field-for-field but whose field **identity** doesn't. */
 export declare function snapshotSparseStores(stores: readonly SparseComponentStore[]): Uint8Array;
 /** Repopulate already-registered sparse stores from `snapshotSparseStores`
  * bytes, giving full-equality round-trip (membership + data). The `stores`
- * registry must already exist with the same shape the snapshot was taken from
- * — restore replays data into a world whose sparse components are registered
+ * registry must already exist with the same shape the snapshot was taken from.
+ * Restore replays data into a world whose sparse components are registered
  * in the same order (the registration is code, not snapshot state). Each store
  * is cleared first, so restoring is idempotent and drops any pre-existing rows.
  *
  * Throws `SparseRestoreError` on any shape or identity mismatch (store count,
  * field count, schema-hash field identity, an entity index past `MAX_INDEX`,
- * or a truncated / over-long buffer) rather than silently corrupting state.
- * The index bound matters because the index keys a `SparseMap` whose backing
- * array grows to `index` length — an unvalidated crafted u32 (up to ~4.29e9)
- * would allocate multi-GB. */
+ * or a truncated or over-long buffer) rather than silently corrupting state.
+ * The index bound matters because the columns of a store grow to fit the
+ * highest member index, an unvalidated crafted u32 (up to ~4.29e9) would ask
+ * for a multi-GB column for each field. */
 export declare function restoreSparseStores(stores: readonly SparseComponentStore[], bytes: Uint8Array): void;
 /** Read-only validation of a `snapshotSparseStores` buffer against the live
- * registry, WITHOUT mutating any store. Mirrors `restoreSparseStores`'s
- * shape/field-identity/index-bounds/frame checks so `Store.restoreInto` can fail
- * closed on a sparse-registration mismatch BEFORE the dense mount overwrites live
- * column data. Throws `SparseRestoreError` on any mismatch / malformed buffer. */
-export declare function validateSparseStores(stores: readonly SparseComponentStore[], bytes: Uint8Array): void;
-export {};
+ * registry, without mutating any store. Mirrors `restoreSparseStores`'s
+ * shape, field-identity, index-bounds and frame checks so `Store.restore` can fail
+ * closed on a sparse-registration mismatch before the dense mount overwrites live
+ * column data. Throws `SparseRestoreError` on any mismatch or malformed buffer. */
+export declare function assertSparseStores(stores: readonly SparseComponentStore[], bytes: Uint8Array): void;
 //# sourceMappingURL=sparse_store.d.ts.map

package/dist/core/ecs/sparse_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sparse_store.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/sparse_store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KA0BK;AAEL,OAAO,EAAE,KAAK,EAAa,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAGnD;;2EAE2E;AAC3E,MAAM,MAAM,iBAAiB,GAAG,KAAK,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;AAOrE,OAAO,CAAC,MAAM,cAAc,EAAE,OAAO,MAAM,CAAC;AAE5C,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,eAAe,GAAG,eAAe,IAAI,iBAAiB,GAAG;IACjG,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;CAC7B,CAAC;AAEF;uEACuE;AACvE,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,kBAAkB,CAAC,MAAM,CAAC,SAAS,eAAe,CAAC,GAC1F,CAAC,GACD,KAAK,CAAC;AAET;;oCAEoC;AACpC,qBAAa,oBAAoB;IAChC,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;IACnD,SAAgB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrC,SAAgB,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5C,SAAgB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAEvC,UAAU,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE;IAQ7D,wDAAwD;IACxD,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;qCAGiC;IACjC,IAAW,OAAO,IAAI,SAAS,MAAM,EAAE,CAEtC;IAED;;;;;;uDAMmD;IAC5C,gBAAgB,IAAI,MAAM,EAAE;IAInC;;2EAEuE;IAChE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS;IAI3D;0DACsD;IAC/C,KAAK,IAAI,IAAI;IAIpB;;8DAE0D;IACnD,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI;IAI7C,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIlC;sEACkE;IAC3D,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAUlE,wEAAwE;IACjE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIrC,6EAA6E;IACtE,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKpE,0EAA0E;IACnE,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;CAMxE;AAED,qBAAa,kBAAmB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI3B;AAuCD;;;;;;;;;;;;;;;;;;;;;;;2DAuB2D;AAC3D,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,oBAAoB,EAAE,GAAG,UAAU,CAuCxF;AAED;;;;;;;;;;;;8BAY8B;AAC9B,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,SAAS,oBAAoB,EAAE,EACvC,KAAK,EAAE,UAAU,GACf,IAAI,CAkEN;AAED;;;;kFAIkF;AAClF,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,SAAS,oBAAoB,EAAE,EACvC,KAAK,EAAE,UAAU,GACf,IAAI,CA4DN"}
+{"version":3,"file":"sparse_store.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/sparse_store.ts"],"names":[],"mappings":"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"}