murow 0.0.60 → 0.0.71

package/dist/{core → types/core}/events/event-system.d.ts

@@ -10,62 +10,43 @@ interface EventSystemProps<EventNames extends string> {
     events: EventNames[];
 }
 /**
- * @description
- * A callback-based event handling system designed to simplify
- * event-driven programming.
+ * Zero-allocation event system. Uses flat arrays instead of Map/Set
+ * to avoid iterator allocations on every emit().
  */
 export declare class EventSystem<EventTuple extends [string, unknown][]> {
-    /**
-     * @private
-     * @description
-     * The map of registered events and their callbacks.
-    */
-    private callbacks;
-    /**
-     * @private
-     * @description
-     * The list of events that were registered.
-    */
+    private eventIndex;
+    private callbackArrays;
+    private callbackCounts;
     private events;
+    private emitting;
     constructor({ events }: EventSystemProps<string>);
     /**
-     * @description
      * Registers a callback for an event.
-     *
-     * @param name Event name
-     * @param callback Callback to run when the event is emitted
      */
     on<EventName extends keyof EventMapFromTuple<EventTuple> & string>(name: EventName, callback: Callback<EventMapFromTuple<EventTuple>[EventName]>): void;
     /**
-     * @description
      * Registers a callback for an event that runs only once.
-     *
-     * @param name Event name
-     * @param callback Callback to run when the event is emitted
      */
     once<EventName extends keyof EventMapFromTuple<EventTuple> & string>(name: EventName, callback: Callback<EventMapFromTuple<EventTuple>[EventName]>): void;
     /**
-     * @description
      * Emits an event, running all registered callbacks.
-     *
-     * @param name Event name
-     * @param data Event data
+     * Zero allocations — iterates a flat array with an index loop.
+     * Safe to call off() during emit (nulled slots are skipped).
      */
     emit<EventName extends keyof EventMapFromTuple<EventTuple> & string>(name: EventName, data: EventMapFromTuple<EventTuple>[EventName]): void;
     /**
-     * @description
      * Removes a callback from an event.
-     *
-     * @param name Event name
-     * @param callback Callback to remove
+     * During emit: nulls the slot (compacted after emit finishes).
+     * Outside emit: swap-and-pop for O(1).
      */
     off<EventName extends keyof EventMapFromTuple<EventTuple> & string>(name: EventName, callback: Callback<EventMapFromTuple<EventTuple>[EventName]>): void;
     /**
-     * @description
      * Removes all callbacks.
-     *
-     * @param name Optional event name
      */
     clear<EventName extends keyof EventMapFromTuple<EventTuple> & string>(name?: EventName): void;
+    /**
+     * Remove null gaps left by off() during emit.
+     */
+    private compact;
 }
 export {};

package/dist/{core → types/core}/fixed-ticker/fixed-ticker.d.ts

@@ -14,7 +14,7 @@
  */
 export declare class FixedTicker {
     /**
-     * @description Accumulator for the time passed since the last tick
+     * @description Accumulator for the time passed since the last tick (in milliseconds)
      */
     private accumulator;
     /**

package/dist/types/core/free-list/free-list.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Free list allocator. Zero-GC, O(1) alloc/free.
+ */
+export declare class FreeList {
+    private freeList;
+    private freeCount;
+    private capacity;
+    constructor(capacity: number);
+    /**
+     * Allocate an index from the pool.
+     * @returns Available index, or -1 if exhausted
+     */
+    allocate(): number;
+    /**
+     * Return an index to the pool for reuse.
+     * @param index Index to free
+     */
+    free(index: number): void;
+    /**
+     * Check if an index can be allocated.
+     */
+    hasAvailable(): boolean;
+    /**
+     * Get number of available slots.
+     */
+    getAvailableCount(): number;
+    /**
+     * Get number of allocated slots.
+     */
+    getAllocatedCount(): number;
+}

package/dist/types/core/free-list/index.d.ts

@@ -0,0 +1 @@
+export * from "./free-list";

package/dist/{core → types/core}/index.d.ts

@@ -3,7 +3,13 @@ export * from './events';
 export * from './fixed-ticker';
 export * from './generate-id';
 export * from './lerp';
-export * from './loop';
+export * from './driver';
 export * from './navmesh';
 export * from './pooled-codec';
 export * from './prediction';
+export * from './input';
+export * from './free-list';
+export * from './sparse-batcher';
+export * from './simple-rng';
+export * from './ray';
+export * from '../renderer';

package/dist/types/core/input/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./manager";
+export * from "./sources";
+export type { InputSnapshot } from "./types";

package/dist/types/core/input/manager.d.ts

@@ -0,0 +1,56 @@
+import type { InputEventSource, InputSnapshot } from "./types";
+/**
+ * Manages keyboard and mouse input.
+ *
+ * Design goals:
+ * - Zero allocations per frame/tick
+ * - Render reads live state (peek)
+ * - Simulation reads frozen state (snapshot)
+* - Deterministic hit/release semantics
+*/
+export declare class InputManager {
+    private keys;
+    private prevKeys;
+    private mouse;
+    private lastClientX;
+    private lastClientY;
+    private prevMouse;
+    private snapshotA;
+    private snapshotB;
+    private snapshotFlip;
+    private inputSource;
+    private handlers;
+    constructor();
+    /**
+     * Returns a live, non-allocating view of the current input state.
+     *
+     * - No hit/release detection
+     * - No resets
+     * - Safe for render passes
+     */
+    peek(): Readonly<InputSnapshot>;
+    /**
+     * Produces a frozen snapshot of the input state.
+     *
+     * - Computes hit/release
+     * - Resets deltas
+     * - Safe to store for the duration of the tick
+     */
+    snapshot(): InputSnapshot;
+    /**
+     * Starts listening to an input event source
+     */
+    listen(source: InputEventSource): void;
+    /**
+     * Stops listening to the current input source.
+     */
+    unlisten(): void;
+    private onKeyDown;
+    private onKeyUp;
+    private onMouseMove;
+    private onMouseDown;
+    private onMouseUp;
+    private onMouseWheel;
+    private onSwipe;
+    private onPinch;
+}

package/dist/types/core/input/sources/browser.d.ts

@@ -0,0 +1,9 @@
+import { InputHandlers, InputEventSource } from "../types";
+export declare class BrowserInputSource implements InputEventSource {
+    private keyboardTarget;
+    private mouseTarget;
+    private handlers;
+    constructor(keyboardTarget: Document | Window, mouseTarget: HTMLElement);
+    attach(h: InputHandlers): void;
+    detach(): void;
+}

package/dist/types/core/input/sources/index.d.ts

@@ -0,0 +1 @@
+export * from "./browser";

package/dist/types/core/input/types.d.ts

@@ -0,0 +1,36 @@
+export type InputHandlers = {
+    keydown: (e: KeyboardEvent) => void;
+    keyup: (e: KeyboardEvent) => void;
+    mousemove: (e: MouseEvent) => void;
+    mousedown: (e: MouseEvent) => void;
+    mouseup: (e: MouseEvent) => void;
+    wheel: (e: WheelEvent) => void;
+    swipe: (direction: 'up' | 'down' | 'left' | 'right') => void;
+    pinch: (scale: number) => void;
+};
+export interface InputEventSource {
+    attach(handlers: InputHandlers): void;
+    detach(): void;
+}
+export type ButtonState = {
+    down: boolean;
+    hit: boolean;
+    released: boolean;
+};
+export type Vector2 = {
+    x: number;
+    y: number;
+};
+export type InputSnapshot = {
+    keys: Record<string, ButtonState>;
+    mouse: {
+        position: Vector2;
+        delta: {
+            position: Vector2;
+            scroll: Vector2;
+        };
+        left: ButtonState;
+        middle: ButtonState;
+        right: ButtonState;
+    };
+};

package/dist/{core → types/core}/navmesh/navmesh.d.ts

@@ -69,26 +69,6 @@ export interface PolygonObstacle extends BaseObstacle {
     pos: Vec2;
     rotation?: number;
 }
-/**
- * Manages obstacles with spatial hashing for fast queries.
- * Version tracking prevents unnecessary rebuilds.
- */
-declare class Obstacles {
-    private items;
-    private spatial;
-    private _cachedItems;
-    dirty: boolean;
-    version: number;
-    add(obstacle: ObstacleInput): ObstacleId;
-    move(id: ObstacleId, pos: Vec2): void;
-    remove(id: ObstacleId): void;
-    /**
-     * Fast spatial query using hash grid.
-     * O(1) average case instead of O(n) linear scan.
-     */
-    at(pos: Vec2): Obstacle | undefined;
-    get values(): Obstacle[];
-}
 type NavType = 'grid' | 'graph';
 /**
  * Navigation mesh with spatial hashing and smart rebuild.
@@ -132,7 +112,7 @@ export declare class NavMesh<TWorkers extends boolean | 'auto' = false> {
     private grid?;
     private graph?;
     private lastVersion;
-    obstacles: Obstacles;
+    private obstacles;
     private options;
     private workerPool?;
     private pendingPaths;

package/dist/types/core/ray/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ray-2d';
+export * from './ray-3d';

package/dist/types/core/ray/ray-2d.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Ray2D — a 2D ray defined by an origin and a normalized direction.
+ * Zero allocations per intersection test.
+ *
+ * All intersection methods return the parametric distance `t` along the ray
+ * to the first hit point, or `null` if there is no intersection.
+ * A hit point can be retrieved via `ray.at(t)`.
+ */
+export declare class Ray2D {
+    origin: [number, number];
+    direction: [number, number];
+    private _point;
+    /**
+     * Set origin and direction. Direction is normalized automatically.
+     */
+    set(ox: number, oy: number, dx: number, dy: number): void;
+    /**
+     * Returns the point at distance `t` along the ray.
+     * Reuses an internal buffer — copy if you need to store the result.
+     */
+    at(t: number): [number, number];
+    /**
+     * Intersection with a line segment from (ax, ay) to (bx, by).
+     * Returns `t` if the ray hits the segment, `null` otherwise.
+     */
+    intersectsSegment(ax: number, ay: number, bx: number, by: number): number | null;
+    /**
+     * Intersection with a circle at (cx, cy) with radius r.
+     * Returns `t` at the entry point (or exit if origin is inside), `null` if no hit.
+     */
+    intersectsCircle(cx: number, cy: number, r: number): number | null;
+    /**
+     * Intersection with an axis-aligned bounding box.
+     * Returns `t` at the entry point, `null` if no hit.
+     */
+    intersectsAABB(minX: number, minY: number, maxX: number, maxY: number): number | null;
+}

package/dist/types/core/ray/ray-3d.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Ray3D — a 3D ray defined by an origin and a normalized direction.
+ * Zero allocations per intersection test.
+ *
+ * All intersection methods return the parametric distance `t` along the ray
+ * to the first hit point, or `null` if there is no intersection.
+ * A hit point can be retrieved via `ray.at(t)`.
+ */
+export declare class Ray3D {
+    origin: [number, number, number];
+    direction: [number, number, number];
+    private _point;
+    /**
+     * Set origin and direction. Direction is normalized automatically.
+     */
+    set(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number): void;
+    /**
+     * Returns the point at distance `t` along the ray.
+     * Reuses an internal buffer — copy if you need to store the result.
+     */
+    at(t: number): [number, number, number];
+    /**
+     * Intersection with a plane defined by normal (nx, ny, nz) and offset d (n·x = d).
+     * Returns `t` at the hit point, `null` if the ray is parallel or hits behind the origin.
+     */
+    intersectsPlane(nx: number, ny: number, nz: number, d: number): number | null;
+    /**
+     * Intersection with a sphere at (cx, cy, cz) with radius r.
+     * Returns `t` at the entry point (or exit if origin is inside), `null` if no hit.
+     */
+    intersectsSphere(cx: number, cy: number, cz: number, r: number): number | null;
+    /**
+     * Intersection with an axis-aligned bounding box.
+     * Returns `t` at the entry point, `null` if no hit.
+     */
+    intersectsAABB(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): number | null;
+    /**
+     * Intersection with a triangle using the Möller–Trumbore algorithm.
+     * Returns `t` at the hit point, `null` if no hit.
+     */
+    intersectsTriangle(ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): number | null;
+}

package/dist/types/core/simple-rng/index.d.ts

@@ -0,0 +1 @@
+export * from "./simple-rng";

package/dist/types/core/simple-rng/simple-rng.d.ts

@@ -0,0 +1,36 @@
+/**
+ * SimpleRNG — deterministic, seedable, zero-allocation pseudo-random number generator.
+ * Uses a 32-bit LCG (Linear Congruential Generator).
+ *
+ * Ideal for gameplay logic that must be reproducible (multiplayer, replays),
+ * particle systems, procedural generation, and any hot path where
+ * Math.random() is too slow or non-deterministic.
+ */
+export declare class SimpleRNG {
+    private state;
+    constructor(seed?: number);
+    /**
+     * Returns a float in [0, 1).
+     */
+    rand(): number;
+    /**
+     * Returns a float in [min, max).
+     */
+    range(min: number, max: number): number;
+    /**
+     * Returns an integer in [min, max] (inclusive).
+     */
+    int(min: number, max: number): number;
+    /**
+     * Returns true with the given probability (0-1).
+     */
+    chance(probability: number): boolean;
+    /**
+     * Pick a random element from an array.
+     */
+    pick<T>(array: T[]): T;
+    /**
+     * Reset to a new seed.
+     */
+    seed(value: number): void;
+}

package/dist/types/core/sparse-batcher/index.d.ts

@@ -0,0 +1 @@
+export * from "./sparse-batcher";

package/dist/types/core/sparse-batcher/sparse-batcher.d.ts

@@ -0,0 +1,55 @@
+/**
+ * SparseBatcher — organizes sprite slots into [layer][sheet] buckets for draw calls.
+ * Only allocates buckets that are actually used. Most games use <10 buckets total.
+ *
+ * Memory (10k sprites, 3 layers × 4 sheets = 12 buckets):
+ *   buckets:       12 × 10,000 × 4 bytes = ~480 KB (lazy, only used buckets)
+ *   bucketSizes:   16384 × 4 bytes       = 64 KB
+ *   activeBuckets: 16384 × 2 bytes       = 32 KB
+ *   Total: ~576 KB base + buckets as needed
+ *
+ * MAX_SHEETS = 64 supports up to 64 unique model/spritesheet IDs per layer.
+ */
+export declare class SparseBatcher {
+    private static readonly MAX_LAYERS;
+    private static readonly MAX_SHEETS;
+    private static readonly MAX_BUCKETS;
+    private readonly BUCKET_INITIAL_SIZE;
+    private buckets;
+    private bucketSizes;
+    private activeBuckets;
+    private sortBuffer;
+    private activeCount;
+    private readonly capacity;
+    constructor(capacity: number);
+    /**
+     * Compute a flat key from layer + sheet.
+     */
+    private key;
+    /**
+     * Register a sprite slot into its (layer, sheet) bucket.
+     */
+    add(layer: number, sheetId: number, slot: number): void;
+    /**
+     * Remove a sprite slot from its (layer, sheet) bucket.
+     * Uses swap-and-pop for O(1) removal within the bucket.
+     */
+    remove(layer: number, sheetId: number, slot: number): void;
+    /**
+     * Iterate active buckets in layer order (back-to-front), zero allocations.
+     * Callback receives sheetId and a subarray view of instance indices.
+     */
+    each(cb: (sheetId: number, instances: Uint32Array, count: number) => void): void;
+    /**
+     * Get the number of active buckets.
+     */
+    getActiveCount(): number;
+    /**
+     * Get total sprite count across all buckets.
+     */
+    getTotalCount(): number;
+    /**
+     * Clear all buckets.
+     */
+    clear(): void;
+}

package/dist/{ecs → types/ecs}/system-builder.d.ts

@@ -4,6 +4,13 @@ import { World } from "./world";
  * Extract component data type from Component<T>
  */
 type InferComponentData<C> = C extends Component<infer T> ? T : never;
+/**
+ * Field descriptor for specialized proxy creation.
+ */
+type FieldDesc = {
+    prop: string;
+    array: any;
+};
 /**
  * Extract the alias (key) and fields from a field mapping object.
  * { transform2d: ['x', 'y'] } => { alias: 'transform2d', fields: ['x', 'y'] }
@@ -26,6 +33,7 @@ type ExtractFieldMapping<T> = T extends Record<string, readonly any[]> ? {
  */
 export type BuildEntityProxy<Components extends readonly Component<any>[], FieldMappings extends readonly any[]> = {
     eid: number;
+    despawn: () => void;
 } & {
     -readonly [Index in keyof FieldMappings as Index extends keyof Components ? Components[Index] extends Component<any> ? ExtractFieldMapping<FieldMappings[Index]>["fields"] extends readonly (keyof InferComponentData<Components[Index]>)[] ? ExtractFieldMapping<FieldMappings[Index]>["fields"][number] extends keyof InferComponentData<Components[Index]> ? `${ExtractFieldMapping<FieldMappings[Index]>["alias"] & string}_${ExtractFieldMapping<FieldMappings[Index]>["fields"][number] & string}` : never : never : never : never]: Index extends keyof Components ? Components[Index] extends Component<any> ? ExtractFieldMapping<FieldMappings[Index]>["fields"] extends readonly (keyof InferComponentData<Components[Index]>)[] ? ExtractFieldMapping<FieldMappings[Index]>["fields"][number] extends keyof InferComponentData<Components[Index]> ? InferComponentData<Components[Index]>[ExtractFieldMapping<FieldMappings[Index]>["fields"][number]] : never : never : never : never;
 } & {
@@ -70,7 +78,8 @@ export declare class SystemBuilder<C extends Component<any>[] = Component<any>[]
     private components;
     private fieldMappings?;
     private userCallback?;
-    constructor(world: World, components: C, fieldMappings?: FM, userCallback?: (entity: any, deltaTime: number, world: World) => void);
+    private conditionPredicate?;
+    constructor(world: World, components: C, fieldMappings?: FM, userCallback?: (entity: any, deltaTime: number, world: World) => void, conditionPredicate?: CB extends true ? (entity: BuildEntityProxy<C, FM>) => boolean : undefined);
     /**
      * Specify which components this system should query for.
      */
@@ -81,6 +90,12 @@ export declare class SystemBuilder<C extends Component<any>[] = Component<any>[]
     fields<const NewFM extends {
         [K in keyof C]: C[K] extends Component<infer T> ? Record<string, readonly (keyof T)[]> : never;
     }>(fieldMappings: NewFM): SystemBuilder<C, NewFM, CB>;
+    /**
+     * Specify a condition to filter entities before running the system callback.
+     * @param predicate - Condition to filter entities before running the system callback.
+     * @returns A new SystemBuilder instance with the specified condition.
+     */
+    when(predicate: (entity: BuildEntityProxy<C, FM>) => boolean): SystemBuilder<C, FM, true>;
     /**
      * Set the system callback. If components and fields are set, builds the system.
      */
@@ -100,13 +115,12 @@ export declare class ExecutableSystem {
     private world;
     private components;
     private userCallback;
-    private fieldArrayCache;
-    private componentByAlias;
-    private aliases;
+    private fieldDescs;
     private queryMaskKey;
     private queryMask;
+    private conditionPredicate?;
     private proxyEntity;
-    constructor(world: World, components: Component<any>[], userCallback: (entity: any, deltaTime: number, world: World) => void, fieldArrayCache: Record<string, Record<string, any>>, componentByAlias: Record<string, Component<any>>, aliases: string[], queryMaskKey: string, queryMask: number[]);
+    constructor(world: World, components: Component<any>[], userCallback: (entity: any, deltaTime: number, world: World) => void, fieldDescs: FieldDesc[], queryMaskKey: string, queryMask: number[], conditionPredicate?: (entity: any) => boolean);
     /**
      * Execute the system for all matching entities.
      *
@@ -116,10 +130,7 @@ export declare class ExecutableSystem {
     /**
      * Create proxy entity that exposes arrays directly.
      *
-     * Instead of entity.transform_x (getter/setter),
-     * use entity.transform_x_array[entity.eid] for direct access.
-     *
-     * BUT ALSO provide getter/setter for convenience.
+     * Each getter closes over a specific TypedArray.
      */
     private createProxyEntity;
     /**

package/dist/{ecs → types/ecs}/world.d.ts

@@ -68,6 +68,8 @@ export declare class World extends WorldSystems {
     private archetypeVersion;
     private queryCacheVersions;
     private queryMaskCache;
+    private despawnedBuffer;
+    private despawnedCount;
     private worldId;
     constructor(config: WorldConfig);
     /**
@@ -135,6 +137,15 @@ export declare class World extends WorldSystems {
      * Check if an entity is alive
      */
     isAlive(entity: Entity): boolean;
+    /**
+     * Get entities despawned since the last flushDespawned() call.
+     * Returns a subarray view — zero allocations.
+     */
+    getDespawned(): Uint32Array;
+    /**
+     * Clear the despawn tracker. Call once per tick after processing despawns.
+     */
+    flushDespawned(): void;
     /**
      * Invalidate all query caches (called on archetype changes).
      */

package/dist/types/game/index.d.ts

@@ -0,0 +1 @@
+export * from "./loop";

package/dist/types/game/loop/index.d.ts

@@ -0,0 +1 @@
+export * from "./loop";