@kayelaa/canvas 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,2267 @@
+/**
+ * @fileoverview High-level 2D Canvas Engine (DOM-like, named entities/scenes)
+ */
+type Listener<T extends any[] = any[]> = (...args: T) => void;
+/**
+ * Generic event emitter with typed events and methods similar to Node.js EventEmitter.
+ *
+ * @template Events - Record mapping event names to argument tuples
+ *
+ * @example
+ * const emitter = new LeaEventEmitter<{
+ *   update: [number];
+ *   error: [Error];
+ * }>();
+ *
+ * emitter.on('update', (delta) => console.log(delta));
+ * emitter.emit('update', 0.016);
+ */
+declare class LeaEventEmitter<Events extends Record<string, any[]>> {
+    #private;
+    constructor();
+    /**
+     * Registers a listener for the specified event.
+     *
+     * @template K - Event name
+     * @param event - The name of the event
+     * @param listener - The callback to invoke when the event is emitted
+     * @returns This emitter for chaining
+     */
+    on<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    /**
+     * Registers a one-time listener for the specified event.
+     *
+     * The listener is automatically removed after the first invocation.
+     *
+     * @template K - Event name
+     * @param event - The name of the event
+     * @param listener - The callback to invoke once
+     * @returns This emitter for chaining
+     */
+    once<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    /**
+     * Removes a listener for the specified event.
+     *
+     * @template K - Event name
+     * @param event - The name of the event
+     * @param listener - The callback to remove
+     * @returns This emitter for chaining
+     */
+    off<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    /**
+     * Emits an event, invoking all registered listeners with the provided arguments.
+     *
+     * If the event is `"error"` and no listeners are registered, the first argument (the error)
+     * will be thrown.
+     *
+     * @template K - Event name
+     * @param event - The name of the event to emit
+     * @param args - Arguments to pass to listeners
+     * @returns `true` if any listeners were invoked, `false` otherwise
+     */
+    emit<K extends keyof Events>(event: K, ...args: Events[K]): boolean;
+    /**
+     * Removes all listeners for the specified event, or all listeners if no event is provided.
+     *
+     * @template K - Event name
+     * @param event - Optional event name to clear listeners for
+     * @returns This emitter for chaining
+     */
+    removeAllListeners<K extends keyof Events>(event?: K): this;
+    /**
+     * Returns the number of listeners registered for the specified event.
+     *
+     * @template K - Event name
+     * @param event - The event to count listeners for
+     * @returns The number of registered listeners
+     */
+    listenerCount<K extends keyof Events>(event: K): number;
+}
+/**
+ * Canvas-based renderer that manages a 2D drawing context and emits a `"draw"` event each frame.
+ *
+ * Handles resolution scaling (viewport vs camera), automatic clearing, and RAF loop.
+ *
+ * @extends LeaEventEmitter<{ draw: [CanvasRenderingContext2D] }>
+ *
+ * @example
+ * const renderer = new LeaRendererII(canvas, { viewportWidth: 800, viewportHeight: 600 });
+ * renderer.on("draw", (ctx) => {
+ *   ctx.fillStyle = "black";
+ *   ctx.fillRect(0, 0, renderer.viewportWidth, renderer.viewportHeight);
+ * });
+ * renderer.start();
+ */
+declare class LeaRendererII extends LeaEventEmitter<{
+    draw: [CanvasRenderingContext2D];
+}> {
+    #private;
+    /**
+     * The target canvas element.
+     */
+    canvas: HTMLCanvasElement;
+    /**
+     * The 2D rendering context.
+     */
+    ctx: CanvasRenderingContext2D;
+    /**
+     * Whether the renderer is currently running (RAF loop active).
+     */
+    running: boolean;
+    private _rafId;
+    private _fps;
+    private _frameCount;
+    private _fpsTimer;
+    private _lastFrameTime;
+    constructor(canvas: HTMLCanvasElement, { viewportWidth, viewportHeight, cameraWidth, cameraHeight, }?: {
+        viewportWidth?: number;
+        viewportHeight?: number;
+        cameraWidth?: number;
+        cameraHeight?: number;
+    });
+    automatic: boolean;
+    retransform(): void;
+    /**
+     * The logical viewport width (game coordinate space).
+     */
+    get viewportWidth(): number;
+    set viewportWidth(v: number);
+    get width(): number;
+    get height(): number;
+    /**
+     * Center X of the viewport (viewportWidth / 2).
+     */
+    get centerX(): number;
+    /**
+     * Center Y of the viewport (viewportHeight / 2).
+     */
+    get centerY(): number;
+    get left(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    /**
+     * The logical viewport height (game coordinate space).
+     */
+    get viewportHeight(): number;
+    set viewportHeight(v: number);
+    /**
+     * The camera/pixel resolution width (canvas backing resolution).
+     */
+    get cameraWidth(): number;
+    set cameraWidth(v: number);
+    /**
+     * The camera/pixel resolution height (canvas backing resolution).
+     */
+    get cameraHeight(): number;
+    set cameraHeight(v: number);
+    /**
+     * Update canvas resolution to match camera
+     * Units remain the same
+     */
+    updateCanvasResolution(): void;
+    /**
+     * Apply viewport → canvas transform
+     * Scale computed dynamically each frame
+     */
+    applyTransform(): void;
+    /**
+     * Current measured FPS (updated every second).
+     */
+    get FPS(): number;
+    private _loop;
+    update(): void;
+    /**
+     * Starts the RAF loop and begins emitting `"draw"` events.
+     *
+     * @throws If called in a non-browser environment or RAF is unavailable
+     */
+    start(): void;
+    /**
+     * Stops the RAF loop and halts drawing.
+     *
+     * @throws If called in a non-browser environment or RAF is unavailable
+     */
+    stop(): void;
+}
+/**
+ * Fixed or variable timestep ticker that emits a `"tick"` event with delta time (seconds).
+ *
+ * Supports RAF mode (`tickInterval = Infinity`) or fixed interval.
+ *
+ * @extends LeaEventEmitter<{ tick: [number]; error: [unknown] }>
+ *
+ * @example
+ * const ticker = new LeaTickerII(1000 / 60); // 60 Hz
+ * ticker.on("tick", (delta) => {
+ *   // update game state
+ * });
+ * ticker.start();
+ */
+declare class LeaTickerII extends LeaEventEmitter<{
+    tick: [number];
+    error: [unknown];
+}> {
+    #private;
+    setNow(now: number): void;
+    /**
+     * @type {NodeJS.Timeout}
+     */
+    private __intervalId;
+    private __lastTime;
+    /**
+     * @param tickInterval Interval in ms
+     */
+    constructor(tickInterval?: number);
+    /**
+     * Speed multiplier for delta time (for slow-motion / fast-forward).
+     */
+    speedHackDT: number;
+    /**
+     * Whether the ticker is using requestAnimationFrame (RAF) mode.
+     */
+    get isRaf(): boolean;
+    /**
+     * Tick interval in milliseconds.
+     * - Finite number = fixed timestep
+     * - `Infinity` = RAF / variable timestep
+     */
+    get tickInterval(): number;
+    set tickInterval(s: number);
+    /**
+     * Current time in milliseconds (monotonic).
+     */
+    now(): number;
+    private __tick;
+    /**
+     *
+     * @param {number} ms
+     * @returns
+     */
+    createTimeout(ms: number): LeaTimeout;
+    createTween(config: ConstructorParameters<typeof DeltaTweenII>[0], callback?: (change: number) => void): DeltaTweenII;
+    /**
+     * Starts the ticker loop.
+     */
+    start(): void;
+    /**
+     * Stops the ticker loop.
+     */
+    stop(): void;
+    /**
+     *
+     * @param {number} ms
+     * @param {number} offset
+     * @returns {number}
+     */
+    getSineMod(ms: number, offset?: number): number;
+}
+type LeaEntitySerializerEach<T extends Record<string, any>, K extends keyof T = keyof T> = [
+    K,
+    {
+        mapExport?: (value: T[K]) => any;
+        mapImport?: (value: any) => T[K];
+    }
+];
+type LeaEntitySerializer<T extends Record<string, any>> = {
+    [K in keyof T]: LeaEntitySerializerEach<T, K>;
+}[keyof T][];
+type LeaEntitySerializerArray<T extends Record<string, any>> = {
+    [K in keyof T]: LeaEntitySerializerEach<T, K>;
+}[keyof T][];
+type OrderedLeaEntitySerializer<T extends Record<string, any>, FirstKeys extends (keyof T)[]> = [
+    ...{
+        [I in keyof FirstKeys]: LeaEntitySerializerEach<T, FirstKeys[I]>;
+    },
+    ...LeaEntitySerializerArray<T>
+];
+declare namespace LeaSerializers {
+    function booleanExport(a: boolean): 0 | 1;
+    function booleanImport(a: 0 | 1): boolean;
+    function vec2Export(vec: Vector2): string;
+    function vec2Import(str: string): Vector2;
+    const booleanMap: {
+        mapExport: typeof booleanExport;
+        mapImport: typeof booleanImport;
+    };
+    function createRounder(maxDecimals: number): (num: number) => number;
+    function createLowPrecision(base?: number): {
+        mapExport(num: number): number;
+        mapImport(num: number): number;
+    };
+    function lightWeightRounder(n: number): number;
+    function createPercent(exportedMax?: number): {
+        mapExport(n: number): number;
+        mapImport(n: number): number;
+    };
+    function createLookup<T extends Record<string, any>>(record: T): {
+        mapExport: (key: string) => any;
+        mapImport: (value: any) => any;
+    };
+    function radToDeg(rad: number): number;
+    function degToRad(deg: number): number;
+    const angleRadToDeg: {
+        mapExport: typeof radToDeg;
+        mapImport: typeof degToRad;
+    };
+    function createLowPrecisionRadToDeg(base?: number): {
+        mapExport(n: number): number;
+        mapImport(n: number): number;
+    };
+}
+/**
+ * Abstract base class for all entities in a LEA scene.
+ *
+ * Provides event emission (`update`, `draw`, `error`), position, name, and z-order.
+ *
+ * @extends LeaEventEmitter<{ update: [number]; draw: [CanvasRenderingContext2D]; error: [unknown] }>
+ */
+declare abstract class LeaEntityII extends LeaEventEmitter<{
+    update: [number];
+    error: [unknown];
+    draw: [CanvasRenderingContext2D];
+}> {
+    /**
+     * Unique name of the entity (used for lookup and serialization).
+     */
+    name: string;
+    /**
+     * @type {number}
+     */
+    scaleRotate: number;
+    /**
+     * @type {number}
+     */
+    scale: number;
+    /**
+     *  @param {string} name
+     *  @param {number} [x]
+     *  @param {number} [y]
+     */
+    constructor(name: string, x?: number, y?: number);
+    arraySerializeMap?: LeaEntitySerializer<any>;
+    autoTranslate: boolean;
+    /**
+     * Z-order for draw sorting (higher = drawn later / on top).
+     */
+    z: number;
+    private ___pos;
+    /**
+     * @type {(keyof this)[]}
+     */
+    nonSerializableProperties: (keyof this)[];
+    /**
+     * @type {(keyof this)[]}
+     */
+    forceSerializableProperties: (keyof this)[];
+    /**
+     * Current position (center point).
+     */
+    get pos(): Vector2;
+    /**
+     * X coordinate (center).
+     */
+    get x(): number;
+    /**
+     * Y coordinate (center).
+     */
+    get y(): number;
+    set x(s: number);
+    set y(s: number);
+    /**
+     * Update entity.
+     */
+    handleUpdate(delta: number): void;
+    /**
+     * Called once per tick with delta time (seconds).
+     *
+     * @param delta - Time since last tick in seconds
+     */
+    abstract update(_delta: number): void;
+    /**
+     * Draw entity.
+     */
+    handleDraw(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Called once per frame to draw the entity.
+     *
+     * The context is already translated to the entity's position if `autoTranslate` is true.
+     *
+     * @param ctx - The 2D rendering context
+     */
+    abstract draw?(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Serializes the entity to a plain object (for save/load).
+     *
+     * Excludes internal properties and respects `nonSerializableProperties`.
+     *
+     * @returns Serializable data
+     */
+    serialize(): any;
+    /**
+     * Converts a world position to local space relative to this entity.
+     *
+     * @param worldVec - World position
+     * @returns Local position
+     */
+    toLocal(worldVec: Vector2): Vector2;
+    /**
+     * Converts a local position to world space.
+     *
+     * @param localVec - Local position
+     * @returns World position
+     */
+    toWorld(localVec: Vector2): Vector2;
+    deserializeArray(snapshot: any[]): any;
+    static deserializeArray(map: LeaEntityII["arraySerializeMap"], snapshot: any[]): any;
+}
+/**
+ * Container for a collection of entities, handling update/draw loops and z-order sorting.
+ *
+ * @extends LeaEventEmitter<{ update: [number]; draw: [CanvasRenderingContext2D] }>
+ */
+declare class LeaSceneII extends LeaEventEmitter<{
+    update: [number];
+    draw: [CanvasRenderingContext2D];
+}> {
+    /**
+     * Unique name of the scene.
+     */
+    name: string;
+    /**
+     * Map of entities by name.
+     */
+    entities: Map<string, LeaEntityII>;
+    /**
+     * Whether updates and drawing are paused.
+     */
+    paused: boolean;
+    constructor(name: string);
+    /**
+     * Updates all non-paused entities in the scene.
+     *
+     * @param delta - Time since last update in seconds
+     */
+    handleUpdate(delta: number): void;
+    /**
+     * Draws all entities in z-order (higher z = drawn later).
+     *
+     * @param ctx - The 2D rendering context
+     */
+    handleDraw(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Adds an entity to the scene.
+     *
+     * @param entity - The entity to add
+     * @throws If the entity has no name
+     */
+    addEntity(entity: any): void;
+    /**
+     * Removes an entity from the scene by name.
+     *
+     * @param entity - The entity to remove
+     */
+    removeEntity(entity: any): void;
+    /**
+     * Retrieves an entity by name.
+     *
+     * @param name - The name of the entity
+     * @returns The entity, or undefined if not found
+     */
+    getEntity(name: string): LeaEntityII;
+}
+/**
+ * Top-level game manager that owns scenes and a shared ticker.
+ *
+ * Coordinates updates across all scenes and provides viewport utilities.
+ */
+declare class LeaGameII {
+    /**
+     * Map of scenes by name.
+     */
+    scenes: Map<string, LeaSceneII>;
+    /**
+     * The shared ticker driving updates.
+     */
+    ticker: LeaTickerII;
+    /**
+     * Center X of the viewport (width / 2).
+     */
+    get centerX(): number;
+    /**
+     * Center Y of the viewport (height / 2).
+     */
+    get centerY(): number;
+    get left(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    /**
+     * Logical viewport width.
+     */
+    width: number;
+    /**
+     * Logical viewport height.
+     */
+    height: number;
+    /**
+     * @param {number} width
+     * @param {number} height
+     * @param {number} tickInterval
+     */
+    constructor(width: number, height: number, tickInterval?: number);
+    /**
+     * Adds a scene to the game.
+     *
+     * @param scene - The scene to add
+     * @throws If the scene has no name
+     */
+    addScene(scene: LeaSceneII): void;
+    /**
+     * Removes a scene from the game.
+     *
+     * @param scene - The scene to remove
+     */
+    removeScene(scene: LeaSceneII): void;
+    /**
+     * Current time in milliseconds (from ticker).
+     */
+    now(): number;
+    /**
+     * Starts the ticker loop (begins emitting "tick" events).
+     */
+    start(): void;
+    /**
+     * Stops the ticker loop.
+     */
+    stop(): void;
+}
+/**
+ * @fileoverview Basic math & easing utilities
+ */
+declare const LeaUtilsII: {
+    /**
+     * Linear interpolation
+     *
+     * @param {number} a Start value
+     * @param {number} b End value
+     * @param {number} t Progress (0–1)
+     * @returns {number}
+     */
+    lerp(a: number, b: number, t: number): number;
+    /**
+     * Clamp a value between min and max
+     *
+     * @param {number} v
+     * @param {number} min
+     * @param {number} max
+     * @returns {number}
+     */
+    clamp(v: number, min: number, max: number): number;
+    /**
+     * Clamp a value between 0 and 1
+     *
+     * @param {number} v
+     * @returns {number}
+     */
+    clamp01(v: number): number;
+    /**
+     * Linear easing
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeLinear(t: number): number;
+    /**
+     * Quadratic ease-in
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInQuad(t: number): number;
+    /**
+     * Quadratic ease-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeOutQuad(t: number): number;
+    /**
+     * Quadratic ease-in-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInOutQuad(t: number): number;
+    /**
+     * Sine ease-in
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInSine(t: number): number;
+    /**
+     * Sine ease-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeOutSine(t: number): number;
+    /**
+     * Sine ease-in-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInOutSine(t: number): number;
+    /**
+     * Expo ease-in
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInExpo(t: number): number;
+    /**
+     * Expo ease-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeOutExpo(t: number): number;
+    /**
+     * Expo ease-in-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInOutExpo(t: number): number;
+    /**
+     * Smoothstep easing
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    smoothstep(t: number): number;
+    /**
+     *
+     * @param {number} a
+     * @param {number} b
+     */
+    randomLerp(a: number, b: number): number;
+    /**
+     *
+     * @param {number} a
+     * @param {number} b
+     * @returns
+     */
+    randomInt(a: number, b: number): number;
+    /**
+     * @template T
+     * @param {T[]} arr
+     * @returns {T}
+     */
+    randomArrayValue<T>(arr: T[]): T;
+    /**
+     * Create a real cubic-bezier easing function
+     * (same behavior as CSS cubic-bezier)
+     *
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @returns {(t:number)=>number}
+     */
+    createBezier(x1: number, y1: number, x2: number, y2: number): (t: number) => number;
+    /**
+     *
+     * @param  {...number} values
+     * @returns
+     */
+    lengthSquared(...values: number[]): number;
+    /**
+     * Normalize an angle in radians to [0, 2π)
+     * @param {number} rad
+     * @returns {number}
+     */
+    normalizeRad(rad: number): number;
+    /**
+     * Convert a Y-down canvas angle to standard mathematical radian coordinates (Y-up)
+     * @param {number} rad
+     * @returns {number}
+     */
+    angleInvertY(rad: number): number;
+    /**
+     * Convert degrees to radians, flipping Y-axis for canvas (top-left origin)
+     * @param {number} deg
+     * @returns {number}
+     */
+    degToRadFlipY(deg: number): number;
+    /**
+     * Determines the **minimal angular rotation direction** along a unit circle
+     * Returns 1 if clockwise is the shorter path, -1 if counter-clockwise is shorter
+     * @param {number} fromRad - starting angle in radians
+     * @param {number} toRad - target angle in radians
+     * @returns {1 | -1}
+     */
+    minimalAngularDirection(fromRad: number, toRad: number): 1 | -1;
+};
+/**
+ * @fileoverview Delta-based tween for a single numeric change
+ */
+declare class DeltaTweenII extends LeaEventEmitter<{
+    delta: number[];
+    finish: void[];
+}> {
+    constructor({ delta, ms, easing, }: {
+        delta: number;
+        ms: number;
+        easing?: (t: number) => number;
+    });
+    delta: number;
+    duration: number;
+    elapsed: number;
+    lastValue: number;
+    finished: boolean;
+    easing: (t: number) => number;
+    /**
+     * Advance tween by delta time
+     */
+    update(delta: number): void;
+}
+/**
+ * Rectangular entity with centered position, width, height, and basic AABB collision.
+ *
+ * Automatically handles translation and rotation for drawing if needed.
+ *
+ * @extends LeaEntityII
+ */
+declare abstract class RectLeaEntity extends LeaEntityII {
+    /**
+     * @param {string} name
+     * @param {number} x Center X
+     * @param {number} y Center Y
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(name: string, x?: number, y?: number, width?: number, height?: number);
+    /**
+     * Width of the rectangle (centered on x).
+     */
+    width: number;
+    /**
+     * Height of the rectangle (centered on y).
+     */
+    height: number;
+    /**
+     * Left edge of the bounding box.
+     */
+    get left(): number;
+    set left(val: number);
+    /**
+     * Right edge of the bounding box.
+     */
+    get right(): number;
+    set right(val: number);
+    /**
+     * Top edge of the bounding box.
+     */
+    get top(): number;
+    set top(val: number);
+    /**
+     * Bottom edge of the bounding box.
+     */
+    get bottom(): number;
+    set bottom(val: number);
+    get lx(): number;
+    get ly(): number;
+    get lleft(): number;
+    get lright(): number;
+    get ltop(): number;
+    get lbottom(): number;
+    /**
+     * Checks for axis-aligned bounding box collision with another rectangular entity.
+     *
+     * @param other - The other entity to check against
+     * @returns `true` if the bounding boxes overlap
+     */
+    isCollidingWith(other: RectLeaEntity): boolean;
+    /**
+     * Default fill color for the rectangle (used in base draw implementation).
+     */
+    color: string;
+    abstract update(_delta: number): void;
+    /**
+     * Draws a filled rectangle centered on the entity's position.
+     *
+     * Subclasses should override or call `super.draw(ctx)` if extending.
+     *
+     * @param ctx - The 2D rendering context
+     */
+    draw(ctx: CanvasRenderingContext2D): void;
+}
+declare class LeaTimeout extends LeaEventEmitter<{
+    finish: [void];
+}> {
+    duration: number;
+    ticker: LeaTickerII;
+    elapsed: number;
+    finished: boolean;
+    _resolve: (value?: unknown) => void;
+    promise: Promise<unknown>;
+    _timeoutId: NodeJS.Timeout;
+    /**
+     * @param {number} duration Duration in milliseconds
+     * @param {LeaTickerII} ticker Optional ticker to drive the timeout
+     */
+    constructor(duration: number, ticker?: LeaTickerII);
+    update(delta?: number): void;
+    finish(): void;
+    /**
+     * Start the timeout manually if no ticker is provided
+     */
+    start(): this;
+    /**
+     * Cancel the timeout
+     */
+    cancel(): void;
+    then<TResult1 = unknown, TResult2 = never>(onfulfilled?: ((value: unknown) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    /**
+     * @type {Promise<void>['then']}
+     */
+    after<TResult1 = unknown, TResult2 = never>(onfulfilled?: ((value: unknown) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+}
+/**
+ * 2D Vector class similar to Godot's Vector2
+ */
+declare class Vector2 {
+    /**
+     * Creates a new Vector2
+     * @param {number} x
+     * @param {number} y
+     */
+    constructor(x?: number, y?: number);
+    x: number;
+    y: number;
+    toJSON(): {
+        x: number;
+        y: number;
+        vec2: boolean;
+    };
+    /**
+     *
+     * @param {any} data
+     */
+    static isVec2(data: any): boolean;
+    /**
+     *
+     * @param {any} data
+     */
+    static fromSerialized(data: any): Vector2;
+    /**
+     * Rotate vector by angle (radians) around origin
+     * @param {number} angle
+     */
+    rotate(angle: number): Vector2;
+    /**
+     * Returns a new Vector2 representing a unit vector pointing in the given angle (radians)
+     * @param {number} rad
+     * @returns {Vector2}
+     */
+    static from(rad: number): Vector2;
+    /**
+     * Returns the angle of the vector relative to the positive X-axis in radians
+     * @returns {number}
+     */
+    get angle(): number;
+    /**
+     * Returns the length (magnitude) of the vector
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     * Returns the squared length (more efficient)
+     * @returns {number}
+     */
+    get lengthSquared(): number;
+    /**
+     * Returns a normalized vector (length = 1)
+     * @returns {Vector2}
+     */
+    normalized(): Vector2;
+    project(other: Vector2): Vector2;
+    /**
+     * Reflects a normalized vector (length = 1)
+     * @returns {Vector2}
+     */
+    reflect(normal: Vector2): Vector2;
+    /**
+     * Alignment
+     * Dot product with another vector (normalized)
+     * @param {Vector2} other
+     * @returns {number} -1 .. 1 if vectors are normalized
+     */
+    dotNormalized(other: Vector2): number;
+    /**
+     *
+     * @param {Vector2} other
+     * @returns
+     */
+    lengthSquaredTo(other: Vector2): number;
+    /**
+     * Projection
+     * True dot product including magnitude
+     * @param {Vector2} other
+     * @returns {number}
+     */
+    dot(other: Vector2): number;
+    /**
+     * Distance to another vector
+     * @param {Vector2} other
+     * @returns {number}
+     */
+    distanceTo(other: Vector2): number;
+    /**
+     * Distance to another vector
+     * @param {Vector2} other
+     * @returns {number}
+     */
+    distanceToCheap(other: Vector2): number;
+    /**
+     * Returns a vector pointing from this vector to another
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    directionTo(other: Vector2): Vector2;
+    /**
+     * Adds another vector
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    add(other: Vector2): Vector2;
+    /**
+     * Adds another vector
+     * @param {number} raw
+     * @returns {Vector2}
+     */
+    addRaw(raw: number): Vector2;
+    /**
+     * Overwrite instance
+     * @param {Vector2} newVec
+     */
+    overwite(newVec: Vector2): void;
+    /**
+     * Subtracts another vector
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    subtract(other: Vector2): Vector2;
+    /**
+     * Scales the vector by a scalar
+     * @param {number} scalar
+     * @returns {Vector2}
+     */
+    scale(scalar: number): Vector2;
+    /**
+     * Returns a string representation
+     * @returns {string}
+     */
+    toString(): string;
+    /**
+     * Clones a vector.
+     * @returns {Vector2}
+     */
+    clone(): Vector2;
+}
+/**
+ *
+ * @param {string} col
+ */
+declare function getNormalizedColor(col: string): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ *
+ * @param {{ r: number; g: number; b: number; a:number }} col
+ */
+declare function colToRGBA(col: {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}): string;
+/**
+ * Extract numeric RGBA from ctx.fillStyle
+ * Supports hex (#rgb, #rrggbb) and rgb(a)
+ * @param {string} fillStyle
+ * @returns {{r:number, g:number, b:number, a:number}}
+ */
+declare function parseFillStyle(fillStyle: string): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ *
+ * @param {string} str
+ * @param {{ r?: number; g?: number; b?: number; a?: number }} param1
+ * @returns {string}
+ */
+declare function editRGBA(str: string, { r, g, b, a }?: {
+    r?: number;
+    g?: number;
+    b?: number;
+    a?: number;
+}): string;
+/**
+ * Scales a 2D coordinate relative to an origin.
+ *
+ * @param {number} absoluteCoord - The original coordinate.
+ * @param {number} scale - The scale factor.
+ * @param {number} origin - The origin point for scaling.
+ * @returns {number} - The new scaled coordinate.
+ */
+declare function scaleCoord(absoluteCoord: number, scale: number, origin: number): number;
+declare function getEnvironment(): "web" | "node" | "unknown";
+declare const ENVIRONMENT: "web" | "node" | "unknown";
+declare const isNode: boolean;
+declare const isWeb: boolean;
+declare class LiaAudio {
+    static unlock(): void;
+    /**
+     * @type {AudioContext}
+     */
+    static audioCtx: AudioContext;
+    static masterGain: GainNode;
+    static musicGain: GainNode;
+    static sfxGain: GainNode;
+    static get SFX_VOLUME(): number;
+    static get MUSIC_VOLUME(): number;
+    static get VOLUME(): number;
+    static set SFX_VOLUME(n: number);
+    static set MUSIC_VOLUME(n: number);
+    static set VOLUME(n: number);
+    /**
+     *
+     * @param {number} note
+     * @returns
+     */
+    static noteToHz(note: number): number;
+    static tuningFreq: number;
+    /**
+     * @type {Map<string, AudioBuffer>}
+     */
+    static audioBufferCache: Map<string, AudioBuffer>;
+    /**
+     * @type {Map<number, { source: LiaAudioSrc, gain: GainNode }>}
+     */
+    static loops: Map<number, {
+        source: LiaAudioSrc;
+        gain: GainNode;
+    }>;
+    /**
+     * @type {Map<string, { source: LiaAudioSrc, gain: GainNode }>}
+     */
+    static sfsx: Map<string, {
+        source: LiaAudioSrc;
+        gain: GainNode;
+    }>;
+    static loopIdCounter: number;
+    static CACHE_NAME: string;
+    /**
+     * Preload and decode audio buffer
+     * @param {string} path
+     * @returns {Promise<AudioBuffer>}
+     */
+    static preLoad(path: string): Promise<AudioBuffer>;
+    /**
+     * @param {string} path
+     * @returns {Promise<Response>}
+     */
+    static getOnlyDownloadedCache(path: string): Promise<Response>;
+    /**
+     * Get AudioBuffer (returns null if not yet loaded)
+     * @param {string} path
+     * @returns {AudioBuffer|null}
+     */
+    static getCached(path: string): AudioBuffer | null;
+    /**
+     * Play SFX once with optional volume
+     * @param {string} path
+     * @param {number} volume
+     * @param {number | null} speed default to random
+     */
+    static playSound(path: string, volume?: number, speed?: number | null, override?: boolean): Promise<void>;
+    /**
+     * Play looping SFX and return loop id
+     * @param {string} path
+     * @param {number} volume
+     * @param {Object} [param2={}]
+     * @param {number} [param2.loopStart=0]
+     * @param {null | number} [param2.loopEnd=null]
+     * @param {boolean} [param2.exclusive=true]
+     * @param {number} [param2.skipMS=0]
+     * @returns {Promise<number | undefined>}
+     */
+    static playLoop(path: string, volume?: number, { loopStart, loopEnd, exclusive, skipMS, }?: {
+        loopStart?: number;
+        loopEnd?: null | number;
+        exclusive?: boolean;
+        skipMS?: number;
+    }): Promise<number | undefined>;
+    /**
+     * Stop a loop by id
+     * @param {number} id
+     */
+    static stopLoop(id: number): void;
+    /**
+     * Create a LiaAudioSrc from a file path without playing it.
+     * @param {string} path - audio file path
+     * @param {Object} [options={}]
+     * @param {number} [options.volume=1]
+     * @param {number} [options.speed=1]
+     * @param {boolean} [options.loop=false]
+     * @param {number} [options.loopStart=0]
+     * @param {number|null} [options.loopEnd=null]
+     * @param {boolean} [options.isMusic]
+     * @returns {Promise<LiaAudioSrc|null>}
+     */
+    static createLiaSource(path: string, { volume, speed, loop, loopStart, loopEnd, isMusic, gain: parentGain, }?: {
+        volume?: number;
+        speed?: number;
+        loop?: boolean;
+        loopStart?: number;
+        loopEnd?: number | null;
+        isMusic?: boolean;
+        gain?: GainNode;
+    }): Promise<LiaAudioSrc | null>;
+}
+declare const NOTE_NAMES: readonly ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+type NOTE_NAME = (typeof NOTE_NAMES)[number];
+declare function isNote(note: string): note is NOTE_NAME;
+/**
+ * High-level AudioBufferSourceNode replacement with play/pause, fades, speed, and strict AudioNode interface.
+ * @implements {AudioNode}
+ */
+declare class LiaAudioSrc {
+    numberOfInputs: number;
+    numberOfOutputs: number;
+    /**
+     * @param {AudioBuffer} buffer
+     * @param {AudioContext} [context=LiaSfx.audioCtx]
+     */
+    constructor(buffer: AudioBuffer, context?: AudioContext);
+    channelCount: number;
+    channelCountMode: string;
+    channelInterpretation: string;
+    onended: () => any;
+    /**
+     * @type {AudioBufferSourceNode|null}
+     */
+    source: AudioBufferSourceNode | null;
+    /**
+     * @type {AudioBuffer}
+     */
+    buffer: AudioBuffer;
+    /**
+     * @type {AudioContext}
+     */
+    context: AudioContext;
+    _createSource(): AudioBufferSourceNode;
+    /**
+     * Start playback
+     * @param {Object} [options]
+     * @param {number} [options.fadeIn=0] - seconds to fade in
+     * @param {number} [options.offset=null] - start offset in seconds
+     */
+    play({ fadeIn, offset, }?: {
+        fadeIn?: number;
+        offset?: number;
+    }): void;
+    /**
+     * Start playback identical to AudioBufferSourceNode.start()
+     * @param {number} [when=0] - seconds from context.currentTime to start
+     * @param {number} [offset=0] - offset in seconds into the buffer
+     * @param {number} [duration] - how long to play in seconds
+     */
+    start(when: number, offset: number, duration: number): void;
+    /**
+     * Pause playback
+     * @param {Object} [options]
+     * @param {number} [options.fadeOut=0] - seconds to fade out
+     */
+    pause({ fadeOut }?: {
+        fadeOut?: number;
+    }): void;
+    /**
+     * Get playback elapsed time in milliseconds
+     * @returns {number}
+     */
+    getElapsed(): number;
+    /**
+     * Set playback speed
+     * @param {number} rate
+     */
+    setSpeed(rate: number): void;
+    /**
+     * Set loop mode
+     * @param {boolean} loop
+     */
+    setLoop(loop?: boolean): void;
+    loop: boolean;
+    playbackRate: number;
+    startTime: number;
+    /**
+     * @type {GainNode}
+     */
+    tempGain: GainNode;
+    /**
+     * Connect node to AudioNode or AudioParam
+     * @param {AudioNode|AudioParam} destination
+     * @param {number} [output=0]
+     * @param {number} [input=0]
+     * @returns {AudioNode|undefined}
+     */
+    connect(destination: AudioNode | AudioParam, output?: number, input?: number): AudioNode | undefined;
+    /**
+     * Disconnect node from AudioNode or AudioParam
+     * @param {AudioNode} [destinationOrOutput]
+     * @param {number} [output]
+     * @param {number} [input]
+     */
+    disconnect(destinationOrOutput: AudioNode, output: number, input: number): void;
+    output: GainNode;
+    /**
+     * Stop playback immediately or at optional future time
+     * @param {number} [when=0] - seconds from now to stop
+     */
+    stop(when?: number): void;
+    pauseTime: number;
+    isPlaying: boolean;
+    notIndependent: boolean;
+    /** @type {number} */
+    loopStart: number;
+    /** @type {number} */
+    loopEnd: number;
+}
+interface SFXConfig {
+    osc: {
+        enabled: boolean;
+        type: "sine" | "square" | "sawtooth" | "triangle";
+        freq: number;
+        detune: number;
+    };
+    noise: {
+        enabled: boolean;
+        level: number;
+    };
+    ampEnv: {
+        attack: number;
+        decay: number;
+        sustain: number;
+        release: number;
+        volume: number;
+    };
+    pitchEnv: {
+        amount: number;
+        decay: number;
+    };
+    filter: {
+        enabled: boolean;
+        type: "lowpass" | "highpass" | "bandpass" | "notch";
+        freq: number;
+        Q: number;
+        envAmount: number;
+        decay: number;
+    };
+    lfo: {
+        enabled: boolean;
+        target: "freq" | "gain" | "filter";
+        rate: number;
+        depth: number;
+    };
+    duration: number;
+}
+/**
+ * @type {SFXConfig}
+ */
+declare const defaultSFXConfig: SFXConfig;
+declare class LiaOscSFX {
+    /**
+     *
+     * @param {Partial<SFXConfig>} config
+     */
+    constructor(config?: Partial<SFXConfig>);
+    ctx: typeof LiaAudio.audioCtx;
+    /**
+     * @type {SFXConfig}
+     */
+    cfg: SFXConfig;
+    play(outputGain?: GainNode): void;
+    /** @returns {SFXConfig} */
+    getConfig(): SFXConfig;
+    /** @param {Partial<SFXConfig>} patch */
+    setConfig(patch: Partial<SFXConfig>): this;
+    getKey<K extends keyof SFXConfig>(key: K): SFXConfig[K];
+    setKey<K extends keyof SFXConfig>(key: K, value: Partial<SFXConfig[K]>): this;
+    /** @param {SFXConfig['osc']['freq']} freq */
+    setFreq(freq: SFXConfig["osc"]["freq"]): this;
+    /** @param {SFXConfig['osc']['type']} type */
+    setWave(type: SFXConfig["osc"]["type"]): this;
+    /** @param {SFXConfig['ampEnv']['volume']} volume */
+    setVolume(volume: SFXConfig["ampEnv"]["volume"]): this;
+    /** @param {SFXConfig['ampEnv']['attack']} attack @param {SFXConfig['ampEnv']['decay']} decay @param {SFXConfig['ampEnv']['sustain']} sustain @param {SFXConfig['ampEnv']['release']} release */
+    setAmpEnv(attack: SFXConfig["ampEnv"]["attack"], decay: SFXConfig["ampEnv"]["decay"], sustain: SFXConfig["ampEnv"]["sustain"], release: SFXConfig["ampEnv"]["release"]): this;
+    /** @param {SFXConfig['pitchEnv']['amount']} amount @param {SFXConfig['pitchEnv']['decay']} decay */
+    setPitchEnv(amount: SFXConfig["pitchEnv"]["amount"], decay: SFXConfig["pitchEnv"]["decay"]): this;
+    /** @param {SFXConfig['noise']['enabled']} enabled */
+    setNoiseEnabled(enabled: SFXConfig["noise"]["enabled"]): this;
+    /** @param {SFXConfig['noise']['level']} level */
+    setNoiseLevel(level: SFXConfig["noise"]["level"]): this;
+    /** @param {SFXConfig['filter']['enabled']} enabled */
+    setFilterEnabled(enabled: SFXConfig["filter"]["enabled"]): this;
+    setFilter(type: SFXConfig["filter"]["type"], freq: SFXConfig["filter"]["freq"], Q: SFXConfig["filter"]["Q"]): this;
+    setLFOEnabled(enabled: SFXConfig["lfo"]["enabled"]): this;
+    /** @param {SFXConfig['lfo']['target']} target @param {SFXConfig['lfo']['rate']} rate @param {SFXConfig['lfo']['depth']} depth */
+    setLFO(target: SFXConfig["lfo"]["target"], rate: SFXConfig["lfo"]["rate"], depth: SFXConfig["lfo"]["depth"]): this;
+    /** @param {SFXConfig['duration']} duration */
+    setDuration(duration: SFXConfig["duration"]): this;
+    clone(): LiaOscSFX;
+}
+declare const sfxUIClick: LiaOscSFX;
+declare const sfxUIHover: LiaOscSFX;
+declare const sfxJump: LiaOscSFX;
+declare const sfxLaser: LiaOscSFX;
+declare const sfxHit: LiaOscSFX;
+declare const LiaSFXMap: Map<string, LiaOscSFX>;
+declare function shortUID(length?: number): string;
+declare function tinyUID(length?: number): string;
+/**
+ * @template EventMap
+ * Default event structure
+ */
+type DefaultWSE<EventMap> = {
+    open: void;
+    close: void;
+    error: Error;
+    message: EventMap[keyof EventMap];
+    key: {
+        key: string;
+        mode: 1 | 2;
+    };
+};
+/**
+ * Memory-based client for in-process IPC
+ */
+declare class GEmitterMemory<Events extends DefaultWSE<Events>> {
+    private peer;
+    private key;
+    private events;
+    mbAcc: number;
+    private connected;
+    constructor();
+    /** Connect to a peer client */
+    connect(peer?: GEmitterMemory<Events>): void;
+    /** Is connected */
+    isConnected(): boolean;
+    /** Add event listener */
+    on<K extends keyof Events>(event: K, listener: (payload: Events[K]) => void): void;
+    /** Remove event listener */
+    off<K extends keyof Events>(event: K, listener: (payload: Events[K]) => void): void;
+    /** Emit event internally */
+    private _emit;
+    /** Send message to peer */
+    send<K extends keyof Events>(event: K, payload: Events[K]): void;
+    /** Receive message from peer */
+    private _receive;
+    /** Disconnect */
+    close(): void;
+    /** Get the client's key */
+    getKey(): string;
+}
+/** Cross-browser UUIDv4 generator */
+declare function generateUUID(): string;
+declare function setAnimInterval(callback: () => void): {
+    clear: () => boolean;
+};
+type Side = "left" | "right" | "top" | "bottom";
+interface RayHit {
+    side: Side;
+    t: number;
+}
+interface RaycastResult extends RayHit {
+    avoidAngle: number;
+}
+/**
+ * Core: Raycast to single rectangle
+ */
+declare function getRayHit(x0: number, y0: number, w: number, h: number, angle: number): RayHit | null;
+declare function getAvoidAngle(angle: number, side: Side): number;
+/**
+ Full reusable raycast with avoidance
+*/
+declare function raycastAvoid(x0: number, y0: number, w: number, h: number, angle: number): RaycastResult | null;
+declare function isMobile(): boolean;
+declare const isInitiallyMobile: boolean;
+
+type LEA_DefaultWSE<EventMap> = DefaultWSE<EventMap>;
+type LEA_DeltaTweenII = DeltaTweenII;
+declare const LEA_DeltaTweenII: typeof DeltaTweenII;
+declare const LEA_ENVIRONMENT: typeof ENVIRONMENT;
+type LEA_GEmitterMemory<Events extends DefaultWSE<Events>> = GEmitterMemory<Events>;
+declare const LEA_GEmitterMemory: typeof GEmitterMemory;
+type LEA_LeaEntityII = LeaEntityII;
+declare const LEA_LeaEntityII: typeof LeaEntityII;
+type LEA_LeaEntitySerializer<T extends Record<string, any>> = LeaEntitySerializer<T>;
+type LEA_LeaEntitySerializerArray<T extends Record<string, any>> = LeaEntitySerializerArray<T>;
+type LEA_LeaEntitySerializerEach<T extends Record<string, any>, K extends keyof T = keyof T> = LeaEntitySerializerEach<T, K>;
+type LEA_LeaEventEmitter<Events extends Record<string, any[]>> = LeaEventEmitter<Events>;
+declare const LEA_LeaEventEmitter: typeof LeaEventEmitter;
+type LEA_LeaGameII = LeaGameII;
+declare const LEA_LeaGameII: typeof LeaGameII;
+type LEA_LeaRendererII = LeaRendererII;
+declare const LEA_LeaRendererII: typeof LeaRendererII;
+type LEA_LeaSceneII = LeaSceneII;
+declare const LEA_LeaSceneII: typeof LeaSceneII;
+declare const LEA_LeaSerializers: typeof LeaSerializers;
+type LEA_LeaTickerII = LeaTickerII;
+declare const LEA_LeaTickerII: typeof LeaTickerII;
+type LEA_LeaTimeout = LeaTimeout;
+declare const LEA_LeaTimeout: typeof LeaTimeout;
+declare const LEA_LeaUtilsII: typeof LeaUtilsII;
+type LEA_LiaAudio = LiaAudio;
+declare const LEA_LiaAudio: typeof LiaAudio;
+type LEA_LiaAudioSrc = LiaAudioSrc;
+declare const LEA_LiaAudioSrc: typeof LiaAudioSrc;
+type LEA_LiaOscSFX = LiaOscSFX;
+declare const LEA_LiaOscSFX: typeof LiaOscSFX;
+declare const LEA_LiaSFXMap: typeof LiaSFXMap;
+type LEA_Listener<T extends any[] = any[]> = Listener<T>;
+type LEA_NOTE_NAME = NOTE_NAME;
+declare const LEA_NOTE_NAMES: typeof NOTE_NAMES;
+type LEA_OrderedLeaEntitySerializer<T extends Record<string, any>, FirstKeys extends (keyof T)[]> = OrderedLeaEntitySerializer<T, FirstKeys>;
+type LEA_RayHit = RayHit;
+type LEA_RaycastResult = RaycastResult;
+type LEA_RectLeaEntity = RectLeaEntity;
+declare const LEA_RectLeaEntity: typeof RectLeaEntity;
+type LEA_SFXConfig = SFXConfig;
+type LEA_Side = Side;
+type LEA_Vector2 = Vector2;
+declare const LEA_Vector2: typeof Vector2;
+declare const LEA_colToRGBA: typeof colToRGBA;
+declare const LEA_defaultSFXConfig: typeof defaultSFXConfig;
+declare const LEA_editRGBA: typeof editRGBA;
+declare const LEA_generateUUID: typeof generateUUID;
+declare const LEA_getAvoidAngle: typeof getAvoidAngle;
+declare const LEA_getEnvironment: typeof getEnvironment;
+declare const LEA_getNormalizedColor: typeof getNormalizedColor;
+declare const LEA_getRayHit: typeof getRayHit;
+declare const LEA_isInitiallyMobile: typeof isInitiallyMobile;
+declare const LEA_isMobile: typeof isMobile;
+declare const LEA_isNode: typeof isNode;
+declare const LEA_isNote: typeof isNote;
+declare const LEA_isWeb: typeof isWeb;
+declare const LEA_parseFillStyle: typeof parseFillStyle;
+declare const LEA_raycastAvoid: typeof raycastAvoid;
+declare const LEA_scaleCoord: typeof scaleCoord;
+declare const LEA_setAnimInterval: typeof setAnimInterval;
+declare const LEA_sfxHit: typeof sfxHit;
+declare const LEA_sfxJump: typeof sfxJump;
+declare const LEA_sfxLaser: typeof sfxLaser;
+declare const LEA_sfxUIClick: typeof sfxUIClick;
+declare const LEA_sfxUIHover: typeof sfxUIHover;
+declare const LEA_shortUID: typeof shortUID;
+declare const LEA_tinyUID: typeof tinyUID;
+declare namespace LEA {
+  export { type LEA_DefaultWSE as DefaultWSE, LEA_DeltaTweenII as DeltaTweenII, LEA_ENVIRONMENT as ENVIRONMENT, LEA_GEmitterMemory as GEmitterMemory, LEA_LeaEntityII as LeaEntityII, type LEA_LeaEntitySerializer as LeaEntitySerializer, type LEA_LeaEntitySerializerArray as LeaEntitySerializerArray, type LEA_LeaEntitySerializerEach as LeaEntitySerializerEach, LEA_LeaEventEmitter as LeaEventEmitter, LEA_LeaGameII as LeaGameII, LEA_LeaRendererII as LeaRendererII, LEA_LeaSceneII as LeaSceneII, LEA_LeaSerializers as LeaSerializers, LEA_LeaTickerII as LeaTickerII, LEA_LeaTimeout as LeaTimeout, LEA_LeaUtilsII as LeaUtilsII, LEA_LiaAudio as LiaAudio, LEA_LiaAudioSrc as LiaAudioSrc, LEA_LiaOscSFX as LiaOscSFX, LEA_LiaSFXMap as LiaSFXMap, type LEA_Listener as Listener, type LEA_NOTE_NAME as NOTE_NAME, LEA_NOTE_NAMES as NOTE_NAMES, type LEA_OrderedLeaEntitySerializer as OrderedLeaEntitySerializer, type LEA_RayHit as RayHit, type LEA_RaycastResult as RaycastResult, LEA_RectLeaEntity as RectLeaEntity, type LEA_SFXConfig as SFXConfig, type LEA_Side as Side, LEA_Vector2 as Vector2, LEA_colToRGBA as colToRGBA, LEA_defaultSFXConfig as defaultSFXConfig, LEA_editRGBA as editRGBA, LEA_generateUUID as generateUUID, LEA_getAvoidAngle as getAvoidAngle, LEA_getEnvironment as getEnvironment, LEA_getNormalizedColor as getNormalizedColor, LEA_getRayHit as getRayHit, LEA_isInitiallyMobile as isInitiallyMobile, LEA_isMobile as isMobile, LEA_isNode as isNode, LEA_isNote as isNote, LEA_isWeb as isWeb, LEA_parseFillStyle as parseFillStyle, LEA_raycastAvoid as raycastAvoid, LEA_scaleCoord as scaleCoord, LEA_setAnimInterval as setAnimInterval, LEA_sfxHit as sfxHit, LEA_sfxJump as sfxJump, LEA_sfxLaser as sfxLaser, LEA_sfxUIClick as sfxUIClick, LEA_sfxUIHover as sfxUIHover, LEA_shortUID as shortUID, LEA_tinyUID as tinyUID };
+}
+
+/**
+ * Base props interface that every Kayla component can receive.
+ *
+ * Extend this when defining custom component props:
+ *
+ * ```ts
+ * interface MyProps extends FCProps {
+ *   speed: number;
+ * }
+ * ```
+ */
+type FCProps = {
+    key?: string;
+    children?: KaylaElement<any>[];
+    ref?: KaylaRef<KaylaInternals.KaylaRectEntity>;
+    exportsRef?: KaylaRef<KaylaExports<any>>;
+} & Record<string, unknown>;
+type FCExports = {} & Record<string, KaylaExportables>;
+interface FC<Props extends FCProps = FCProps, Exports extends FCExports = FCExports> {
+    (props: Props & {
+        ref?: KaylaElementRef;
+        exportsRef?: KaylaRef<KaylaExports<Exports>>;
+    }): KaylaElement<any>[] | KaylaElement<any> | void;
+    displayName?: string | undefined;
+}
+/**
+ * Creates a new game instance that coordinates scenes, renderers, and a shared ticker.
+ *
+ * The game manages the global update loop (via `updateHz`) and allows attaching multiple renderers
+ * and scenes. Start the game with `game.start()` to begin ticking and rendering.
+ *
+ * @param config - Configuration options
+ * @param config.width - Logical viewport width (used for entity coordinates)
+ * @param config.height - Logical viewport height
+ * @param config.updateHz - Tick frequency:
+ *   - `"frames"` = run updates every render frame (RAF-synced, variable timestep)
+ *   - number = fixed timestep in Hz (e.g. 60)
+ * @returns A `KaylaGame` instance
+ *
+ * @example
+ * const game = createGame({ width: 800, height: 600, updateHz: 60 });
+ * game.start();
+ */
+declare function createGame({ width, height, updateHz: hz, }: {
+    width: number;
+    height: number;
+    updateHz?: number | "frames";
+}): KaylaInternals.KaylaGame;
+/**
+ * Creates a scene that manages a collection of entities and their update/draw lifecycle.
+ *
+ * Scenes handle z-sorted drawing, paused state, and entity addition/removal.
+ * Use `scene.spawn()` to mount a root component tree.
+ *
+ * @param name - Unique identifier for the scene
+ * @returns A `KaylaScene` wrapper with `.spawn()` and other methods
+ *
+ * @example
+ * const scene = createScene("main");
+ * scene.spawn(<GameWorld />);
+ */
+declare function createScene(name: string): KaylaInternals.KaylaScene;
+/**
+ * Creates a renderer that drives the canvas draw loop and handles pointer tracking.
+ *
+ * The renderer automatically clears the canvas each frame and emits a `"draw"` event
+ * where scenes can paint. Call `renderer.start()` to begin the RAF loop.
+ *
+ * @param canvas - The target `<canvas>` element
+ * @returns A `KaylaRenderer` instance
+ *
+ * @example
+ * const canvas = document.getElementById("game") as HTMLCanvasElement;
+ * const renderer = createRenderer(canvas);
+ * renderer.start();
+ */
+declare function createRenderer(canvas: HTMLCanvasElement): KaylaRenderer;
+/**
+ * Creates a Kayla element descriptor (virtual representation of an entity/component).
+ *
+ * This is the JSX factory used internally by the transpiler. You rarely call it directly,
+ * but it powers declarative trees passed to `scene.spawn()`.
+ *
+ * @template Props - Props type accepted by the component
+ * @param fc - The functional component
+ * @param props - Props including `key`, `ref`, `exportsRef`, `children`, etc.
+ * @returns Element descriptor
+ *
+ * @example
+ * const elem = createElement(Player, { x: 400, y: 300 });
+ * scene.spawn(elem);
+ */
+declare function createElement<Props extends FCProps>(fc: FC<Props>, props: Props): KaylaElement<Props>;
+interface KaylaElement<Props extends FCProps> {
+    type: FC<Props>;
+    props: Props;
+}
+/**
+ * Read-only view of a state value created via `useState`.
+ *
+ * Returned by `useState`. Changes via `.set()` / `.add()` / `.multiply()` may trigger
+ * a component refresh (re-execution of the component function), which can be expensive
+ * in performance-critical loops.
+ *
+ * **Performance warning:** Avoid frequent `.set()` calls in `useTick` / `usePaint` loops.
+ * Prefer `useSelf` or `useRef` for hot data (position, velocity, timers, counters).
+ * Use `useState` only for infrequent structural changes (e.g. `isDead`, `currentLevel`).
+ *
+ * @template T - Type of the stored value
+ */
+interface KaylaState<T> extends KaylaInternals.KaylaState<T> {
+}
+/**
+ * Mutable reference object whose `.current` property persists across component refreshes.
+ *
+ * Returned by `useRef` and `useSelf`. Changes to `.current` **never** trigger refresh,
+ * making it safe for hot mutable data (position, velocity, timers, DOM nodes, etc.).
+ *
+ * @template T - Type of the referenced value
+ */
+interface KaylaRef<T> extends KaylaInternals.KaylaRef<T> {
+}
+/**
+ * Game instance that coordinates scenes, renderers, and the shared ticker.
+ *
+ * @extends LeaGameII
+ */
+interface KaylaGame extends KaylaInternals.KaylaGame {
+}
+/**
+ * Scene wrapper that manages entity lifecycle and delegates to the underlying LEA scene.
+ *
+ * @extends LeaSceneII (via internal delegation)
+ */
+interface KaylaScene extends KaylaInternals.KaylaScene {
+}
+/**
+ * Renderer wrapper that extends LEA renderer with game integration and pointer utilities.
+ *
+ * @extends LeaRendererII
+ */
+interface KaylaRenderer extends KaylaInternals.KaylaRenderer {
+}
+/**
+ * Internal APIs, do not use outside.
+ */
+declare namespace KaylaInternals {
+    /**
+     * Game instance that coordinates scenes, renderers, and the shared ticker.
+     *
+     * @extends LeaGameII
+     */
+    class KaylaGame extends LeaGameII {
+        #private;
+        constructor(width: number, height: number, hz: typeof Infinity | number);
+        /**
+         * Whether the game has been started.
+         */
+        get started(): boolean;
+        /**
+         * Starts the game: starts all attached renderers and the ticker.
+         */
+        start(): void;
+        /**
+         * Stops the game: stops all attached renderers and the ticker.
+         */
+        stop(): void;
+        /**
+         * Attaches a renderer to the game.
+         *
+         * If the game is already started, the renderer is started immediately.
+         *
+         * @param renderer - The renderer to attach
+         */
+        addRenderer(renderer: KaylaRenderer): void;
+        /**
+         * Detaches a renderer from the game.
+         *
+         * If the game is running, the renderer is stopped.
+         *
+         * @param renderer - The renderer to detach
+         */
+        deleteRenderer(renderer: KaylaRenderer): void;
+    }
+    /**
+     * Renderer wrapper that extends LEA renderer with game integration and pointer utilities.
+     *
+     * @extends LeaRendererII
+     */
+    class KaylaRenderer extends LeaRendererII {
+        #private;
+        /**
+         * The attached game instance (set via `attachTo`).
+         */
+        game?: KaylaGame;
+        /**
+         * Current canvas-space pointer X coordinate.
+         */
+        pointerX: number;
+        /**
+         * Current canvas-space pointer Y coordinate.
+         */
+        pointerY: number;
+        constructor(canvas: HTMLCanvasElement);
+        listenPointerUpdates(): void;
+        unlistenPointerUpdates(): void;
+        /**
+         * Transforms canvas-space coordinates to world-space coordinates.
+         *
+         * @param mx - Mouse X in canvas pixels
+         * @param my - Mouse Y in canvas pixels
+         * @returns World-space position
+         */
+        pointerPosToWorldPos(mx: number, my: number): Vector2;
+        /**
+         * Returns the current pointer position in world coordinates.
+         *
+         * Requires `listenPointerUpdates()` to have been called.
+         *
+         * @returns World-space position
+         */
+        getMousePos(): Vector2;
+        /**
+         * Registers a draw callback that receives a normalized `KaylaEvent`.
+         *
+         * @param callback - Paint handler
+         * @returns Unsubscribe function
+         */
+        useDraw(callback: KaylaInternalComponent["onPaint"][number]): () => void;
+        /**
+         * Attaches this renderer to a game.
+         *
+         * Sets `renderer.game` and adds it to `game.#renderers`.
+         *
+         * @param game - The game to attach to
+         */
+        attachTo(game: KaylaGame): void;
+        /**
+         * Detaches this renderer from its game (if attached).
+         */
+        detach(): void;
+    }
+    class GlobalKayla {
+        current?: KaylaInternalComponent;
+        saves: {
+            current?: GlobalKayla["current"];
+        }[];
+        constructor();
+        useTick(onTick: KaylaInternalComponent["onTick"][number]): void;
+        usePaint(onPaint: KaylaInternalComponent["onPaint"][number]): void;
+        useEntity(): KaylaElementRef;
+        useSelf<T>(init: () => T): T;
+        useState<T>(initialValue?: T, { alwaysRecall }?: {
+            alwaysRecall?: boolean;
+        }): KaylaState<T>;
+        useRef(initialValue: typeof selfSym): KaylaElementRef;
+        useRef<T>(initialValue: T | null): KaylaRef<T>;
+        useEffect(onEffect: KaylaInternalComponent["onEffect"][number]): void;
+        useExports<T extends FC<any, any>>(fc: T, onExport: KaylaInternalComponent<PropOfFC<T>, ExportsOfFC<T>>["onExport"]): void;
+        save(): void;
+        restore(): void;
+    }
+    class KaylaEvent {
+        #private;
+        preventDefault(): void;
+        isPrevented(): boolean;
+    }
+    /**
+     * Read-only view of a state value created via `useState`.
+     *
+     * Returned by `useState`. Changes via `.set()` / `.add()` / `.multiply()` may trigger
+     * a component refresh (re-execution of the component function), which can be expensive
+     * in performance-critical loops.
+     *
+     * **Performance warning:** Avoid frequent `.set()` calls in `useTick` / `usePaint` loops.
+     * Prefer `useSelf` or `useRef` for hot data (position, velocity, timers, counters).
+     * Use `useState` only for infrequent structural changes (e.g. `isDead`, `currentLevel`).
+     *
+     * @template T - Type of the stored value
+     */
+    class KaylaState<T> {
+        #private;
+        alwaysRecall: boolean;
+        constructor(current: KaylaInternalComponent<any>, initialValue?: T, { alwaysRecall }?: {
+            alwaysRecall?: boolean;
+        });
+        get(this: KaylaState<T>): T;
+        /**
+         * Adds a number to the current value (only available when `T` is `number`).
+         *
+         * Convenience method that calls `.set(get() + added)`.
+         * Behaves exactly like `.set()` regarding refresh overhead.
+         *
+         * @param added - Value to add
+         * @param options - Optional control over refresh
+         * @param options.recall - Force refresh (default: false)
+         */
+        add(this: KaylaState<number>, added: number, { recall }?: {
+            recall?: boolean;
+        }): void;
+        /**
+         * Multiplies the current value by a number (only available when `T` is `number`).
+         *
+         * Convenience method that calls `.set(get() * multiplier)`.
+         * Behaves exactly like `.set()` regarding refresh overhead.
+         *
+         * @param multiplier - Value to multiply by
+         * @param options - Optional control over refresh
+         * @param options.recall - Force refresh (default: false)
+         */
+        multiply(this: KaylaState<number>, added: number, { recall }?: {
+            recall?: boolean;
+        }): void;
+        /**
+         * Updates the state value.
+         *
+         * If the new value differs from the current one (strict `!==` comparison),
+         * and either `recall: true` is passed or `alwaysRecall` was set at creation,
+         * this triggers a component refresh.
+         *
+         * Refreshing re-runs the entire component function, re-binds hooks,
+         * and may re-mount/unmount children — avoid in hot paths.
+         *
+         * @param newValue - The new state value
+         * @param options - Optional control over refresh behavior
+         * @param options.recall - Force a refresh even if `alwaysRecall` is false (default: false)
+         */
+        set(this: KaylaState<T>, s: T, { recall }?: {
+            recall?: boolean;
+        }): void;
+        /**
+         * The current value of the state.
+         *
+         * Reading this property is always safe and does not trigger side effects.
+         *
+         * @readonly
+         */
+        get value(): T;
+        /**
+         * Timestamp (milliseconds since epoch) of the last time the state was changed via `.set()`.
+         *
+         * Useful for dependency tracking or knowing when the value was last mutated.
+         *
+         * @readonly
+         */
+        get lastChanged(): number;
+    }
+    /**
+     * Mutable reference object whose `.current` property persists across component refreshes.
+     *
+     * Returned by `useRef` and `useSelf`. Changes to `.current` **never** trigger refresh,
+     * making it safe for hot mutable data (position, velocity, timers, DOM nodes, etc.).
+     *
+     * @template T - Type of the referenced value
+     */
+    class KaylaRef<T> {
+        #private;
+        constructor(current: KaylaInternalComponent<any>, initialValue?: T);
+        /**
+         * The mutable value held by the ref.
+         *
+         * Reading or writing this property has **no side effects** — it does **not** trigger
+         * component refresh, re-render, or hook re-registration.
+         *
+         * When initialized with the `self` symbol via `useRef(self)`, this becomes a reference
+         * to the underlying `KaylaRectEntity`.
+         *
+         * @type {T}
+         */
+        get current(): T;
+        set current(s: T);
+    }
+    class KaylaInternalComponent<Props extends FCProps = {}, Exports extends FCExports = FCExports> {
+        state: KaylaState<unknown>[];
+        refs: KaylaRef<unknown>[];
+        global: GlobalKayla;
+        callProps: Props;
+        scene: KaylaScene;
+        exports: KaylaExports<Exports>;
+        constructor(globalKayla: GlobalKayla, scene: KaylaScene, element: KaylaElement<Props>);
+        get key(): string;
+        set key(s: string);
+        get children(): KaylaElement<any>[];
+        set children(s: KaylaElement<any>[]);
+        entity?: KaylaRectEntity;
+        onExport: () => KaylaExports<Exports>;
+        onEffect: Array<() => (() => void) | void>;
+        onUnEffect: Array<() => void>;
+        onEffectDeps?: KaylaState<any>[] | undefined;
+        onPaint: Array<(ctx: CanvasRenderingContext2D, event: KaylaEvent) => void>;
+        onTick: Array<(deltaS: number, event: KaylaEvent) => void>;
+        fc?: FC<any>;
+        useStateCallIndex: number;
+        useEffectCallIndex: number;
+        useDrawCallIndex: number;
+        useStepCallIndex: number;
+        useRefCallIndex: number;
+        lastStateDeps: Array<{
+            stateRef: KaylaState<any>;
+            stamp: number;
+        }>;
+        refresh(): void;
+        lastChildren: KaylaInternalComponent<any>[];
+        isFirstUse: boolean;
+        use(): void;
+        unuse(): void;
+    }
+    class KaylaRectEntity extends RectLeaEntity {
+        #private;
+        constructor(component: KaylaInternalComponent, name: string);
+        update(_delta: number): void;
+        draw(ctx: CanvasRenderingContext2D): void;
+    }
+    class KaylaScene {
+        #private;
+        constructor(scene: LeaSceneII);
+        /**
+         * Returns the underlying LEA scene instance.
+         */
+        getScene(): LeaSceneII;
+        private drawHandler;
+        /**
+         * Attaches this scene to a game instance.
+         *
+         * @param game - The game to attach to
+         */
+        attachTo(game: LeaGameII): void;
+        /**
+         * Mounts a root component tree into the scene.
+         *
+         * Triggers component execution, entity creation, and hook registration.
+         *
+         * @param elem - Root Kayla element (usually JSX)
+         */
+        spawn(elem: KaylaElement<any>): void;
+        /**
+         * Detaches this scene from its game (if attached).
+         */
+        detach(): void;
+        private tickHandler;
+    }
+    const singleGlobalInstance: GlobalKayla;
+}
+/**
+ * Returns a stateful value and a setter to update it.
+ *
+ * **This hook MUST be called at the top level of a component function — never inside loops, conditions, nested functions, or callbacks.**
+ * The call order of all hooks is **strictly fixed** across every refresh; reordering calls will corrupt internal state.
+ *
+ * Calling the setter **may** schedule an entity refresh (re-execution of the component function),
+ * which re-binds all hooks to the same entity instance and potentially re-spawns children.
+ *
+ * **Critical performance warning:**
+ * **Do NOT** use `useState` for frequently-updated game data (position, velocity, rotation, timers, health deltas, etc.).
+ * Those **must** live in `useSelf` or plain `useRef`.
+ * `useState` is **only** for infrequent structural changes that should trigger refresh
+ * (e.g. `isDead` → spawn particles, `currentLevel` → reload map, `variant` → change sprite sheet).
+ *
+ * @template T The type of the state value
+ * @param initialValue Optional initial value
+ * @param options Configuration object
+ * @param options.alwaysRecall If `true`, **every** `.set()` call triggers a refresh (default: `false`)
+ * @returns A state wrapper with `.get()`, `.set()`, `.add()`, `.multiply()`, and `.lastChanged`
+ *
+ * @example Correct structural use
+ * const isDead = useState(false);
+ * if (health <= 0) isDead.set(true); // → refresh spawns death animation children
+ *
+ * @example Incorrect hot-data use (do NOT do this)
+ * const pos = useState({ x: 400, y: 300 }); // BAD — thrashing + GC pressure
+ */
+declare const useState: <T>(initialValue?: T, { alwaysRecall }?: {
+    alwaysRecall?: boolean;
+}) => KaylaInternals.KaylaState<T>;
+/**
+ * Returns a mutable ref object whose `.current` property persists across entity refreshes.
+ *
+ * **This hook MUST be called at the top level of a component function — never inside loops, conditions, nested functions, or callbacks.**
+ * The call order of all hooks is **strictly fixed**; reordering calls will corrupt internal ref storage.
+ *
+ * Changes to `.current` **never** trigger refresh or re-bind hooks — refs are stable for the entity's lifetime.
+ *
+ * **Primary use:** Hold mutable game state, methods, timers, audio nodes, previous values, etc.
+ * For most entities, wrap your full logic in `useSelf()` instead (strongly recommended pattern).
+ *
+ * Special case: pass the `self` symbol to get the current LEA entity:
+ *
+ * @template T The type of the ref's value
+ * @param initialValue Initial value for `.current`, or `self` symbol for entity reference
+ * @returns A ref object with mutable `.current` property
+ *
+ * @example Entity reference
+ * const entity = useRef(self);
+ * entity.current.x += 10; // direct entity mutation, no refresh
+ *
+ * @example Mutable counter
+ * const timer = useRef(0);
+ * useTick(delta => { timer.current += delta; });
+ */
+declare const useRef: {
+    (initialValue: typeof selfSym): KaylaElementRef;
+    <T>(initialValue: T | null): KaylaInternals.KaylaRef<T>;
+};
+/**
+ * Registers an effect that runs after entity creation and after every refresh.
+ *
+ * **This hook MUST be called at the top level of a component function — never inside loops, conditions, nested functions, or callbacks.**
+ * The call order of all hooks is **strictly fixed**; reordering calls will corrupt effect registration.
+ *
+ * The effect callback runs **synchronously** after refresh completes.
+ * If it returns a function, that cleanup runs **before** the next effect execution or when the entity is destroyed.
+ *
+ * Multiple `useEffect` calls **stack** — all run in declaration order.
+ * Effects are **re-registered** on every refresh (no dependency array in current version).
+ *
+ * **Use only for true side-effects** (event listeners, intervals, tweens, audio nodes, physics setup).
+ * For game logic, use `useTick` / `usePaint` / `useSelf` instead.
+ *
+ * @param effect Imperative function that may return a cleanup
+ */
+declare const useEffect: (onEffect: KaylaInternals.KaylaInternalComponent["onEffect"][number]) => void;
+/**
+ * Registers a callback that runs on every game tick (update phase).
+ *
+ * **This hook MUST be called at the top level of a component function — never inside loops, conditions, nested functions, or callbacks.**
+ * The call order of all hooks is **strictly fixed**; reordering calls will corrupt tick registration.
+ *
+ * Multiple `useTick` calls **stack** — all run in declaration order every tick.
+ * Call `event.preventDefault()` to skip remaining tick handlers for this entity (including default update).
+ *
+ * **Use for:** physics, movement, AI, timers, collision checks, input polling.
+ *
+ * @param callback Tick handler receiving delta time (seconds) and cancellable event
+ */
+declare const useTick: (onTick: KaylaInternals.KaylaInternalComponent["onTick"][number]) => void;
+/**
+ * Registers a callback that runs on every render frame (paint phase).
+ *
+ * **This hook MUST be called at the top level of a component function — never inside loops, conditions, nested functions, or callbacks.**
+ * The call order of all hooks is **strictly fixed**; reordering calls will corrupt paint registration.
+ *
+ * Multiple `usePaint` calls **stack** — all run in declaration order every frame.
+ * Call `event.preventDefault()` to skip remaining paint handlers (including default rect fill).
+ *
+ * **Use for:** drawing sprites, particles, health bars, debug overlays, name tags.
+ *
+ * @param callback Paint handler receiving canvas context and cancellable event
+ */
+declare const usePaint: (onPaint: KaylaInternals.KaylaInternalComponent["onPaint"][number]) => void;
+/**
+ * Defines the public API this entity exposes to its parent via the `exportsRef` prop.
+ *
+ * **This hook MUST be called at the top level of a component function — never inside loops, conditions, nested functions, or callbacks.**
+ * The call order of all hooks is **strictly fixed**; only **one** `useExports` call is allowed per component (later calls override earlier ones).
+ *
+ * The exporter function runs during every refresh; the returned object is assigned to `this.exports`.
+ * Parent receives it via `exportsRef.current` (stable reference).
+ *
+ * **Use for:** exposing methods (jump, takeDamage), getters (position, health), or state handles to parent.
+ *
+ * @template T The functional component type (used for type inference)
+ * @param component The component function itself (required for TypeScript inference)
+ * @param exporter Function returning the exportable values/methods
+ *
+ * @example
+ * useExports(Player, () => ({
+ *   jump: () => { ...  },
+ *   getPosition: () => entity.current.pos.clone()
+ * }));
+ */
+declare const useExports: <T extends FC<any, any>>(fc: T, onExport: KaylaInternals.KaylaInternalComponent<PropOfFC<T>, ExportsOfFC<T>>["onExport"]) => void;
+/**
+ * Creates and returns a stable object (god-object) for holding most of an entity's state and logic.
+ *
+ * **This hook MUST be called at the top level of a component function — never inside loops, conditions, nested functions, or callbacks.**
+ * The call order of all hooks is **strictly fixed**; reordering calls will corrupt ref storage.
+ *
+ * The initializer runs **only once** (on first entity creation); the returned object is the **same reference** on every refresh.
+ *
+ * **Recommended pattern:** Put nearly all mutable state, methods, and game logic here.
+ * Use `useState` **only** for rare structural changes that should trigger refresh.
+ *
+ * @template T The type of the god-object
+ * @param init Factory function returning the object (called only once)
+ * @returns The initialized god-object (stable across refreshes)
+ *
+ * @example
+ * const self = useSelf(() => ({
+ *   pos: new Vector2(400, 300),
+ *   vel: new Vector2(100, 0),
+ *   tick(delta) { this.pos.x += this.vel.x * delta; }
+ * }));
+ *
+ * useTick(delta => self.tick(delta));
+ */
+declare const useSelf: <T>(init: () => T) => T;
+/**
+ * Returns a direct reference to the underlying LEA entity instance managed by this component.
+ *
+ * **This hook MUST be called at the top level of a component function — never inside loops, conditions, nested functions, or callbacks.**
+ * The call order of all hooks is **strictly fixed**; reordering calls will corrupt internal state.
+ *
+ * The returned reference is **stable** for the entity's lifetime and allows direct mutation of `x`, `y`, `z`, `width`, `height`, etc.
+ *
+ * @returns Reference to the `KaylaRectEntity` instance
+ */
+declare const useEntity: () => KaylaElementRef;
+/**
+ * Special symbol used to obtain a reference to the current entity.
+ *
+ * Pass this to `useRef` to get the underlying `KaylaRectEntity`:
+ *
+ * ```ts
+ * const entity = useRef(self);
+ * entity.current.x += 10;
+ * ```
+ *
+ * @see {@link useRef}
+ */
+declare const selfSym: unique symbol;
+
+/**
+ * Schedules a callback to run in the next microtask (via `Promise.resolve().then`).
+ *
+ * Used internally to defer entity refreshes safely and prevent synchronous re-entrancy.
+ * Rarely needed directly by users.
+ *
+ * @param callback - The function to schedule
+ */
+declare const useNextStack: (callback: () => void) => void;
+/**
+ * A fragment component that simply returns its children.
+ *
+ * Useful for grouping entities without adding an extra wrapper entity.
+ * Behaves like React.Fragment — no additional DOM/entity overhead.
+ *
+ * @example
+ * return (
+ *   <KaylaFragment>
+ *     <Enemy />
+ *     <Coin />
+ *   </KaylaFragment>
+ * );
+ *
+ * // Or shorthand:
+ * return (
+ *   <>
+ *     <Enemy />
+ *     <Coin />
+ *   </>
+ * );
+ */
+declare const KaylaFragment: FC;
+declare namespace JSX {
+    type Element = KaylaElement<any>;
+    interface IntrinsicElements {
+    }
+    type ElementType = FC<any>;
+}
+/**
+ * Marker type for values that can be exported from a component via `useExports`.
+ *
+ * Currently supports `KaylaState` or `KaylaRef` instances.
+ */
+type KaylaExportables = KaylaState<any> | KaylaRef<any>;
+/**
+ * Shape of the object returned by a component's `useExports` callback.
+ *
+ * @template StateMap - Record mapping export names to exportable values
+ */
+type KaylaExports<StateMap extends Record<string, KaylaExportables>> = {
+    [K in keyof StateMap]: StateMap[K];
+};
+type PropOfFC<T extends FC<any, any>> = T extends FC<infer Props, any> ? Props : never;
+type ExportsOfFC<T extends FC<any, any>> = T extends FC<any, infer Exports> ? Exports : never;
+/**
+ * Creates a temporary ref object **outside** of component context.
+ *
+ * Unlike `useRef`, this ref **does not persist** across entity refreshes — it is recreated
+ * every time the component function runs. Use for one-off values or render-pass temporaries.
+ *
+ * @template T - Type of the ref's value
+ * @param initialValue - Initial value for `.current`
+ * @returns A fresh `KaylaRef` instance
+ *
+ * @example
+ * const temp = useDisposableRef({ count: 0 });
+ * // temp.current is only valid for this render
+ */
+declare function useDisposableRef<T>(initialValue: T): KaylaInternals.KaylaRef<T>;
+/**
+ * Reference type returned by `useEntity()` or passed via `ref` prop.
+ *
+ * Provides direct access to the underlying `KaylaRectEntity` (LEA entity wrapper).
+ */
+interface KaylaElementRef extends KaylaRef<KaylaInternals.KaylaRectEntity> {
+}
+
+type kaylaInternals_ExportsOfFC<T extends FC<any, any>> = ExportsOfFC<T>;
+type kaylaInternals_FC<Props extends FCProps = FCProps, Exports extends FCExports = FCExports> = FC<Props, Exports>;
+type kaylaInternals_FCExports = FCExports;
+type kaylaInternals_FCProps = FCProps;
+declare const kaylaInternals_JSX: typeof JSX;
+type kaylaInternals_KaylaElement<Props extends FCProps> = KaylaElement<Props>;
+type kaylaInternals_KaylaElementRef = KaylaElementRef;
+type kaylaInternals_KaylaExportables = KaylaExportables;
+type kaylaInternals_KaylaExports<StateMap extends Record<string, KaylaExportables>> = KaylaExports<StateMap>;
+declare const kaylaInternals_KaylaFragment: typeof KaylaFragment;
+type kaylaInternals_KaylaGame = KaylaGame;
+declare const kaylaInternals_KaylaInternals: typeof KaylaInternals;
+type kaylaInternals_KaylaRef<T> = KaylaRef<T>;
+type kaylaInternals_KaylaRenderer = KaylaRenderer;
+type kaylaInternals_KaylaScene = KaylaScene;
+type kaylaInternals_KaylaState<T> = KaylaState<T>;
+type kaylaInternals_PropOfFC<T extends FC<any, any>> = PropOfFC<T>;
+declare const kaylaInternals_createElement: typeof createElement;
+declare const kaylaInternals_createGame: typeof createGame;
+declare const kaylaInternals_createRenderer: typeof createRenderer;
+declare const kaylaInternals_createScene: typeof createScene;
+declare const kaylaInternals_useDisposableRef: typeof useDisposableRef;
+declare const kaylaInternals_useEffect: typeof useEffect;
+declare const kaylaInternals_useEntity: typeof useEntity;
+declare const kaylaInternals_useExports: typeof useExports;
+declare const kaylaInternals_useNextStack: typeof useNextStack;
+declare const kaylaInternals_usePaint: typeof usePaint;
+declare const kaylaInternals_useRef: typeof useRef;
+declare const kaylaInternals_useSelf: typeof useSelf;
+declare const kaylaInternals_useState: typeof useState;
+declare const kaylaInternals_useTick: typeof useTick;
+declare namespace kaylaInternals {
+  export { type kaylaInternals_ExportsOfFC as ExportsOfFC, type kaylaInternals_FC as FC, type kaylaInternals_FCExports as FCExports, type kaylaInternals_FCProps as FCProps, kaylaInternals_JSX as JSX, type kaylaInternals_KaylaElement as KaylaElement, type kaylaInternals_KaylaElementRef as KaylaElementRef, type kaylaInternals_KaylaExportables as KaylaExportables, type kaylaInternals_KaylaExports as KaylaExports, kaylaInternals_KaylaFragment as KaylaFragment, type kaylaInternals_KaylaGame as KaylaGame, kaylaInternals_KaylaInternals as KaylaInternals, type kaylaInternals_KaylaRef as KaylaRef, type kaylaInternals_KaylaRenderer as KaylaRenderer, type kaylaInternals_KaylaScene as KaylaScene, type kaylaInternals_KaylaState as KaylaState, type kaylaInternals_PropOfFC as PropOfFC, kaylaInternals_createElement as createElement, kaylaInternals_createGame as createGame, kaylaInternals_createRenderer as createRenderer, kaylaInternals_createScene as createScene, selfSym as self, kaylaInternals_useDisposableRef as useDisposableRef, kaylaInternals_useEffect as useEffect, kaylaInternals_useEntity as useEntity, kaylaInternals_useExports as useExports, kaylaInternals_useNextStack as useNextStack, kaylaInternals_usePaint as usePaint, kaylaInternals_useRef as useRef, kaylaInternals_useSelf as useSelf, kaylaInternals_useState as useState, kaylaInternals_useTick as useTick };
+}
+
+declare namespace UI {
+    interface UIProps extends FCProps {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        onClick?: () => void;
+    }
+    const UIComponent: FC<UIProps>;
+}
+
+type Kayla_ExportsOfFC<T extends FC<any, any>> = ExportsOfFC<T>;
+type Kayla_FC<Props extends FCProps = FCProps, Exports extends FCExports = FCExports> = FC<Props, Exports>;
+type Kayla_FCExports = FCExports;
+type Kayla_FCProps = FCProps;
+declare const Kayla_JSX: typeof JSX;
+type Kayla_KaylaElement<Props extends FCProps> = KaylaElement<Props>;
+type Kayla_KaylaElementRef = KaylaElementRef;
+type Kayla_KaylaExportables = KaylaExportables;
+type Kayla_KaylaExports<StateMap extends Record<string, KaylaExportables>> = KaylaExports<StateMap>;
+declare const Kayla_KaylaFragment: typeof KaylaFragment;
+type Kayla_KaylaGame = KaylaGame;
+declare const Kayla_KaylaInternals: typeof KaylaInternals;
+type Kayla_KaylaRef<T> = KaylaRef<T>;
+type Kayla_KaylaRenderer = KaylaRenderer;
+type Kayla_KaylaScene = KaylaScene;
+type Kayla_KaylaState<T> = KaylaState<T>;
+type Kayla_PropOfFC<T extends FC<any, any>> = PropOfFC<T>;
+declare const Kayla_UI: typeof UI;
+declare const Kayla_createElement: typeof createElement;
+declare const Kayla_createGame: typeof createGame;
+declare const Kayla_createRenderer: typeof createRenderer;
+declare const Kayla_createScene: typeof createScene;
+declare const Kayla_useDisposableRef: typeof useDisposableRef;
+declare const Kayla_useEffect: typeof useEffect;
+declare const Kayla_useEntity: typeof useEntity;
+declare const Kayla_useExports: typeof useExports;
+declare const Kayla_useNextStack: typeof useNextStack;
+declare const Kayla_usePaint: typeof usePaint;
+declare const Kayla_useRef: typeof useRef;
+declare const Kayla_useSelf: typeof useSelf;
+declare const Kayla_useState: typeof useState;
+declare const Kayla_useTick: typeof useTick;
+declare namespace Kayla {
+  export { type Kayla_ExportsOfFC as ExportsOfFC, type Kayla_FC as FC, type Kayla_FCExports as FCExports, type Kayla_FCProps as FCProps, Kayla_JSX as JSX, kaylaInternals as Kayla, type Kayla_KaylaElement as KaylaElement, type Kayla_KaylaElementRef as KaylaElementRef, type Kayla_KaylaExportables as KaylaExportables, type Kayla_KaylaExports as KaylaExports, Kayla_KaylaFragment as KaylaFragment, type Kayla_KaylaGame as KaylaGame, Kayla_KaylaInternals as KaylaInternals, type Kayla_KaylaRef as KaylaRef, type Kayla_KaylaRenderer as KaylaRenderer, type Kayla_KaylaScene as KaylaScene, type Kayla_KaylaState as KaylaState, type Kayla_PropOfFC as PropOfFC, Kayla_UI as UI, Kayla_createElement as createElement, Kayla_createGame as createGame, Kayla_createRenderer as createRenderer, Kayla_createScene as createScene, selfSym as self, Kayla_useDisposableRef as useDisposableRef, Kayla_useEffect as useEffect, Kayla_useEntity as useEntity, Kayla_useExports as useExports, Kayla_useNextStack as useNextStack, Kayla_usePaint as usePaint, Kayla_useRef as useRef, Kayla_useSelf as useSelf, Kayla_useState as useState, Kayla_useTick as useTick };
+}
+
+declare const _default: {
+    LEA: typeof LEA;
+    Kayla: typeof Kayla;
+};
+
+export { Kayla, LEA, _default as default };