@vworlds/vecs 1.0.9 → 1.0.11

package/dist/system.d.ts

@@ -1,18 +1,15 @@
-import { ArrayMap } from "./util/array_map.js";
-import { Bitset } from "./util/bitset.js";
 import { Component } from "./component.js";
 import { Query } from "./query.js";
 import { type QueryDSL, type MaybeRequired } from "./dsl.js";
 import type { Entity } from "./entity.js";
-import { Phase, type IPhase } from "./phase.js";
+import { type IPhase } from "./phase.js";
 import { type World } from "./world.js";
 export type { QueryDSL as SystemQuery, EntityTestFunc } from "./dsl.js";
-type ComponentCallback = (c: Component) => void;
 type RunCallback = (now: number, delta: number) => void;
 /**
- * A reactive processor that operates on a filtered subset of world entities.
+ * A reactive processor running over a filtered subset of world entities.
  *
- * Systems are created and registered through {@link World.system}:
+ * Systems are created and configured through {@link World.system}:
  *
  * ```ts
  * world.system("Move")
@@ -23,127 +20,77 @@ type RunCallback = (now: number, delta: number) => void;
  *   .exit((e) => { console.log("entity left", e.eid); });
  * ```
  *
- * All builder methods return `this` for chaining. Call {@link World.start}
- * once all systems are registered; after that, drive the loop with
- * {@link World.runPhase}.
+ * Every builder method returns `this` for chaining. After registering systems
+ * call {@link World.start} once, then drive the loop with
+ * {@link World.runPhase} or {@link World.progress}.
+ *
+ * Internally each system holds a single ordered **inbox** of routed events
+ * (`enter`, `exit`, `update`). The world appends to it during command-queue
+ * routing; the system replays the inbox at the top of every `_run` so
+ * callbacks observe events in arrival order.
  *
  * ### Component injection and type inference
  *
- * `enter`, `exit`, `update`, `each`, and `sort` all accept an array of
- * component classes that are resolved from the entity and passed as a typed
- * tuple to the callback. Use `{ parent: SomeComponent }` to resolve from the
- * entity's parent instead of the entity itself.
+ * `enter`, `exit`, `update`, `each`, and `sort` accept an array of component
+ * classes resolved from the entity and passed as a typed tuple to the
+ * callback. Use `{ parent: SomeComponent }` to resolve from the entity's
+ * parent instead of the entity itself.
+ *
+ * Components declared via {@link requires} (or the `_guaranteed` argument of
+ * {@link query}) are tracked as the type parameter `R`. Inside `sort`,
+ * `each`, and `update` injection callbacks they are non-nullable; any other
+ * component remains `Type | undefined`.
  *
- * Components declared via {@link requires} (or the second argument of
- * {@link query}) are tracked as a type parameter `R` on the system. In
- * `sort`, `each`, and `update` inject callbacks, those components appear as
- * non-nullable; any component not in `R` remains `Type | undefined`.
+ * @typeParam R - Component classes guaranteed present on every matched entity.
  */
 export declare class System<R extends (typeof Component)[] = []> extends Query<R> {
-    protected componentUpdateCallbacks: ArrayMap<ComponentCallback>;
-    protected eachCallback: ((e: Entity) => void) | undefined;
-    private _runCallback;
-    private readonly updateQueue;
-    /** @internal */
-    _phase: string | Phase | undefined;
-    protected watchlistBitmask: Bitset;
     constructor(name: string, world: World);
     /**
      * Assign this system to a pipeline phase.
      *
-     * The phase can be specified by name (the world will resolve it at
-     * {@link World.start | start} time) or by an {@link IPhase} reference
-     * returned from {@link World.addPhase}. Systems without an explicit phase
-     * are placed in the built-in `"update"` phase.
+     * Pass either a phase name (resolved at {@link World.start}) or an
+     * {@link IPhase} reference returned from {@link World.addPhase}. Systems
+     * with no explicit phase fall into the built-in `"update"` phase.
      *
      * @param p - Phase name or `IPhase` reference.
-     * @returns `this` for chaining.
+     * @returns This system, for chaining.
+     * @throws When the phase reference is not a `Phase`, or belongs to a
+     *   different world.
      */
     phase(p: string | IPhase): this;
-    /** @internal Delivers a component-modified notification to this system. */
-    notifyModified(c: Component): void;
-    /** @internal Fires enter callbacks, adds entity to tracked set, queues component updates. */
-    _enter(e: Entity): void;
-    /** @internal Fires exit callbacks, removes entity from tracked set, drains update queue. */
-    _exit(e: Entity): void;
-    /** @internal Execute one tick: run `run`, fire `each`, then drain the update queue. */
-    _run(now: number, delta: number): void;
     /**
-     * Register a per-tick callback that runs every time this system's phase
-     * executes, regardless of entity membership.
+     * Register a per-tick callback fired every time this system's phase runs,
+     * regardless of entity membership.
      *
-     * Use this for logic that is not driven by component updates — polling,
+     * Use it for logic that is not driven by component changes — polling,
      * network flushing, global timers, etc.
      *
      * @param callback - Receives `now` (absolute timestamp in ms) and `delta`
-     *   (ms since the last tick).
-     * @returns `this` for chaining.
+     *   (ms since the previous tick).
+     * @returns This system, for chaining.
      */
     run(callback: RunCallback): this;
     /**
-     * Register a callback that fires when a component of type `ComponentClass`
-     * is modified on any entity in this system.
-     *
-     * The system will automatically begin tracking entities that have this
-     * component type (equivalent to adding it to a `requires` / `HAS` query)
-     * unless a custom {@link query} was already set.
-     *
-     * @param ComponentClass - The component class to watch.
-     * @param callback - Receives the modified component instance.
-     * @returns `this` for chaining.
-     *
-     * @example
-     * ```ts
-     * world.system("RenderPosition")
-     *   .update(Position, (pos) => {
-     *     sprite.setPosition(pos.x, pos.y);
-     *   });
-     * ```
-     */
-    update<C extends typeof Component>(ComponentClass: C, callback: (c: InstanceType<C>) => void): this;
-    /**
-     * Register a callback that fires when `ComponentClass` is modified, with
-     * additional components injected from the same entity.
-     *
-     * @param ComponentClass - The component class to watch.
-     * @param inject - Additional component classes to resolve from the entity.
-     * @param callback - Receives the modified component and the injected tuple.
-     * @returns `this` for chaining.
-     *
-     * @example
-     * ```ts
-     * world.system("SyncSprite")
-     *   .update(Position, [Sprite], (pos, [sprite]) => {
-     *     sprite.sprite.setPosition(pos.x, pos.y);
-     *   });
-     * ```
-     */
-    update<C extends typeof Component, J extends (typeof Component)[]>(ComponentClass: C, inject: readonly [...J], callback: (c: InstanceType<C>, injected: {
-        [K in keyof J]: MaybeRequired<J[K], R>;
-    }) => void): this;
-    /**
-     * Register a callback that fires **every tick** for every entity currently
-     * tracked by this system, with the listed components resolved from each
-     * entity.
+     * Register a callback fired **every tick** for **every tracked entity**,
+     * unconditionally, with the listed components resolved from each entity.
      *
      * Unlike {@link update} (which only fires when `component.modified()` is
-     * called), `each` fires unconditionally on every tick the system runs,
-     * once per tracked entity. Components declared via {@link requires} are
-     * guaranteed non-null in the resolved tuple; any other component class
-     * may be `undefined` if the entity lacks it.
+     * called), `each` fires every tick the system runs, once per tracked entity.
+     * Components declared via {@link requires} are non-nullable in the resolved
+     * tuple; any other component class may be `undefined` if the entity lacks it.
      *
      * `each` does **not** modify the system's query — define membership with
      * {@link requires} or {@link query} as usual. It does, however, implicitly
      * enable {@link track}, so matched entities are exposed via {@link entities}.
      *
-     * Only a single `each` callback may be registered per system; calling
-     * `each` a second time throws.
+     * Only one `each` callback may be registered per system; calling `each` a
+     * second time throws.
      *
      * @param components - Component classes to resolve from each entity.
      * @param callback - Receives the entity and a tuple of resolved component
-     *   instances (`undefined` for components not covered by {@link requires}).
-     * @returns `this` for chaining.
-     * @throws If `each` has already been registered on this system.
+     *   instances (`undefined` for any not covered by {@link requires}).
+     * @returns This system, for chaining.
+     * @throws When `each` has already been registered on this system.
      *
      * @example
      * ```ts
@@ -159,50 +106,39 @@ export declare class System<R extends (typeof Component)[] = []> extends Query<R
         [K in keyof J]: MaybeRequired<J[K], R>;
     }) => void): this;
     /**
-     * Not supported on `System`. Throws unconditionally.
-     *
-     * Systems are owned by the world for the duration of the session. If you
-     * need a temporary reactive set, use a standalone {@link Query} instead.
-     */
-    destroy(): never;
-    /**
-     * Set the entity membership predicate using the {@link QueryDSL} DSL.
+     * Set the entity-membership predicate using a {@link QueryDSL} expression.
      *
      * Replaces any implicit query derived from `update` watchlists and any
-     * previous `requires` call. After calling `query`, auto-expanding of
-     * `update` watchlists is disabled.
+     * previous `requires` call. After calling `query`, watchlist auto-expansion
+     * via `update` is disabled.
      *
-     * The optional `guaranteed` tuple is a pure type-level hint: it tells
-     * `sort`, `each`, and `update` callbacks which components are guaranteed
-     * to be present on every matched entity, eliminating `| undefined` from
-     * those positions. It has no effect at runtime.
+     * The optional `_guaranteed` tuple is a pure type-level hint — see
+     * {@link Query.query} for details.
      *
-     * @param q - A {@link QueryDSL} expression.
+     * @param q - Query expression.
      * @param _guaranteed - Component classes guaranteed present on every matched
      *   entity (type hint only — not validated at runtime).
-     * @returns `this` for chaining.
-     *
-     * @example
-     * ```ts
-     * world.system("Move")
-     *   .query({ AND: [{ HAS: Position }, { HAS: Velocity }] }, [Position, Velocity])
-     *   .each([Position, Velocity], (e, [pos, vel]) => {
-     *     pos.x += vel.vx;  // no ! needed
-     *   });
-     * ```
+     * @returns This system, retyped with the guaranteed tuple as its `R`.
      */
     query<T extends (typeof Component)[] = []>(q: QueryDSL, _guaranteed?: readonly [...T]): System<T>;
     /**
-     * Shorthand for `query([...components])` — the system tracks entities that
-     * have **all** of the listed component types.
+     * Shorthand for `query([...components])` — tracks entities that have **all**
+     * of the listed component types.
      *
-     * Equivalent to `query({ HAS: components })`. Unlike `query`, passing
-     * component classes here also informs the types of {@link sort} and
-     * {@link each} callbacks: listed components will be non-nullable in those
-     * tuples.
+     * Equivalent to `query({ HAS: components })`. The listed components are also
+     * recorded in the type parameter `R`, so {@link sort}, {@link each}, and
+     * {@link update} callbacks treat them as non-nullable.
      *
-     * @param components - One or more component classes.
-     * @returns `this` for chaining.
+     * @param components - Component classes to require.
+     * @returns This system, retyped with the required tuple as its `R`.
      */
     requires<T extends (typeof Component)[]>(...components: [...T]): System<T>;
+    /**
+     * Not supported on `System`. Throws unconditionally.
+     *
+     * Systems are owned by the world for the duration of the session; if you
+     * need a temporary reactive set use a standalone {@link Query} via
+     * {@link World.query}.
+     */
+    destroy(): never;
 }

package/dist/system.js

@@ -1,12 +1,9 @@
-import { ArrayMap } from "./util/array_map.js";
-import { Bitset } from "./util/bitset.js";
 import { Query } from "./query.js";
-import { HAS } from "./dsl.js";
 import { Phase } from "./phase.js";
 /**
- * A reactive processor that operates on a filtered subset of world entities.
+ * A reactive processor running over a filtered subset of world entities.
  *
- * Systems are created and registered through {@link World.system}:
+ * Systems are created and configured through {@link World.system}:
  *
  * ```ts
  * world.system("Move")
@@ -17,39 +14,133 @@ import { Phase } from "./phase.js";
  *   .exit((e) => { console.log("entity left", e.eid); });
  * ```
  *
- * All builder methods return `this` for chaining. Call {@link World.start}
- * once all systems are registered; after that, drive the loop with
- * {@link World.runPhase}.
+ * Every builder method returns `this` for chaining. After registering systems
+ * call {@link World.start} once, then drive the loop with
+ * {@link World.runPhase} or {@link World.progress}.
+ *
+ * Internally each system holds a single ordered **inbox** of routed events
+ * (`enter`, `exit`, `update`). The world appends to it during command-queue
+ * routing; the system replays the inbox at the top of every `_run` so
+ * callbacks observe events in arrival order.
  *
  * ### Component injection and type inference
  *
- * `enter`, `exit`, `update`, `each`, and `sort` all accept an array of
- * component classes that are resolved from the entity and passed as a typed
- * tuple to the callback. Use `{ parent: SomeComponent }` to resolve from the
- * entity's parent instead of the entity itself.
+ * `enter`, `exit`, `update`, `each`, and `sort` accept an array of component
+ * classes resolved from the entity and passed as a typed tuple to the
+ * callback. Use `{ parent: SomeComponent }` to resolve from the entity's
+ * parent instead of the entity itself.
+ *
+ * Components declared via {@link requires} (or the `_guaranteed` argument of
+ * {@link query}) are tracked as the type parameter `R`. Inside `sort`,
+ * `each`, and `update` injection callbacks they are non-nullable; any other
+ * component remains `Type | undefined`.
  *
- * Components declared via {@link requires} (or the second argument of
- * {@link query}) are tracked as a type parameter `R` on the system. In
- * `sort`, `each`, and `update` inject callbacks, those components appear as
- * non-nullable; any component not in `R` remains `Type | undefined`.
+ * @typeParam R - Component classes guaranteed present on every matched entity.
  */
 export class System extends Query {
     constructor(name, world) {
         super(name, world, false);
-        this.componentUpdateCallbacks = new ArrayMap();
-        this.updateQueue = [];
-        this.watchlistBitmask = new Bitset();
+        /** @internal Single inbox replayed in arrival order on every `_run`. */
+        this._inbox = [];
+    }
+    /**
+     * @internal Routing entry: register query membership for `e`, push an
+     * inbox `enter` event when an `enter` callback is registered, and bridge
+     * watched components through {@link _notifyModified} to surface them as
+     * inbox `update` events on entry.
+     */
+    _enter(e) {
+        this._entities?.add(e);
+        e._addQueryMembership(this);
+        if (this._enterCallback !== undefined) {
+            this._inbox.push({ kind: 0 /* InboxCommand.Enter */, entity: e });
+        }
+        e.components.forEach((c) => {
+            if (this._watchlistBitmask.hasBit(c.bitPtr)) {
+                this._notifyModified(c);
+            }
+        });
+    }
+    /**
+     * @internal Routing entry: deregister query membership for `e` and push an
+     * inbox `exit` event when an `exit` callback is registered, capturing a
+     * snapshot of the components the callback wants to inject so they remain
+     * resolvable after the underlying components are removed.
+     */
+    _exit(e) {
+        this._entities?.delete(e);
+        e._removeQueryMembership(this);
+        if (this._exitCallback !== undefined) {
+            let snapshot;
+            if (this._exitSnapshotTypes && this._exitSnapshotTypes.length > 0) {
+                snapshot = new Map();
+                for (const type of this._exitSnapshotTypes) {
+                    const c = e._get(type);
+                    if (c) {
+                        snapshot.set(type, c);
+                    }
+                }
+            }
+            this._inbox.push({ kind: 1 /* InboxCommand.Exit */, entity: e, snapshot });
+        }
+    }
+    /**
+     * @internal Routing entry: push an inbox `update` event when the modified
+     * component matches the watchlist.
+     */
+    _notifyModified(c) {
+        if (!this._watchlistBitmask.hasBit(c.bitPtr)) {
+            return;
+        }
+        this._inbox.push({ kind: 2 /* InboxCommand.Update */, component: c });
+    }
+    /**
+     * @internal Execute one tick: drain the inbox in arrival order, then run
+     * the `run` callback, then the `each` callback for every tracked entity.
+     *
+     * The whole body executes inside a `World.defer` scope; mutations made by
+     * callbacks land in the world queue and are processed when `_run` returns.
+     */
+    _run(now, delta) {
+        this.world.defer(() => {
+            for (let i = 0; i < this._inbox.length; i++) {
+                const event = this._inbox[i];
+                switch (event.kind) {
+                    case 0 /* InboxCommand.Enter */:
+                        this._enterCallback(event.entity);
+                        break;
+                    case 1 /* InboxCommand.Exit */:
+                        this._exitCallback(event.entity, event.snapshot);
+                        break;
+                    case 2 /* InboxCommand.Update */:
+                        const callback = this._componentUpdateCallbacks.get(event.component.type);
+                        if (callback) {
+                            callback(event.component);
+                        }
+                        break;
+                }
+            }
+            this._inbox.length = 0;
+            if (this._runCallback) {
+                this._runCallback(now, delta);
+            }
+            if (this._eachCallback) {
+                const cb = this._eachCallback;
+                this.forEach((e) => cb(e));
+            }
+        });
     }
     /**
      * Assign this system to a pipeline phase.
      *
-     * The phase can be specified by name (the world will resolve it at
-     * {@link World.start | start} time) or by an {@link IPhase} reference
-     * returned from {@link World.addPhase}. Systems without an explicit phase
-     * are placed in the built-in `"update"` phase.
+     * Pass either a phase name (resolved at {@link World.start}) or an
+     * {@link IPhase} reference returned from {@link World.addPhase}. Systems
+     * with no explicit phase fall into the built-in `"update"` phase.
      *
      * @param p - Phase name or `IPhase` reference.
-     * @returns `this` for chaining.
+     * @returns This system, for chaining.
+     * @throws When the phase reference is not a `Phase`, or belongs to a
+     *   different world.
      */
     phase(p) {
         if (typeof p !== "string") {
@@ -63,115 +154,42 @@ export class System extends Query {
         this._phase = p;
         return this;
     }
-    /** @internal Delivers a component-modified notification to this system. */
-    notifyModified(c) {
-        if (!this.watchlistBitmask.hasBit(c.bitPtr)) {
-            return;
-        }
-        this.updateQueue.push(c);
-    }
-    /** @internal Fires enter callbacks, adds entity to tracked set, queues component updates. */
-    _enter(e) {
-        super._enter(e);
-        e.forEachComponent((c) => this.notifyModified(c));
-    }
-    /** @internal Fires exit callbacks, removes entity from tracked set, drains update queue. */
-    _exit(e) {
-        super._exit(e);
-        this.updateQueue.forEach((c, i) => {
-            if (!c) {
-                return;
-            }
-            if (c.entity === e) {
-                this.updateQueue[i] = undefined;
-            }
-        });
-    }
-    /** @internal Execute one tick: run `run`, fire `each`, then drain the update queue. */
-    _run(now, delta) {
-        if (this._runCallback) {
-            this._runCallback(now, delta);
-        }
-        if (this.eachCallback) {
-            const cb = this.eachCallback;
-            this.forEach((e) => cb(e));
-        }
-        this.updateQueue.forEach((c) => {
-            if (!c) {
-                return;
-            }
-            const callback = this.componentUpdateCallbacks.get(c.type);
-            if (callback) {
-                callback(c);
-            }
-        });
-        this.updateQueue.length = 0;
-    }
     /**
-     * Register a per-tick callback that runs every time this system's phase
-     * executes, regardless of entity membership.
+     * Register a per-tick callback fired every time this system's phase runs,
+     * regardless of entity membership.
      *
-     * Use this for logic that is not driven by component updates — polling,
+     * Use it for logic that is not driven by component changes — polling,
      * network flushing, global timers, etc.
      *
      * @param callback - Receives `now` (absolute timestamp in ms) and `delta`
-     *   (ms since the last tick).
-     * @returns `this` for chaining.
+     *   (ms since the previous tick).
+     * @returns This system, for chaining.
      */
     run(callback) {
         this._runCallback = callback;
         return this;
     }
-    update(ComponentClass, injectOrCallback, callback) {
-        const type = this.world.getComponentType(ComponentClass);
-        if (typeof injectOrCallback === "function") {
-            callback = injectOrCallback;
-            this.componentUpdateCallbacks.set(type, callback);
-        }
-        else {
-            const inject = injectOrCallback;
-            const injectedComponentTypes = inject.map((C) => this.world.getComponentType(C));
-            const cb = (c) => {
-                const injected = [];
-                injectedComponentTypes.forEach((InjectedComponentType) => {
-                    injected.push(c.entity.get(InjectedComponentType));
-                });
-                if (callback) {
-                    callback(c, injected);
-                }
-            };
-            this.componentUpdateCallbacks.set(type, cb);
-        }
-        this.watchlistBitmask.add(type);
-        if (!this.hasQuery) {
-            const watchlist = this.watchlistBitmask.indices();
-            this._belongs = HAS(this.world, ...watchlist);
-        }
-        return this;
-    }
     /**
-     * Register a callback that fires **every tick** for every entity currently
-     * tracked by this system, with the listed components resolved from each
-     * entity.
+     * Register a callback fired **every tick** for **every tracked entity**,
+     * unconditionally, with the listed components resolved from each entity.
      *
      * Unlike {@link update} (which only fires when `component.modified()` is
-     * called), `each` fires unconditionally on every tick the system runs,
-     * once per tracked entity. Components declared via {@link requires} are
-     * guaranteed non-null in the resolved tuple; any other component class
-     * may be `undefined` if the entity lacks it.
+     * called), `each` fires every tick the system runs, once per tracked entity.
+     * Components declared via {@link requires} are non-nullable in the resolved
+     * tuple; any other component class may be `undefined` if the entity lacks it.
      *
      * `each` does **not** modify the system's query — define membership with
      * {@link requires} or {@link query} as usual. It does, however, implicitly
      * enable {@link track}, so matched entities are exposed via {@link entities}.
      *
-     * Only a single `each` callback may be registered per system; calling
-     * `each` a second time throws.
+     * Only one `each` callback may be registered per system; calling `each` a
+     * second time throws.
      *
      * @param components - Component classes to resolve from each entity.
      * @param callback - Receives the entity and a tuple of resolved component
-     *   instances (`undefined` for components not covered by {@link requires}).
-     * @returns `this` for chaining.
-     * @throws If `each` has already been registered on this system.
+     *   instances (`undefined` for any not covered by {@link requires}).
+     * @returns This system, for chaining.
+     * @throws When `each` has already been registered on this system.
      *
      * @example
      * ```ts
@@ -184,71 +202,60 @@ export class System extends Query {
      * ```
      */
     each(components, callback) {
-        if (this.eachCallback) {
+        if (this._eachCallback) {
             throw `each already registered for system '${this.name}'`;
         }
         this.track();
         const types = components.map((C) => this.world.getComponentType(C));
-        this.eachCallback = (e) => {
+        this._eachCallback = (e) => {
             const resolved = types.map((t) => e.get(t));
             callback(e, resolved);
         };
         return this;
     }
     /**
-     * Not supported on `System`. Throws unconditionally.
-     *
-     * Systems are owned by the world for the duration of the session. If you
-     * need a temporary reactive set, use a standalone {@link Query} instead.
-     */
-    destroy() {
-        throw `destroy() is not supported on System '${this.name}'`;
-    }
-    /**
-     * Set the entity membership predicate using the {@link QueryDSL} DSL.
+     * Set the entity-membership predicate using a {@link QueryDSL} expression.
      *
      * Replaces any implicit query derived from `update` watchlists and any
-     * previous `requires` call. After calling `query`, auto-expanding of
-     * `update` watchlists is disabled.
+     * previous `requires` call. After calling `query`, watchlist auto-expansion
+     * via `update` is disabled.
      *
-     * The optional `guaranteed` tuple is a pure type-level hint: it tells
-     * `sort`, `each`, and `update` callbacks which components are guaranteed
-     * to be present on every matched entity, eliminating `| undefined` from
-     * those positions. It has no effect at runtime.
+     * The optional `_guaranteed` tuple is a pure type-level hint — see
+     * {@link Query.query} for details.
      *
-     * @param q - A {@link QueryDSL} expression.
+     * @param q - Query expression.
      * @param _guaranteed - Component classes guaranteed present on every matched
      *   entity (type hint only — not validated at runtime).
-     * @returns `this` for chaining.
-     *
-     * @example
-     * ```ts
-     * world.system("Move")
-     *   .query({ AND: [{ HAS: Position }, { HAS: Velocity }] }, [Position, Velocity])
-     *   .each([Position, Velocity], (e, [pos, vel]) => {
-     *     pos.x += vel.vx;  // no ! needed
-     *   });
-     * ```
+     * @returns This system, retyped with the guaranteed tuple as its `R`.
      */
     query(q, _guaranteed) {
         super.query(q, _guaranteed);
         return this;
     }
     /**
-     * Shorthand for `query([...components])` — the system tracks entities that
-     * have **all** of the listed component types.
+     * Shorthand for `query([...components])` — tracks entities that have **all**
+     * of the listed component types.
      *
-     * Equivalent to `query({ HAS: components })`. Unlike `query`, passing
-     * component classes here also informs the types of {@link sort} and
-     * {@link each} callbacks: listed components will be non-nullable in those
-     * tuples.
+     * Equivalent to `query({ HAS: components })`. The listed components are also
+     * recorded in the type parameter `R`, so {@link sort}, {@link each}, and
+     * {@link update} callbacks treat them as non-nullable.
      *
-     * @param components - One or more component classes.
-     * @returns `this` for chaining.
+     * @param components - Component classes to require.
+     * @returns This system, retyped with the required tuple as its `R`.
      */
     requires(...components) {
         super.requires(...components);
         return this;
     }
+    /**
+     * Not supported on `System`. Throws unconditionally.
+     *
+     * Systems are owned by the world for the duration of the session; if you
+     * need a temporary reactive set use a standalone {@link Query} via
+     * {@link World.query}.
+     */
+    destroy() {
+        throw `destroy() is not supported on System '${this.name}'`;
+    }
 }
 //# sourceMappingURL=system.js.map