blecsd 0.1.0

package/dist/tilemap-D1HJvKy3.d.ts

@@ -0,0 +1,1211 @@
+import { E as Entity, W as World } from './types-BcsvoKzf.js';
+
+/**
+ * Collision component for entity collision detection.
+ * @module components/collision
+ */
+
+/**
+ * Collider shape types.
+ */
+declare enum ColliderType {
+    /** Axis-aligned bounding box */
+    BOX = 0,
+    /** Circle collider */
+    CIRCLE = 1
+}
+/**
+ * Collider component store using SoA (Structure of Arrays) for performance.
+ *
+ * - `type`: Collider shape (BOX or CIRCLE)
+ * - `width`, `height`: Dimensions (for BOX, height ignored for CIRCLE where width=diameter)
+ * - `offsetX`, `offsetY`: Offset from entity position
+ * - `layer`: Collision layer bitmask (what layer this entity is on)
+ * - `mask`: Collision mask bitmask (what layers to collide with)
+ * - `isTrigger`: Whether collider is a trigger (events only, no physics response)
+ *
+ * @example
+ * ```typescript
+ * import { setCollider, ColliderType } from 'blecsd';
+ *
+ * // Box collider
+ * setCollider(world, entity, {
+ *   type: ColliderType.BOX,
+ *   width: 2,
+ *   height: 1,
+ * });
+ *
+ * // Circle collider as trigger
+ * setCollider(world, entity, {
+ *   type: ColliderType.CIRCLE,
+ *   width: 3, // diameter
+ *   isTrigger: true,
+ * });
+ * ```
+ */
+declare const Collider: {
+    /** Collider type (0=BOX, 1=CIRCLE) */
+    type: Uint8Array<ArrayBuffer>;
+    /** Width (or diameter for circles) */
+    width: Float32Array<ArrayBuffer>;
+    /** Height (ignored for circles) */
+    height: Float32Array<ArrayBuffer>;
+    /** X offset from entity position */
+    offsetX: Float32Array<ArrayBuffer>;
+    /** Y offset from entity position */
+    offsetY: Float32Array<ArrayBuffer>;
+    /** Collision layer bitmask */
+    layer: Uint16Array<ArrayBuffer>;
+    /** Collision mask (layers to collide with) */
+    mask: Uint16Array<ArrayBuffer>;
+    /** Whether this is a trigger (1) or solid (0) */
+    isTrigger: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Collider data returned by getCollider.
+ */
+interface ColliderData {
+    readonly type: ColliderType;
+    readonly width: number;
+    readonly height: number;
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly layer: number;
+    readonly mask: number;
+    readonly isTrigger: boolean;
+}
+/**
+ * Options for setting a collider.
+ */
+interface ColliderOptions {
+    /** Collider type (default: BOX) */
+    type?: ColliderType;
+    /** Width or diameter (default: 1) */
+    width?: number;
+    /** Height, ignored for circles (default: 1) */
+    height?: number;
+    /** X offset from position (default: 0) */
+    offsetX?: number;
+    /** Y offset from position (default: 0) */
+    offsetY?: number;
+    /** Collision layer bitmask (default: 1) */
+    layer?: number;
+    /** Collision mask (default: 0xFFFF - collide with all) */
+    mask?: number;
+    /** Whether this is a trigger only (default: false) */
+    isTrigger?: boolean;
+}
+/**
+ * Default collision layer.
+ */
+declare const DEFAULT_LAYER = 1;
+/**
+ * Default collision mask (collide with all layers).
+ */
+declare const DEFAULT_MASK = 65535;
+/**
+ * Sets a collider on an entity.
+ * Adds the Collider component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Collider options
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setCollider, ColliderType } from 'blecsd';
+ *
+ * // Create a box collider
+ * setCollider(world, player, {
+ *   type: ColliderType.BOX,
+ *   width: 1,
+ *   height: 2,
+ *   layer: 0b0001,  // Player layer
+ *   mask: 0b0110,   // Collide with enemies and walls
+ * });
+ *
+ * // Create a trigger zone
+ * setCollider(world, checkpoint, {
+ *   type: ColliderType.BOX,
+ *   width: 3,
+ *   height: 3,
+ *   isTrigger: true,
+ * });
+ * ```
+ */
+declare function setCollider(world: World, eid: Entity, options?: ColliderOptions): Entity;
+/**
+ * Gets the collider data of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Collider data or undefined
+ *
+ * @example
+ * ```typescript
+ * import { getCollider } from 'blecsd';
+ *
+ * const collider = getCollider(world, entity);
+ * if (collider) {
+ *   console.log(`Collider: ${collider.width}x${collider.height}`);
+ * }
+ * ```
+ */
+declare function getCollider(world: World, eid: Entity): ColliderData | undefined;
+/**
+ * Checks if an entity has a Collider component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has Collider component
+ */
+declare function hasCollider(world: World, eid: Entity): boolean;
+/**
+ * Removes the collider from an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function removeCollider(world: World, eid: Entity): Entity;
+/**
+ * Sets the collision layer for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param layer - The collision layer bitmask
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setCollisionLayer } from 'blecsd';
+ *
+ * // Put entity on layer 2
+ * setCollisionLayer(world, entity, 0b0010);
+ * ```
+ */
+declare function setCollisionLayer(world: World, eid: Entity, layer: number): Entity;
+/**
+ * Sets the collision mask for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param mask - The collision mask bitmask
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setCollisionMask } from 'blecsd';
+ *
+ * // Only collide with layers 1 and 3
+ * setCollisionMask(world, entity, 0b0101);
+ * ```
+ */
+declare function setCollisionMask(world: World, eid: Entity, mask: number): Entity;
+/**
+ * Sets whether the collider is a trigger.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param isTrigger - Whether collider is trigger-only
+ * @returns The entity ID for chaining
+ */
+declare function setTrigger(world: World, eid: Entity, isTrigger: boolean): Entity;
+/**
+ * Checks if a collider is a trigger.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if collider is a trigger
+ */
+declare function isTrigger(world: World, eid: Entity): boolean;
+/**
+ * Checks if two layers can collide based on layer/mask.
+ *
+ * @param layerA - Layer of entity A
+ * @param maskA - Mask of entity A
+ * @param layerB - Layer of entity B
+ * @param maskB - Mask of entity B
+ * @returns true if the entities can collide
+ *
+ * @example
+ * ```typescript
+ * import { canLayersCollide } from 'blecsd';
+ *
+ * // Check if player (layer 1, mask 6) can collide with enemy (layer 2, mask 1)
+ * const canCollide = canLayersCollide(1, 6, 2, 1); // true
+ * ```
+ */
+declare function canLayersCollide(layerA: number, maskA: number, layerB: number, maskB: number): boolean;
+/**
+ * Axis-aligned bounding box.
+ */
+interface AABB {
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+}
+/**
+ * Gets the AABB for an entity's collider at a given position.
+ *
+ * @param eid - The entity ID
+ * @param posX - Entity X position
+ * @param posY - Entity Y position
+ * @returns The AABB bounds
+ *
+ * @example
+ * ```typescript
+ * import { getColliderAABB, Position } from 'blecsd';
+ *
+ * const bounds = getColliderAABB(entity, Position.x[entity], Position.y[entity]);
+ * console.log(`Bounds: ${bounds.minX},${bounds.minY} to ${bounds.maxX},${bounds.maxY}`);
+ * ```
+ */
+declare function getColliderAABB(eid: Entity, posX: number, posY: number): AABB;
+/**
+ * Tests if two AABBs overlap.
+ *
+ * @param a - First AABB
+ * @param b - Second AABB
+ * @returns true if the AABBs overlap
+ *
+ * @example
+ * ```typescript
+ * import { testAABBOverlap } from 'blecsd';
+ *
+ * const overlaps = testAABBOverlap(boundsA, boundsB);
+ * ```
+ */
+declare function testAABBOverlap(a: AABB, b: AABB): boolean;
+/**
+ * Tests if two circles overlap.
+ *
+ * @param x1 - Center X of first circle
+ * @param y1 - Center Y of first circle
+ * @param r1 - Radius of first circle
+ * @param x2 - Center X of second circle
+ * @param y2 - Center Y of second circle
+ * @param r2 - Radius of second circle
+ * @returns true if the circles overlap
+ */
+declare function testCircleOverlap(x1: number, y1: number, r1: number, x2: number, y2: number, r2: number): boolean;
+/**
+ * Tests if a circle overlaps with an AABB.
+ *
+ * @param cx - Circle center X
+ * @param cy - Circle center Y
+ * @param radius - Circle radius
+ * @param box - The AABB
+ * @returns true if they overlap
+ */
+declare function testCircleAABBOverlap(cx: number, cy: number, radius: number, box: AABB): boolean;
+/**
+ * Tests if two entities' colliders overlap.
+ * Handles all combinations of BOX and CIRCLE colliders.
+ *
+ * @param eidA - First entity
+ * @param posAX - First entity X position
+ * @param posAY - First entity Y position
+ * @param eidB - Second entity
+ * @param posBX - Second entity X position
+ * @param posBY - Second entity Y position
+ * @returns true if the colliders overlap
+ *
+ * @example
+ * ```typescript
+ * import { testCollision, Position } from 'blecsd';
+ *
+ * const colliding = testCollision(
+ *   entityA, Position.x[entityA], Position.y[entityA],
+ *   entityB, Position.x[entityB], Position.y[entityB]
+ * );
+ * ```
+ */
+declare function testCollision(eidA: Entity, posAX: number, posAY: number, eidB: Entity, posBX: number, posBY: number): boolean;
+/**
+ * Represents a collision between two entities.
+ */
+interface CollisionPair {
+    readonly entityA: Entity;
+    readonly entityB: Entity;
+    readonly isTrigger: boolean;
+}
+/**
+ * Creates a normalized collision pair (lower entity ID first).
+ * This ensures consistent ordering for collision tracking.
+ *
+ * @param eidA - First entity
+ * @param eidB - Second entity
+ * @param isTrigger - Whether this is a trigger collision
+ * @returns Normalized collision pair
+ */
+declare function createCollisionPair(eidA: Entity, eidB: Entity, isTrigger: boolean): CollisionPair;
+/**
+ * Creates a unique key for a collision pair.
+ *
+ * @param pair - The collision pair
+ * @returns A unique string key
+ */
+declare function collisionPairKey(pair: CollisionPair): string;
+
+/**
+ * Particle and ParticleEmitter components for visual effects.
+ *
+ * Provides SoA component stores for particles and emitters,
+ * along with helper functions for color interpolation, aging,
+ * and emitter configuration.
+ *
+ * @module components/particle
+ */
+
+/**
+ * Particle component store using SoA (Structure of Arrays).
+ *
+ * - `lifetime`: Total lifetime in seconds
+ * - `age`: Current age in seconds
+ * - `fadeOut`: 1 if particle should fade as it ages, 0 otherwise
+ * - `char`: Character code point to render
+ * - `startFg`: Foreground color at birth (packed RGBA)
+ * - `endFg`: Foreground color at death (packed RGBA)
+ * - `emitter`: Entity ID of the emitter that spawned this particle
+ *
+ * @example
+ * ```typescript
+ * import { Particle, setParticle, getParticle, isParticleDead } from 'blecsd';
+ *
+ * setParticle(world, entity, {
+ *   lifetime: 2,
+ *   char: '*'.codePointAt(0)!,
+ *   startFg: 0xffff0000,
+ *   endFg: 0xff880000,
+ *   fadeOut: true,
+ * });
+ * ```
+ */
+declare const Particle: {
+    /** Total lifetime in seconds */
+    lifetime: Float32Array<ArrayBuffer>;
+    /** Current age in seconds */
+    age: Float32Array<ArrayBuffer>;
+    /** 1 if particle fades out, 0 otherwise */
+    fadeOut: Uint8Array<ArrayBuffer>;
+    /** Character code point to render */
+    char: Uint32Array<ArrayBuffer>;
+    /** Foreground color at birth (packed RGBA) */
+    startFg: Uint32Array<ArrayBuffer>;
+    /** Foreground color at death (packed RGBA) */
+    endFg: Uint32Array<ArrayBuffer>;
+    /** Entity ID of the emitter that spawned this particle (0 = none) */
+    emitter: Uint32Array<ArrayBuffer>;
+};
+/**
+ * ParticleEmitter component store using SoA (Structure of Arrays).
+ *
+ * - `rate`: Particles per second (continuous emission)
+ * - `burstCount`: Number of particles to emit in a burst
+ * - `lifetime`: Default lifetime for spawned particles
+ * - `spread`: Emission spread angle in radians (0 = forward, PI = half-circle, 2*PI = full circle)
+ * - `speed`: Initial speed of spawned particles (cells/sec)
+ * - `gravity`: Downward acceleration (cells/sec^2)
+ * - `angle`: Base emission angle in radians (0 = right)
+ * - `active`: 1 if emitter is actively emitting, 0 if paused
+ * - `accumulator`: Internal accumulator for rate-based emission
+ *
+ * @example
+ * ```typescript
+ * import { ParticleEmitter, setEmitter, burstParticles } from 'blecsd';
+ *
+ * setEmitter(world, entity, {
+ *   rate: 10,
+ *   lifetime: 1.5,
+ *   speed: 5,
+ *   spread: Math.PI / 4,
+ *   gravity: 2,
+ * });
+ *
+ * burstParticles(world, entity, 20);
+ * ```
+ */
+declare const ParticleEmitter: {
+    /** Particles per second */
+    rate: Float32Array<ArrayBuffer>;
+    /** Burst count */
+    burstCount: Uint16Array<ArrayBuffer>;
+    /** Default particle lifetime in seconds */
+    lifetime: Float32Array<ArrayBuffer>;
+    /** Emission spread angle in radians */
+    spread: Float32Array<ArrayBuffer>;
+    /** Initial speed in cells per second */
+    speed: Float32Array<ArrayBuffer>;
+    /** Downward gravity in cells/sec^2 */
+    gravity: Float32Array<ArrayBuffer>;
+    /** Base emission angle in radians (0 = right) */
+    angle: Float32Array<ArrayBuffer>;
+    /** 1 if active, 0 if paused */
+    active: Uint8Array<ArrayBuffer>;
+    /** Internal accumulator for rate-based emission */
+    accumulator: Float32Array<ArrayBuffer>;
+};
+/**
+ * Particle data returned by getParticle.
+ */
+interface ParticleData {
+    readonly lifetime: number;
+    readonly age: number;
+    readonly fadeOut: boolean;
+    readonly char: number;
+    readonly startFg: number;
+    readonly endFg: number;
+    readonly emitter: number;
+}
+/**
+ * Options for setting a particle.
+ */
+interface ParticleOptions {
+    /** Total lifetime in seconds */
+    lifetime: number;
+    /** Character code point to render */
+    char: number;
+    /** Foreground color at birth (packed RGBA) */
+    startFg: number;
+    /** Foreground color at death (packed RGBA, default: same as startFg) */
+    endFg?: number;
+    /** Whether particle fades out (default: false) */
+    fadeOut?: boolean;
+    /** Entity ID of the emitter (default: 0) */
+    emitter?: number;
+}
+/**
+ * Emitter data returned by getEmitter.
+ */
+interface EmitterData {
+    readonly rate: number;
+    readonly burstCount: number;
+    readonly lifetime: number;
+    readonly spread: number;
+    readonly speed: number;
+    readonly gravity: number;
+    readonly angle: number;
+    readonly active: boolean;
+}
+/**
+ * Options for configuring an emitter.
+ */
+interface EmitterOptions {
+    /** Particles per second (default: 0, continuous off) */
+    rate?: number;
+    /** Burst count (default: 0) */
+    burstCount?: number;
+    /** Default particle lifetime in seconds */
+    lifetime: number;
+    /** Emission spread angle in radians (default: 2*PI, full circle) */
+    spread?: number;
+    /** Initial particle speed in cells/sec (default: 3) */
+    speed?: number;
+    /** Gravity in cells/sec^2 (default: 0) */
+    gravity?: number;
+    /** Base emission angle in radians (default: 0, right) */
+    angle?: number;
+    /** Whether emitter is active (default: true) */
+    active?: boolean;
+}
+/**
+ * Options for configuring emitter characters and colors.
+ */
+interface EmitterAppearance {
+    /** Characters to randomly pick from for spawned particles */
+    chars: ReadonlyArray<number>;
+    /** Start foreground color (packed RGBA) */
+    startFg: number;
+    /** End foreground color (packed RGBA, default: same as startFg) */
+    endFg?: number;
+    /** Whether particles should fade out (default: true) */
+    fadeOut?: boolean;
+}
+/**
+ * Sets particle data on an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Particle configuration
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setParticle, packColor } from 'blecsd';
+ *
+ * setParticle(world, entity, {
+ *   lifetime: 1.5,
+ *   char: '*'.codePointAt(0)!,
+ *   startFg: packColor(255, 255, 0),
+ *   endFg: packColor(255, 0, 0),
+ *   fadeOut: true,
+ * });
+ * ```
+ */
+declare function setParticle(world: World, eid: Entity, options: ParticleOptions): Entity;
+/**
+ * Gets particle data for an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns ParticleData or undefined if not a particle
+ */
+declare function getParticle(world: World, eid: Entity): ParticleData | undefined;
+/**
+ * Checks if an entity has a Particle component.
+ */
+declare function hasParticle(world: World, eid: Entity): boolean;
+/**
+ * Removes the Particle component from an entity.
+ */
+declare function removeParticle(world: World, eid: Entity): Entity;
+/**
+ * Checks if a particle has exceeded its lifetime.
+ */
+declare function isParticleDead(world: World, eid: Entity): boolean;
+/**
+ * Gets the normalized age of a particle (0-1).
+ */
+declare function getParticleProgress(world: World, eid: Entity): number;
+/**
+ * Interpolates between two packed RGBA colors based on a 0-1 parameter.
+ *
+ * @param startColor - Start color (packed RGBA)
+ * @param endColor - End color (packed RGBA)
+ * @param t - Interpolation factor (0 = start, 1 = end)
+ * @returns Interpolated packed RGBA color
+ *
+ * @example
+ * ```typescript
+ * import { interpolateColor, packColor } from 'blecsd';
+ *
+ * const red = packColor(255, 0, 0);
+ * const blue = packColor(0, 0, 255);
+ * const purple = interpolateColor(red, blue, 0.5);
+ * ```
+ */
+declare function interpolateColor(startColor: number, endColor: number, t: number): number;
+/**
+ * Gets the current interpolated color of a particle based on its age.
+ */
+declare function getParticleColor(world: World, eid: Entity): number;
+/**
+ * Sets emitter data on an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Emitter configuration
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setEmitter } from 'blecsd';
+ *
+ * setEmitter(world, entity, {
+ *   rate: 20,
+ *   lifetime: 1,
+ *   speed: 5,
+ *   spread: Math.PI / 3,
+ *   gravity: 9.8,
+ * });
+ * ```
+ */
+declare function setEmitter(world: World, eid: Entity, options: EmitterOptions): Entity;
+/**
+ * Gets emitter data for an entity.
+ */
+declare function getEmitter(world: World, eid: Entity): EmitterData | undefined;
+/**
+ * Checks if an entity has a ParticleEmitter component.
+ */
+declare function hasEmitter(world: World, eid: Entity): boolean;
+/**
+ * Removes the ParticleEmitter component from an entity.
+ */
+declare function removeEmitter(world: World, eid: Entity): Entity;
+/**
+ * Sets the visual appearance config for particles spawned by this emitter.
+ *
+ * @param eid - The emitter entity ID
+ * @param appearance - Appearance configuration
+ */
+declare function setEmitterAppearance(eid: Entity, appearance: EmitterAppearance): void;
+/**
+ * Gets the appearance config for an emitter.
+ */
+declare function getEmitterAppearance(eid: Entity): EmitterAppearance | undefined;
+/**
+ * Gets the set of particle entity IDs spawned by an emitter.
+ */
+declare function getEmitterParticles(eid: Entity): ReadonlySet<number>;
+/**
+ * Tracks a particle as belonging to an emitter.
+ */
+declare function trackParticle(emitterId: Entity, particleId: Entity): void;
+/**
+ * Untracks a particle from its emitter.
+ */
+declare function untrackParticle(emitterId: Entity, particleId: Entity): void;
+/**
+ * Activates an emitter.
+ */
+declare function activateEmitter(world: World, eid: Entity): void;
+/**
+ * Pauses an emitter.
+ */
+declare function pauseEmitter(world: World, eid: Entity): void;
+/**
+ * Checks if an emitter is active.
+ */
+declare function isEmitterActive(world: World, eid: Entity): boolean;
+/**
+ * Sets the emission rate (particles per second).
+ */
+declare function setEmitterRate(world: World, eid: Entity, rate: number): void;
+/**
+ * Sets the emitter speed.
+ */
+declare function setEmitterSpeed(world: World, eid: Entity, speed: number): void;
+/**
+ * Sets the emitter gravity.
+ */
+declare function setEmitterGravity(world: World, eid: Entity, gravity: number): void;
+/**
+ * Resets all particle/emitter side stores. Useful for testing.
+ */
+declare function resetParticleStore(): void;
+
+/**
+ * TileMap component for 2D tile-based game maps.
+ *
+ * Provides a tile map data structure with multiple layers,
+ * tileset management, and per-entity SoA storage for tile map
+ * metadata. Tile data is stored in an external side store
+ * (Map-based) for variable-sized arrays.
+ *
+ * @module components/tilemap
+ */
+
+/** Empty tile index (no tile rendered) */
+declare const EMPTY_TILE = 0;
+/**
+ * A single tile definition in a tileset.
+ *
+ * @example
+ * ```typescript
+ * import type { TileDefinition } from 'blecsd';
+ *
+ * const grass: TileDefinition = { char: '.', fg: 0x00ff00ff, bg: 0x003300ff };
+ * const wall: TileDefinition = { char: '#', fg: 0xaaaaaaff, bg: 0x444444ff };
+ * ```
+ */
+interface TileDefinition {
+    /** Character to render for this tile */
+    readonly char: string;
+    /** Foreground color (packed RGBA) */
+    readonly fg: number;
+    /** Background color (packed RGBA) */
+    readonly bg: number;
+}
+/**
+ * Tileset data stored in the tileset store.
+ */
+interface TilesetData {
+    /** Unique tileset ID */
+    readonly id: number;
+    /** Human-readable name */
+    readonly name: string;
+    /** Array of tile definitions (index 0 = empty/transparent) */
+    readonly tiles: readonly TileDefinition[];
+}
+/**
+ * Options for registering a new tileset.
+ */
+interface TilesetOptions {
+    /** Human-readable name for the tileset */
+    name: string;
+    /** Array of tile definitions. Index 0 is conventionally empty/transparent. */
+    tiles: TileDefinition[];
+}
+/**
+ * Storage for tileset data.
+ *
+ * @example
+ * ```typescript
+ * import { registerTileset, getTileset } from 'blecsd';
+ *
+ * const tilesetId = registerTileset({
+ *   name: 'dungeon',
+ *   tiles: [
+ *     { char: ' ', fg: 0, bg: 0 },           // 0: empty
+ *     { char: '.', fg: 0x888888ff, bg: 0 },   // 1: floor
+ *     { char: '#', fg: 0xaaaaaaff, bg: 0x444444ff }, // 2: wall
+ *   ],
+ * });
+ * ```
+ */
+declare const tilesetStore: {
+    /** Map of tileset ID to data */
+    tilesets: Map<number, TilesetData>;
+    /** Map of tileset name to ID */
+    nameToId: Map<string, number>;
+};
+/**
+ * Resets the tileset store to initial state. Useful for testing.
+ *
+ * @example
+ * ```typescript
+ * import { resetTilesetStore } from 'blecsd';
+ *
+ * resetTilesetStore();
+ * ```
+ */
+declare function resetTilesetStore(): void;
+/**
+ * Registers a new tileset and returns its ID.
+ *
+ * @param options - Tileset configuration
+ * @returns The tileset ID
+ *
+ * @example
+ * ```typescript
+ * import { registerTileset } from 'blecsd';
+ *
+ * const tilesetId = registerTileset({
+ *   name: 'overworld',
+ *   tiles: [
+ *     { char: ' ', fg: 0, bg: 0 },
+ *     { char: '.', fg: 0x00ff00ff, bg: 0x003300ff },
+ *     { char: '~', fg: 0x0000ffff, bg: 0x000066ff },
+ *   ],
+ * });
+ * ```
+ */
+declare function registerTileset(options: TilesetOptions): number;
+/**
+ * Gets a tileset by ID.
+ *
+ * @param id - The tileset ID
+ * @returns The tileset data or undefined
+ *
+ * @example
+ * ```typescript
+ * import { getTileset } from 'blecsd';
+ *
+ * const tileset = getTileset(tilesetId);
+ * if (tileset) {
+ *   console.log(`Tileset: ${tileset.name}, ${tileset.tiles.length} tiles`);
+ * }
+ * ```
+ */
+declare function getTileset(id: number): TilesetData | undefined;
+/**
+ * Gets a tileset by name.
+ *
+ * @param name - The tileset name
+ * @returns The tileset data or undefined
+ *
+ * @example
+ * ```typescript
+ * import { getTilesetByName } from 'blecsd';
+ *
+ * const tileset = getTilesetByName('dungeon');
+ * ```
+ */
+declare function getTilesetByName(name: string): TilesetData | undefined;
+/**
+ * Unregisters a tileset.
+ *
+ * @param id - The tileset ID to remove
+ * @returns true if removed, false if not found
+ */
+declare function unregisterTileset(id: number): boolean;
+/**
+ * A single layer of tile data.
+ */
+interface TileMapLayer {
+    /** Flat array of tile indices (width * height), row-major order */
+    readonly tiles: Uint16Array;
+    /** Whether this layer is visible */
+    visible: boolean;
+}
+/**
+ * Tile map data stored in the side store.
+ */
+interface TileMapData {
+    /** Map width in tiles */
+    readonly width: number;
+    /** Map height in tiles */
+    readonly height: number;
+    /** Array of tile layers (bottom to top) */
+    readonly layers: TileMapLayer[];
+}
+/**
+ * Storage for tile map layer data.
+ * Maps data IDs to their tile data.
+ */
+declare const tileMapStore: {
+    /** Map of data ID to tile map data */
+    data: Map<number, TileMapData>;
+};
+/**
+ * Resets the tile map store to initial state. Useful for testing.
+ *
+ * @example
+ * ```typescript
+ * import { resetTileMapStore } from 'blecsd';
+ *
+ * resetTileMapStore();
+ * ```
+ */
+declare function resetTileMapStore(): void;
+/**
+ * Creates tile map data with the specified dimensions and number of layers.
+ * Returns the data ID for referencing in the TileMap component.
+ *
+ * @param width - Map width in tiles
+ * @param height - Map height in tiles
+ * @param layerCount - Number of layers (default: 1)
+ * @returns The data ID
+ *
+ * @example
+ * ```typescript
+ * import { createTileData } from 'blecsd';
+ *
+ * const dataId = createTileData(32, 32, 2); // 32x32 map, 2 layers
+ * ```
+ */
+declare function createTileData(width: number, height: number, layerCount?: number): number;
+/**
+ * Gets tile map data by ID.
+ *
+ * @param dataId - The data ID
+ * @returns The tile map data or undefined
+ */
+declare function getTileData(dataId: number): TileMapData | undefined;
+/**
+ * Removes tile map data.
+ *
+ * @param dataId - The data ID to remove
+ * @returns true if removed, false if not found
+ */
+declare function removeTileData(dataId: number): boolean;
+/**
+ * Sets a tile at a specific position in a layer.
+ *
+ * @param dataId - The tile map data ID
+ * @param layerIndex - The layer index (0-based)
+ * @param x - X coordinate in tiles
+ * @param y - Y coordinate in tiles
+ * @param tileIndex - The tile index in the tileset
+ * @returns true if set successfully, false if out of bounds or invalid
+ *
+ * @example
+ * ```typescript
+ * import { createTileData, setTile } from 'blecsd';
+ *
+ * const dataId = createTileData(10, 10);
+ * setTile(dataId, 0, 5, 3, 2); // Set tile at (5,3) on layer 0 to tile index 2
+ * ```
+ */
+declare function setTile(dataId: number, layerIndex: number, x: number, y: number, tileIndex: number): boolean;
+/**
+ * Gets the tile index at a specific position in a layer.
+ *
+ * @param dataId - The tile map data ID
+ * @param layerIndex - The layer index (0-based)
+ * @param x - X coordinate in tiles
+ * @param y - Y coordinate in tiles
+ * @returns The tile index, or EMPTY_TILE if out of bounds
+ *
+ * @example
+ * ```typescript
+ * import { getTile, EMPTY_TILE } from 'blecsd';
+ *
+ * const tile = getTile(dataId, 0, 5, 3);
+ * if (tile !== EMPTY_TILE) {
+ *   // Tile is not empty
+ * }
+ * ```
+ */
+declare function getTile(dataId: number, layerIndex: number, x: number, y: number): number;
+/**
+ * Fills an entire layer with a tile index.
+ *
+ * @param dataId - The tile map data ID
+ * @param layerIndex - The layer index (0-based)
+ * @param tileIndex - The tile index to fill with
+ * @returns true if filled, false if invalid
+ *
+ * @example
+ * ```typescript
+ * import { createTileData, fillTiles } from 'blecsd';
+ *
+ * const dataId = createTileData(32, 32);
+ * fillTiles(dataId, 0, 1); // Fill entire layer with tile 1 (floor)
+ * ```
+ */
+declare function fillTiles(dataId: number, layerIndex: number, tileIndex: number): boolean;
+/**
+ * Fills a rectangular region of a layer with a tile index.
+ *
+ * @param dataId - The tile map data ID
+ * @param layerIndex - The layer index
+ * @param x - Start X coordinate
+ * @param y - Start Y coordinate
+ * @param width - Rectangle width in tiles
+ * @param height - Rectangle height in tiles
+ * @param tileIndex - The tile index to fill with
+ * @returns true if filled, false if invalid
+ *
+ * @example
+ * ```typescript
+ * import { fillTileRect } from 'blecsd';
+ *
+ * // Create a 5x3 wall region at (2, 4)
+ * fillTileRect(dataId, 0, 2, 4, 5, 3, 2);
+ * ```
+ */
+declare function fillTileRect(dataId: number, layerIndex: number, x: number, y: number, width: number, height: number, tileIndex: number): boolean;
+/**
+ * Gets the number of layers in a tile map.
+ *
+ * @param dataId - The tile map data ID
+ * @returns The number of layers, or 0 if invalid
+ */
+declare function getLayerCount(dataId: number): number;
+/**
+ * Adds a new empty layer to the tile map.
+ *
+ * @param dataId - The tile map data ID
+ * @returns The new layer index, or -1 if invalid
+ *
+ * @example
+ * ```typescript
+ * import { addLayer } from 'blecsd';
+ *
+ * const layerIdx = addLayer(dataId);
+ * // Now you can set tiles on the new layer
+ * ```
+ */
+declare function addLayer(dataId: number): number;
+/**
+ * Sets the visibility of a layer.
+ *
+ * @param dataId - The tile map data ID
+ * @param layerIndex - The layer index
+ * @param visible - Whether the layer should be visible
+ * @returns true if set, false if invalid
+ *
+ * @example
+ * ```typescript
+ * import { setLayerVisible } from 'blecsd';
+ *
+ * setLayerVisible(dataId, 1, false); // Hide layer 1
+ * ```
+ */
+declare function setLayerVisible(dataId: number, layerIndex: number, visible: boolean): boolean;
+/**
+ * Gets the visibility of a layer.
+ *
+ * @param dataId - The tile map data ID
+ * @param layerIndex - The layer index
+ * @returns true if visible, false if hidden or invalid
+ */
+declare function isLayerVisible(dataId: number, layerIndex: number): boolean;
+/**
+ * TileMap component store using SoA (Structure of Arrays) for performance.
+ *
+ * - `width`: Map width in tiles
+ * - `height`: Map height in tiles
+ * - `tileWidth`: Tile width in terminal cells (for rendering)
+ * - `tileHeight`: Tile height in terminal cells (for rendering)
+ * - `dataId`: Reference to tile data in tileMapStore
+ * - `tilesetId`: Reference to tileset in tilesetStore
+ *
+ * @example
+ * ```typescript
+ * import { TileMap, setTileMap, getTileMap } from 'blecsd';
+ *
+ * setTileMap(world, entity, {
+ *   width: 32,
+ *   height: 32,
+ *   tileWidth: 1,
+ *   tileHeight: 1,
+ *   tilesetId: myTilesetId,
+ * });
+ * ```
+ */
+declare const TileMap: {
+    /** Map width in tiles */
+    width: Uint16Array<ArrayBuffer>;
+    /** Map height in tiles */
+    height: Uint16Array<ArrayBuffer>;
+    /** Tile width in terminal cells */
+    tileWidth: Uint8Array<ArrayBuffer>;
+    /** Tile height in terminal cells */
+    tileHeight: Uint8Array<ArrayBuffer>;
+    /** Reference to tile data in tileMapStore */
+    dataId: Uint32Array<ArrayBuffer>;
+    /** Reference to tileset in tilesetStore */
+    tilesetId: Uint32Array<ArrayBuffer>;
+};
+/**
+ * TileMap data returned by getTileMap.
+ */
+interface TileMapComponentData {
+    readonly width: number;
+    readonly height: number;
+    readonly tileWidth: number;
+    readonly tileHeight: number;
+    readonly dataId: number;
+    readonly tilesetId: number;
+}
+/**
+ * Options for creating a tile map on an entity.
+ */
+interface TileMapOptions {
+    /** Map width in tiles */
+    width: number;
+    /** Map height in tiles */
+    height: number;
+    /** Tile width in terminal cells (default: 1) */
+    tileWidth?: number;
+    /** Tile height in terminal cells (default: 1) */
+    tileHeight?: number;
+    /** Tileset ID to use for rendering */
+    tilesetId: number;
+    /** Number of layers (default: 1) */
+    layerCount?: number;
+    /** Existing data ID to use (skips creating new tile data) */
+    dataId?: number;
+}
+/**
+ * Sets a tile map on an entity. Creates tile data if not provided.
+ * Adds the TileMap component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Tile map options
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setTileMap, registerTileset } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * const tilesetId = registerTileset({
+ *   name: 'dungeon',
+ *   tiles: [
+ *     { char: ' ', fg: 0, bg: 0 },
+ *     { char: '.', fg: 0x888888ff, bg: 0 },
+ *     { char: '#', fg: 0xaaaaaaff, bg: 0x444444ff },
+ *   ],
+ * });
+ *
+ * setTileMap(world, entity, {
+ *   width: 20,
+ *   height: 15,
+ *   tilesetId,
+ * });
+ * ```
+ */
+declare function setTileMap(world: World, eid: Entity, options: TileMapOptions): Entity;
+/**
+ * Gets the tile map data of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns TileMap component data or undefined
+ *
+ * @example
+ * ```typescript
+ * import { getTileMap } from 'blecsd';
+ *
+ * const tileMap = getTileMap(world, entity);
+ * if (tileMap) {
+ *   console.log(`Map: ${tileMap.width}x${tileMap.height}`);
+ * }
+ * ```
+ */
+declare function getTileMap(world: World, eid: Entity): TileMapComponentData | undefined;
+/**
+ * Checks if an entity has a TileMap component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has TileMap component
+ */
+declare function hasTileMap(world: World, eid: Entity): boolean;
+/**
+ * Removes the tile map from an entity.
+ * Also removes the associated tile data from the store.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param keepData - If true, does not remove tile data from store (default: false)
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { removeTileMap } from 'blecsd';
+ *
+ * removeTileMap(world, entity);
+ * ```
+ */
+declare function removeTileMap(world: World, eid: Entity, keepData?: boolean): Entity;
+/**
+ * Gets the data ID for an entity's tile map.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The data ID or 0 if not found
+ */
+declare function getTileMapDataId(world: World, eid: Entity): number;
+/**
+ * A single rendered cell from the tile map.
+ */
+interface RenderedTileCell {
+    /** Character to display */
+    readonly char: string;
+    /** Foreground color (packed RGBA) */
+    readonly fg: number;
+    /** Background color (packed RGBA) */
+    readonly bg: number;
+}
+/**
+ * Renders a rectangular viewport of the tile map to an array of cells.
+ * Composites all visible layers from bottom to top.
+ * Non-empty tiles on upper layers overwrite lower layers.
+ *
+ * @param dataId - The tile map data ID
+ * @param tilesetId - The tileset ID to use for rendering
+ * @param viewX - Viewport X offset in tiles
+ * @param viewY - Viewport Y offset in tiles
+ * @param viewWidth - Viewport width in tiles
+ * @param viewHeight - Viewport height in tiles
+ * @returns 2D array of rendered cells (row-major: [y][x])
+ *
+ * @example
+ * ```typescript
+ * import { renderTileMapArea } from 'blecsd';
+ *
+ * // Render a 10x8 viewport starting at tile (5, 3)
+ * const cells = renderTileMapArea(dataId, tilesetId, 5, 3, 10, 8);
+ * for (let y = 0; y < cells.length; y++) {
+ *   for (let x = 0; x < cells[y].length; x++) {
+ *     const cell = cells[y][x];
+ *     // Render cell.char with cell.fg and cell.bg
+ *   }
+ * }
+ * ```
+ */
+declare function renderTileMapArea(dataId: number, tilesetId: number, viewX: number, viewY: number, viewWidth: number, viewHeight: number): RenderedTileCell[][];
+
+export { isEmitterActive as $, type AABB as A, getCollider as B, Collider as C, DEFAULT_LAYER as D, EMPTY_TILE as E, getColliderAABB as F, getEmitter as G, getEmitterAppearance as H, getEmitterParticles as I, getLayerCount as J, getParticle as K, getParticleColor as L, getParticleProgress as M, getTile as N, getTileData as O, Particle as P, getTileMap as Q, type RenderedTileCell as R, getTileMapDataId as S, type TileDefinition as T, getTileset as U, getTilesetByName as V, hasCollider as W, hasEmitter as X, hasParticle as Y, hasTileMap as Z, interpolateColor as _, type ColliderData as a, isLayerVisible as a0, isParticleDead as a1, isTrigger as a2, pauseEmitter as a3, registerTileset as a4, removeCollider as a5, removeEmitter as a6, removeParticle as a7, removeTileData as a8, removeTileMap as a9, renderTileMapArea as aa, resetParticleStore as ab, resetTileMapStore as ac, resetTilesetStore as ad, setCollider as ae, setCollisionLayer as af, setCollisionMask as ag, setEmitter as ah, setEmitterAppearance as ai, setEmitterGravity as aj, setEmitterRate as ak, setEmitterSpeed as al, setLayerVisible as am, setParticle as an, setTile as ao, setTileMap as ap, setTrigger as aq, testAABBOverlap as ar, testCircleAABBOverlap as as, testCircleOverlap as at, testCollision as au, tileMapStore as av, tilesetStore as aw, trackParticle as ax, unregisterTileset as ay, untrackParticle as az, type ColliderOptions as b, ColliderType as c, type CollisionPair as d, DEFAULT_MASK as e, type EmitterAppearance as f, type EmitterData as g, type EmitterOptions as h, type ParticleData as i, ParticleEmitter as j, type ParticleOptions as k, TileMap as l, type TileMapComponentData as m, type TileMapData as n, type TileMapLayer as o, type TileMapOptions as p, type TilesetData as q, type TilesetOptions as r, activateEmitter as s, addLayer as t, canLayersCollide as u, collisionPairKey as v, createCollisionPair as w, createTileData as x, fillTileRect as y, fillTiles as z };