murow 0.0.70 → 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/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

@@ -8,3 +8,8 @@ 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/{core → types/core}/input/index.d.ts

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

package/dist/{core → types/core}/input/manager.d.ts

@@ -12,6 +12,8 @@ export declare class InputManager {
     private keys;
     private prevKeys;
     private mouse;
+    private lastClientX;
+    private lastClientY;
     private prevMouse;
     private snapshotA;
     private snapshotB;

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}/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/{game → types/game}/loop/loop.d.ts

@@ -4,12 +4,12 @@ import { InputManager } from "../../core/input";
  * GameLoop class that manages the main game loop with tick events and optional rendering.
  * It supports both client and server types, emitting appropriate events for both.
  */
-export declare class GameLoop<T extends DriverType = DriverType> {
-    options: GameLoopOptions & {
-        type: T;
-    };
-    private _driver;
+export declare class GameLoop<T extends GameLoopType = DriverType> {
+    options: GameLoopOptions<T>;
+    private _driver?;
     private _input;
+    private readonly _isClient;
+    private readonly _isManual;
     /**
      * FixedTicker instance that handles tick timing and updates.
      */
@@ -17,7 +17,7 @@ export declare class GameLoop<T extends DriverType = DriverType> {
     /**
      * Event emitter system for the game loop, emitting various lifecycle events.
      */
-    events: Events;
+    events: EventSystem<BaseEvents> & T extends ClientLike ? EventSystem<ClientEvents> : EventSystem<ServerEvents>;
     /**
      * Current frames per second (FPS) measurement.
      */
@@ -25,10 +25,12 @@ export declare class GameLoop<T extends DriverType = DriverType> {
     /**
      * Current status of the game loop: 'running', 'paused', or 'stopped'.
      */
-    status: 'running' | 'paused' | 'stopped';
-    constructor(options: GameLoopOptions & {
-        type: T;
-    });
+    status: "running" | "paused" | "stopped";
+    private _tickData;
+    private _skipData;
+    private _renderData;
+    constructor(options: GameLoopOptions<T>);
+    step(deltaTime: number): void;
     /**
      * Pauses the game ticker and emits a 'toggle-pause' event.
      */
@@ -46,15 +48,15 @@ export declare class GameLoop<T extends DriverType = DriverType> {
      */
     stop(): void;
 }
-interface GameLoopOptions {
+interface GameLoopOptions<T extends GameLoopType> {
     tickRate: number;
-    type: DriverType;
-    onTick?: (dt: number, tick: number, input: ReturnType<InputManager['snapshot']>) => void;
-    onRender?: (dt: number, alpha: number, input: ReturnType<InputManager['snapshot']>) => void;
+    type: T;
+    onTick?: (dt: number, tick: number, input: ReturnType<InputManager["snapshot"]>) => void;
+    onRender?: (dt: number, alpha: number, input: ReturnType<InputManager["peek"]>) => void;
 }
 type BaseEvents = [
     [
-        'start',
+        "start",
         {
             /**
              * Timestamp when the loop was started.
@@ -63,7 +65,7 @@ type BaseEvents = [
         }
     ],
     [
-        'pre-tick',
+        "pre-tick",
         {
             /**
              * Current tick number.
@@ -78,11 +80,11 @@ type BaseEvents = [
              *
              * **Only available in client loops.**
              */
-            input: ReturnType<InputManager['snapshot']>;
+            input: ReturnType<InputManager["snapshot"]>;
         }
     ],
     [
-        'tick',
+        "tick",
         {
             /**
              * Current tick number.
@@ -97,15 +99,15 @@ type BaseEvents = [
              *
              * **Only available in client loops.**
              */
-            input: ReturnType<InputManager['snapshot']>;
+            input: ReturnType<InputManager["snapshot"]>;
         }
     ],
     [
-        'post-tick',
+        "post-tick",
         {
             /**
-            * Current tick number.
-            */
+             * Current tick number.
+             */
             tick: number;
             /**
              * Delta time since the last tick.
@@ -116,11 +118,11 @@ type BaseEvents = [
              *
              * **Only available in client loops.**
              */
-            input: ReturnType<InputManager['snapshot']>;
+            input: ReturnType<InputManager["snapshot"]>;
         }
     ],
     [
-        'skip',
+        "skip",
         {
             /**
              * Number of ticks that were skipped.
@@ -129,7 +131,7 @@ type BaseEvents = [
         }
     ],
     [
-        'stop',
+        "stop",
         {
             /**
              * Timestamp when the loop was stopped.
@@ -138,7 +140,7 @@ type BaseEvents = [
         }
     ],
     [
-        'toggle-pause',
+        "toggle-pause",
         {
             /**
              * Current paused state of the loop.
@@ -158,14 +160,16 @@ type BaseEvents = [
 type ClientEvents = [
     ...BaseEvents,
     [
-        'render',
+        "render",
         {
             deltaTime: number;
             alpha: number;
-            input: ReturnType<InputManager['snapshot']>;
+            input: ReturnType<InputManager["peek"]>;
         }
     ]
 ];
 type ServerEvents = BaseEvents;
-type Events = EventSystem<ClientEvents | ServerEvents>;
+type Manual = "manual-client" | "manual-server";
+type ClientLike = "client" | "manual-client";
+export type GameLoopType = DriverType | Manual;
 export {};

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

@@ -19,3 +19,4 @@ export * from "./protocol";
 export * from "./net";
 export * from "./ecs";
 export * from "./game";
+export * from "./renderer";

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

@@ -14,8 +14,8 @@
  *
  * @example
  * ```typescript
- * import { ServerNetwork, ClientNetwork } from '@mococa/net';
- * import { BunWebSocketServerTransport } from '@mococa/net/transports/bun-websocket';
+ * import { ServerNetwork, ClientNetwork } from 'murow/net';
+ * import { BunWebSocketServerTransport } from 'murow/net/transports/bun-websocket';
  * import { IntentRegistry, SnapshotRegistry } from '@mococa/protocol';
  *
  * // Server setup

package/dist/types/renderer/base-2d-renderer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Abstract base for 2D renderers. Defines the sprite-based rendering API.
+ */
+import { BaseRenderer } from "./base-renderer";
+import type { Camera2DState, Renderer2DOptions, SpriteHandle, SpriteOptions, SpritesheetHandle, SpritesheetSource } from "./types";
+export declare abstract class Base2DRenderer extends BaseRenderer<Renderer2DOptions> {
+    readonly maxSprites: number;
+    abstract readonly camera: Camera2DState;
+    constructor(canvas: HTMLCanvasElement, options: Renderer2DOptions);
+    abstract loadSpritesheet(source: SpritesheetSource): Promise<SpritesheetHandle>;
+    abstract addSprite(options: SpriteOptions): SpriteHandle;
+    abstract removeSprite(sprite: SpriteHandle): void;
+}

package/dist/types/renderer/base-3d-renderer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Abstract base for 3D renderers. Defines the model/instance-based rendering API.
+ */
+import { BaseRenderer } from "./base-renderer";
+import type { Camera3DState, Renderer3DOptions } from "./types";
+export declare abstract class Base3DRenderer extends BaseRenderer<Renderer3DOptions> {
+    readonly maxModels: number;
+    abstract readonly camera: Camera3DState;
+    constructor(canvas: HTMLCanvasElement, options: Renderer3DOptions);
+}

package/dist/types/renderer/base-renderer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Abstract base for all renderers. Provides lifecycle and canvas management.
+ */
+import type { ClearColor, RendererOptions } from "./types";
+export declare abstract class BaseRenderer<TOptions extends RendererOptions = RendererOptions> {
+    readonly canvas: HTMLCanvasElement;
+    protected readonly options: TOptions;
+    protected _clearColor: ClearColor;
+    protected _width: number;
+    protected _height: number;
+    protected _initialized: boolean;
+    constructor(canvas: HTMLCanvasElement, options: TOptions);
+    get clearColor(): ClearColor;
+    set clearColor(value: ClearColor);
+    get width(): number;
+    get height(): number;
+    get initialized(): boolean;
+    abstract init(): Promise<void>;
+    abstract render(alpha: number): void;
+    abstract destroy(): void;
+}

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

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./base-renderer";
+export * from "./base-2d-renderer";
+export * from "./base-3d-renderer";