@aethervtt/shard-core 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+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.

package/README.md

@@ -0,0 +1,3 @@
+# @aethervtt/shard-core
+
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/ecs/commands.d.ts

@@ -0,0 +1,35 @@
+import type { ComponentDef } from '../schema/component.js';
+import type { Fields, InitFields } from '../schema/field.js';
+import type { Entity } from './entity.js';
+import type { ComponentInit, World } from './world.js';
+/**
+ * Deferred world changes, applied in issue order at the next sync point. Use these for
+ * structural changes (spawn, despawn, add, remove) while iterating a query.
+ *
+ * Stored in flat, reused arrays: after warm-up, recording a command doesn't allocate
+ * beyond the values you pass in.
+ */
+export declare class Commands {
+    private readonly ops;
+    private readonly targets;
+    private readonly defs;
+    private readonly payloads;
+    /** The world the commands apply to. */
+    readonly world: World;
+    constructor(world: World);
+    get length(): number;
+    /** Reserves an entity id now; the entity comes alive when the commands apply. */
+    spawn(...inits: ComponentInit[]): Entity;
+    /** Despawns the entity and its descendants. Already-dead entities are skipped. */
+    despawn(entity: Entity): void;
+    despawnSingle(entity: Entity): void;
+    add<F extends Fields>(entity: Entity, component: ComponentDef<F>, value?: InitFields<F>): void;
+    remove(entity: Entity, component: ComponentDef): void;
+    set<F extends Fields>(entity: Entity, component: ComponentDef<F>, value: InitFields<F>): void;
+    /** Runs arbitrary code against the world at apply time. */
+    run(fn: (world: World) => void): void;
+    /** Applies every recorded command in order, then clears the buffer. */
+    apply(): void;
+    clear(): void;
+    private push;
+}

package/dist/ecs/commands.js

@@ -0,0 +1,96 @@
+const SPAWN = 0;
+const DESPAWN = 1;
+const DESPAWN_SINGLE = 2;
+const ADD = 3;
+const REMOVE = 4;
+const SET = 5;
+const RUN = 6;
+class Commands {
+  ops = [];
+  targets = [];
+  defs = [];
+  payloads = [];
+  /** The world the commands apply to. */
+  world;
+  constructor(world) {
+    this.world = world;
+  }
+  get length() {
+    return this.ops.length;
+  }
+  /** Reserves an entity id now; the entity comes alive when the commands apply. */
+  spawn(...inits) {
+    const entity = this.world.reserveEntity();
+    this.push(SPAWN, entity, void 0, inits);
+    return entity;
+  }
+  /** Despawns the entity and its descendants. Already-dead entities are skipped. */
+  despawn(entity) {
+    this.push(DESPAWN, entity, void 0, void 0);
+  }
+  despawnSingle(entity) {
+    this.push(DESPAWN_SINGLE, entity, void 0, void 0);
+  }
+  add(entity, component, value) {
+    this.push(ADD, entity, component, value);
+  }
+  remove(entity, component) {
+    this.push(REMOVE, entity, component, void 0);
+  }
+  set(entity, component, value) {
+    this.push(SET, entity, component, value);
+  }
+  /** Runs arbitrary code against the world at apply time. */
+  run(fn) {
+    this.push(RUN, -1, void 0, fn);
+  }
+  /** Applies every recorded command in order, then clears the buffer. */
+  apply() {
+    const world = this.world;
+    for (let i = 0; i < this.ops.length; i++) {
+      const entity = this.targets[i];
+      const def = this.defs[i];
+      const payload = this.payloads[i];
+      switch (this.ops[i]) {
+        case SPAWN:
+          world.spawnReserved(entity, payload);
+          break;
+        case DESPAWN:
+          if (world.isAlive(entity)) world.despawn(entity);
+          break;
+        case DESPAWN_SINGLE:
+          if (world.isAlive(entity)) world.despawnSingle(entity);
+          break;
+        case ADD:
+          world.add(entity, def, payload);
+          break;
+        case REMOVE:
+          world.remove(entity, def);
+          break;
+        case SET:
+          world.set(entity, def, payload);
+          break;
+        case RUN:
+          ;
+          payload(world);
+          break;
+      }
+    }
+    this.clear();
+  }
+  clear() {
+    this.ops.length = 0;
+    this.targets.length = 0;
+    this.defs.length = 0;
+    this.payloads.length = 0;
+  }
+  push(op, entity, def, payload) {
+    this.ops.push(op);
+    this.targets.push(entity);
+    this.defs.push(def);
+    this.payloads.push(payload);
+  }
+}
+export {
+  Commands
+};

package/dist/ecs/entity.d.ts

@@ -0,0 +1,11 @@
+/**
+ * An entity id: `index + generation * 2^22`. Plain number, safe integer, serializable.
+ * The index addresses per-entity storage; the generation detects stale ids.
+ */
+export type Entity = number;
+export declare const MAX_ENTITIES = 4194304;
+export declare const entityIndex: (e: Entity) => number;
+export declare const entityGeneration: (e: Entity) => number;
+export declare const makeEntity: (index: number, generation: number) => Entity;
+/** Human-readable form, e.g. `12v3` (index 12, generation 3). */
+export declare const formatEntity: (e: Entity) => string;

package/dist/ecs/entity.js

@@ -0,0 +1,12 @@
+const MAX_ENTITIES = 4194304;
+const entityIndex = (e) => e % MAX_ENTITIES;
+const entityGeneration = (e) => Math.floor(e / MAX_ENTITIES);
+const makeEntity = (index, generation) => generation * MAX_ENTITIES + index;
+const formatEntity = (e) => `${entityIndex(e)}v${entityGeneration(e)}`;
+export {
+  MAX_ENTITIES,
+  entityGeneration,
+  entityIndex,
+  formatEntity,
+  makeEntity
+};

package/dist/ecs/events.d.ts

@@ -0,0 +1,34 @@
+import type { EventDef } from '../schema/resource.js';
+/**
+ * Double-buffered event storage. Events sent during frame N are readable during frames N and
+ * N+1, then dropped. Every event has a sequence number so readers can track what they've seen.
+ */
+export declare class EventQueue<T> {
+    private older;
+    private newer;
+    private olderStart;
+    private newerStart;
+    private sent;
+    readonly def: EventDef<T>;
+    constructor(def: EventDef<T>);
+    send(event: T): void;
+    /** Called once per frame by the app. Drops events older than one frame. */
+    update(): void;
+    /** Events currently buffered (both frames). */
+    get length(): number;
+    /** @internal Copies events with sequence >= cursor into `out`. Returns the new cursor. */
+    readFrom(cursor: number, out: T[]): number;
+    /** @internal */
+    get oldestSequence(): number;
+}
+/** Independent cursor over an event queue. Several readers can consume the same events. */
+export declare class EventReader<T> {
+    private cursor;
+    private readonly scratch;
+    private readonly queue;
+    constructor(queue: EventQueue<T>);
+    /** Events not yet seen by this reader. The array is reused: copy it to keep it. */
+    read(): readonly T[];
+    /** Marks everything as seen without returning it. */
+    clear(): void;
+}

package/dist/ecs/events.js

@@ -0,0 +1,65 @@
+class EventQueue {
+  older = [];
+  newer = [];
+  olderStart = 0;
+  newerStart = 0;
+  sent = 0;
+  def;
+  constructor(def) {
+    this.def = def;
+  }
+  send(event) {
+    this.newer.push(event);
+    this.sent++;
+  }
+  /** Called once per frame by the app. Drops events older than one frame. */
+  update() {
+    const dropped = this.older;
+    this.older = this.newer;
+    this.olderStart = this.newerStart;
+    dropped.length = 0;
+    this.newer = dropped;
+    this.newerStart = this.sent;
+  }
+  /** Events currently buffered (both frames). */
+  get length() {
+    return this.older.length + this.newer.length;
+  }
+  /** @internal Copies events with sequence >= cursor into `out`. Returns the new cursor. */
+  readFrom(cursor, out) {
+    const start = Math.max(cursor, this.olderStart);
+    for (let i = start - this.olderStart; i < this.older.length; i++) out.push(this.older[i]);
+    const newerFrom = Math.max(cursor, this.newerStart);
+    for (let i = newerFrom - this.newerStart; i < this.newer.length; i++) out.push(this.newer[i]);
+    return this.sent;
+  }
+  /** @internal */
+  get oldestSequence() {
+    return this.olderStart;
+  }
+}
+class EventReader {
+  cursor;
+  scratch = [];
+  queue;
+  constructor(queue) {
+    this.queue = queue;
+    this.cursor = queue.oldestSequence;
+  }
+  /** Events not yet seen by this reader. The array is reused: copy it to keep it. */
+  read() {
+    this.scratch.length = 0;
+    this.cursor = this.queue.readFrom(this.cursor, this.scratch);
+    return this.scratch;
+  }
+  /** Marks everything as seen without returning it. */
+  clear() {
+    this.scratch.length = 0;
+    this.cursor = this.queue.readFrom(this.cursor, this.scratch);
+    this.scratch.length = 0;
+  }
+}
+export {
+  EventQueue,
+  EventReader
+};

package/dist/ecs/hierarchy.d.ts

@@ -0,0 +1,7 @@
+export declare const ChildOf: import("..").ComponentDef<{
+    readonly parent: import("..").FieldType<number | null, "f64">;
+}>;
+export declare const Children: import("..").ComponentDef<{
+    readonly entities: import("..").FieldType<(number | null)[], "object">;
+}>;
+export declare const Derived: import("..").TagDef;

package/dist/ecs/hierarchy.js

@@ -0,0 +1,29 @@
+import { defineComponent, defineTag } from "../schema/component.js";
+import { t } from "../schema/field.js";
+const ChildOf = defineComponent(
+  "core/ChildOf",
+  { parent: t.entity({ description: "The parent entity." }) },
+  { description: "Makes this entity a child of another. Despawning the parent despawns it." }
+);
+const Children = defineComponent(
+  "core/Children",
+  {
+    entities: t.list(t.entity, {
+      readonly: true,
+      description: "Maintained automatically from ChildOf. Do not write."
+    })
+  },
+  {
+    description: "The direct children of this entity, in insertion order. Derived from ChildOf.",
+    serialize: false
+  }
+);
+const Derived = defineTag("core/Derived", {
+  description: "An entity the engine rebuilds from other state every run (terrain chunks). Saved games and world hashes leave it out.",
+  serialize: false
+});
+export {
+  ChildOf,
+  Children,
+  Derived
+};

package/dist/ecs/index.d.ts

@@ -0,0 +1,8 @@
+export { Commands } from './commands.js';
+export { type Entity, entityGeneration, entityIndex, formatEntity, MAX_ENTITIES, makeEntity, } from './entity.js';
+export { EventQueue, EventReader } from './events.js';
+export { ChildOf, Children, Derived } from './hierarchy.js';
+export { type LifecycleEvent, type LifecycleKind, type LifecycleObserver, type LifecycleTrigger, onAdd, onRemove, onSet, type TriggerEvent, type TriggerObserver, } from './observers.js';
+export { Query, type QueryDescriptor } from './query.js';
+export { type ColumnOf, ComponentStorage, Table, type TickSource } from './table.js';
+export { type ComponentInit, World, type WorldStats } from './world.js';

package/dist/ecs/index.js

@@ -0,0 +1,38 @@
+import { Commands } from "./commands.js";
+import {
+  entityGeneration,
+  entityIndex,
+  formatEntity,
+  MAX_ENTITIES,
+  makeEntity
+} from "./entity.js";
+import { EventQueue, EventReader } from "./events.js";
+import { ChildOf, Children, Derived } from "./hierarchy.js";
+import {
+  onAdd,
+  onRemove,
+  onSet
+} from "./observers.js";
+import { Query } from "./query.js";
+import { ComponentStorage, Table } from "./table.js";
+import { World } from "./world.js";
+export {
+  ChildOf,
+  Children,
+  Commands,
+  ComponentStorage,
+  Derived,
+  EventQueue,
+  EventReader,
+  MAX_ENTITIES,
+  Query,
+  Table,
+  World,
+  entityGeneration,
+  entityIndex,
+  formatEntity,
+  makeEntity,
+  onAdd,
+  onRemove,
+  onSet
+};

package/dist/ecs/observers.d.ts

@@ -0,0 +1,40 @@
+import type { ComponentDef } from '../schema/component.js';
+import type { Fields, InferFields } from '../schema/field.js';
+import type { EventDef } from '../schema/resource.js';
+import type { Entity } from './entity.js';
+import type { World } from './world.js';
+export type LifecycleKind = 'add' | 'remove' | 'set';
+export interface LifecycleTrigger<F extends Fields = Fields> {
+    readonly kind: LifecycleKind;
+    readonly component: ComponentDef<F>;
+}
+/** Fires after the component is added (not when an existing one is replaced; that's `onSet`). */
+export declare const onAdd: <F extends Fields>(component: ComponentDef<F>) => LifecycleTrigger<F>;
+/** Fires before the component is removed, including on despawn. The value is still readable. */
+export declare const onRemove: <F extends Fields>(component: ComponentDef<F>) => LifecycleTrigger<F>;
+/** Fires after `world.set`, or after `world.add` replaces an existing value. */
+export declare const onSet: <F extends Fields>(component: ComponentDef<F>) => LifecycleTrigger<F>;
+export interface LifecycleEvent<F extends Fields = Fields> {
+    readonly kind: LifecycleKind;
+    readonly entity: Entity;
+    readonly component: ComponentDef<F>;
+    readonly world: World;
+    /** For `set`: the value before the write. */
+    readonly previous: InferFields<F> | undefined;
+}
+export interface TriggerEvent<T> {
+    readonly event: EventDef<T>;
+    readonly data: T;
+    readonly entity: Entity | undefined;
+    readonly world: World;
+}
+export type LifecycleObserver<F extends Fields = Fields> = (event: LifecycleEvent<F>) => void;
+export type TriggerObserver<T> = (event: TriggerEvent<T>) => void;
+/** Observer lists indexed by component or event id. */
+export declare class ObserverTable {
+    readonly add: (LifecycleObserver[] | undefined)[];
+    readonly remove: (LifecycleObserver[] | undefined)[];
+    readonly set: (LifecycleObserver[] | undefined)[];
+    readonly custom: (TriggerObserver<unknown>[] | undefined)[];
+    listFor(kind: LifecycleKind): (LifecycleObserver[] | undefined)[];
+}

package/dist/ecs/observers.js

@@ -0,0 +1,27 @@
+const onAdd = (component) => ({
+  kind: "add",
+  component
+});
+const onRemove = (component) => ({
+  kind: "remove",
+  component
+});
+const onSet = (component) => ({
+  kind: "set",
+  component
+});
+class ObserverTable {
+  add = [];
+  remove = [];
+  set = [];
+  custom = [];
+  listFor(kind) {
+    return kind === "add" ? this.add : kind === "remove" ? this.remove : this.set;
+  }
+}
+export {
+  ObserverTable,
+  onAdd,
+  onRemove,
+  onSet
+};

package/dist/ecs/query.d.ts

@@ -0,0 +1,44 @@
+import type { ComponentDef } from '../schema/component.js';
+import type { Entity } from './entity.js';
+import type { Table } from './table.js';
+export interface QueryDescriptor {
+    /** Entities must have all of these. */
+    with?: readonly ComponentDef[];
+    /** Entities must have none of these. */
+    without?: readonly ComponentDef[];
+    /** Documents components the system may read if present. Doesn't affect matching. */
+    optional?: readonly ComponentDef[];
+    /** Row filter: component added since the `since` tick passed to `each`/`count`. Implies `with`. */
+    added?: readonly ComponentDef[];
+    /** Row filter: component changed since the `since` tick. Implies `with`. */
+    changed?: readonly ComponentDef[];
+}
+export declare function queryKey(desc: QueryDescriptor): string;
+/**
+ * A cached list of tables matching a descriptor. The world keeps `tables` up to date as new
+ * archetypes appear. Create queries once (in system setup) and reuse them.
+ *
+ * Hot loops should walk `tables` directly; `each` is for cold code.
+ */
+export declare class Query {
+    readonly tables: Table[];
+    readonly with: readonly ComponentDef[];
+    readonly without: readonly ComponentDef[];
+    readonly optional: readonly ComponentDef[];
+    readonly added: readonly ComponentDef[];
+    readonly changed: readonly ComponentDef[];
+    private readonly withIds;
+    private readonly withoutIds;
+    constructor(desc: QueryDescriptor);
+    /** @internal Called by the world for every table, once. */
+    consider(table: Table): void;
+    /** Whether a row passes the `added` / `changed` filters for a given `since` tick. */
+    passes(table: Table, row: number, since: number): boolean;
+    /**
+     * Calls `fn` for each matching row. `since` is the tick for `added`/`changed` filters
+     * (a system passes `ctx.lastRunTick`). Don't make structural changes inside `fn`; use commands.
+     */
+    each(fn: (entity: Entity, row: number, table: Table) => void, since?: number): void;
+    count(since?: number): number;
+    entities(since?: number): Entity[];
+}

package/dist/ecs/query.js

@@ -0,0 +1,67 @@
+function queryKey(desc) {
+  const ids = (defs) => (defs ?? []).map((d) => d.id).sort((a, b) => a - b).join(",");
+  return `w${ids(desc.with)}|x${ids(desc.without)}|a${ids(desc.added)}|c${ids(desc.changed)}`;
+}
+class Query {
+  tables = [];
+  with;
+  without;
+  optional;
+  added;
+  changed;
+  withIds;
+  withoutIds;
+  constructor(desc) {
+    this.added = desc.added ?? [];
+    this.changed = desc.changed ?? [];
+    this.with = [.../* @__PURE__ */ new Set([...desc.with ?? [], ...this.added, ...this.changed])];
+    this.without = desc.without ?? [];
+    this.optional = desc.optional ?? [];
+    this.withIds = this.with.map((d) => d.id);
+    this.withoutIds = this.without.map((d) => d.id);
+  }
+  /** @internal Called by the world for every table, once. */
+  consider(table) {
+    for (const id of this.withIds) if (!table.hasId(id)) return;
+    for (const id of this.withoutIds) if (table.hasId(id)) return;
+    this.tables.push(table);
+  }
+  /** Whether a row passes the `added` / `changed` filters for a given `since` tick. */
+  passes(table, row, since) {
+    for (const def of this.added) if (!table.isAdded(def, row, since)) return false;
+    for (const def of this.changed) if (!table.isChanged(def, row, since)) return false;
+    return true;
+  }
+  /**
+   * Calls `fn` for each matching row. `since` is the tick for `added`/`changed` filters
+   * (a system passes `ctx.lastRunTick`). Don't make structural changes inside `fn`; use commands.
+   */
+  each(fn, since = 0) {
+    const filtered = this.added.length > 0 || this.changed.length > 0;
+    for (const table of this.tables) {
+      for (let row = 0; row < table.count; row++) {
+        if (filtered && !this.passes(table, row, since)) continue;
+        fn(table.entities[row], row, table);
+      }
+    }
+  }
+  count(since = 0) {
+    if (this.added.length === 0 && this.changed.length === 0) {
+      let n2 = 0;
+      for (const table of this.tables) n2 += table.count;
+      return n2;
+    }
+    let n = 0;
+    this.each(() => n++, since);
+    return n;
+  }
+  entities(since = 0) {
+    const out = [];
+    this.each((e) => out.push(e), since);
+    return out;
+  }
+}
+export {
+  Query,
+  queryKey
+};

package/dist/ecs/table.d.ts

@@ -0,0 +1,91 @@
+import type { ComponentDef } from '../schema/component.js';
+import type { Column, Fields, FieldType, InferFields, TypedArrayFor } from '../schema/field.js';
+import type { Entity } from './entity.js';
+/** Anything that knows the current change-detection tick (the world). */
+export interface TickSource {
+    readonly tick: number;
+}
+/** The column type for a field: a TypedArray for numeric storage, a JS array otherwise. */
+export type ColumnOf<T> = T extends FieldType<infer V, infer S> ? S extends 'object' ? (V | undefined)[] : TypedArrayFor<Exclude<S, 'object'>> : never;
+/** Storage for one component inside one table. */
+export declare class ComponentStorage {
+    readonly columns: Column[];
+    /** Columns by field name. Same arrays as `columns`. */
+    readonly byName: Record<string, Column>;
+    added: Uint32Array;
+    changed: Uint32Array;
+    /** The newest tick in `changed`, so a system can skip a table where nothing changed. */
+    lastChanged: number;
+    def: ComponentDef;
+    constructor(def: ComponentDef, capacity: number);
+    grow(capacity: number): void;
+    private reindex;
+}
+/**
+ * All entities that have exactly one set of components (an archetype), stored as columns.
+ *
+ * Column arrays are replaced when the table grows, so fetch them each frame rather than
+ * holding on to them.
+ */
+export declare class Table {
+    count: number;
+    capacity: number;
+    entities: Float64Array;
+    /** Component ids in this archetype, sorted. */
+    readonly ids: readonly number[];
+    readonly storages: readonly ComponentStorage[];
+    /** Cached archetype transitions: component id → table with it added / removed. */
+    readonly addEdges: Map<number, Table>;
+    readonly removeEdges: Map<number, Table>;
+    private readonly idSet;
+    private readonly byId;
+    readonly id: number;
+    /**
+     * The tick a row last moved in or out. Rows that move in keep their change ticks, so "nothing
+     * changed" needs this too.
+     */
+    lastStructural: number;
+    readonly components: readonly ComponentDef[];
+    private readonly clock;
+    constructor(id: number, components: readonly ComponentDef[], clock: TickSource, capacity?: number);
+    has(def: ComponentDef): boolean;
+    hasId(id: number): boolean;
+    storage(def: ComponentDef): ComponentStorage | undefined;
+    /**
+     * The raw column for one field. Numeric fields are TypedArrays with `stride` values per row
+     * (a vec3 at row `i` is at `[i * 3]`, `[i * 3 + 1]`, `[i * 3 + 2]`).
+     */
+    column<F extends Fields, K extends keyof F & string>(def: ComponentDef<F>, field: K): ColumnOf<F[K]>;
+    addedTicks(def: ComponentDef): Uint32Array;
+    changedTicks(def: ComponentDef): Uint32Array;
+    /** Marks one row, or every row, as changed at the current tick. */
+    markChanged(def: ComponentDef, row?: number): void;
+    /**
+     * The newest change tick of any row of `def`: when it's not after `since`, no row changed. Code
+     * that writes `changedTicks()` directly must call `touch` too.
+     */
+    lastChanged(def: ComponentDef): number;
+    /** Records that rows of `def` changed this tick, after writing `changedTicks()` directly. */
+    touch(def: ComponentDef): void;
+    isAdded(def: ComponentDef, row: number, since: number): boolean;
+    isChanged(def: ComponentDef, row: number, since: number): boolean;
+    pushRow(entity: Entity): number;
+    /** Swap-removes a row. Returns the entity moved into `row`, or -1 if it was the last row. */
+    removeRow(row: number): Entity;
+    /** Copies the components both tables share from `row` here into `targetRow` there. */
+    copySharedTo(row: number, target: Table, targetRow: number): void;
+    /** Writes a full component value; fields missing from `init` take their defaults. */
+    initComponent(def: ComponentDef, row: number, init: Record<string, unknown> | undefined): void;
+    /** Writes only the fields present in `values`. */
+    writeComponent(def: ComponentDef, row: number, values: Record<string, unknown>): void;
+    readComponent<F extends Fields>(def: ComponentDef<F>, row: number): InferFields<F>;
+    /**
+     * Replaces a component's definition with one sharing its id (hot reload). Without `migrate`
+     * the layout must be the same and only the definition changes; with it, every row's value is
+     * rebuilt into new columns. Added ticks carry over; changed ticks become the current tick.
+     */
+    redefine(def: ComponentDef, migrate?: (value: Record<string, unknown>, row: number) => Record<string, unknown>): void;
+    /** Approximate bytes used by TypedArray columns (object columns count as 8 bytes a slot). */
+    bytes(): number;
+    private grow;
+}