@utsp/core 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,4732 @@
+import { Vector2, AxisSource, ButtonSource, InputBindingLoadPacket, AxisBinding, ButtonBinding, UserRenderState } from '@utsp/types';
+export { AxisBinding, AxisSource, ButtonBinding, ButtonSource, InputBindingLoadPacket, RenderState, RenderedCell, UserRenderState, Vector2 } from '@utsp/types';
+
+/**
+ * Font system for UTSP Core
+ * Supports WebFont (CSS-based) and BitmapFont (pixel-based)
+ */
+/**
+ * Font type enumeration
+ */
+declare enum FontType {
+    Web = "web",
+    Bitmap = "bitmap"
+}
+/**
+ * WebFont configuration
+ * For CSS-based fonts rendered by the browser
+ */
+interface WebFontConfig {
+    fontFamily: string;
+    fontSize: number;
+    offsetX?: number;
+    offsetY?: number;
+    charSpacing?: number;
+    lineHeight?: number;
+    fontWeight?: string;
+    fontStyle?: string;
+}
+/**
+ * WebFont class
+ * Represents a CSS-based font for browser rendering
+ */
+declare class WebFont {
+    private fontId;
+    private config;
+    constructor(fontId: number, config: WebFontConfig);
+    /**
+     * Get the unique font ID
+     */
+    getFontId(): number;
+    /**
+     * Get the full configuration (copy)
+     */
+    getConfig(): WebFontConfig;
+    /**
+     * Get the font family
+     */
+    getFontFamily(): string;
+    /**
+     * Get the font size in pixels
+     */
+    getFontSize(): number;
+    /**
+     * Get the horizontal offset
+     */
+    getOffsetX(): number;
+    /**
+     * Get the vertical offset
+     */
+    getOffsetY(): number;
+    /**
+     * Get the character spacing
+     */
+    getCharSpacing(): number;
+    /**
+     * Get the line height multiplier
+     */
+    getLineHeight(): number;
+    /**
+     * Get the font weight
+     */
+    getFontWeight(): string;
+    /**
+     * Get the font style
+     */
+    getFontStyle(): string;
+    /**
+     * Generate CSS declaration for this font
+     * @returns CSS string (e.g., "font-family: Consolas; font-size: 16px;")
+     */
+    toCSS(): string;
+}
+/**
+ * BitmapFont configuration
+ * For pixel-based fonts with custom glyph data
+ */
+interface BitmapFontConfig {
+    charWidth: number;
+    charHeight: number;
+    cellWidth?: number;
+    cellHeight?: number;
+    glyphs: Map<number, Uint8Array>;
+}
+/**
+ * BitmapFont class
+ * Represents a pixel-based font with custom glyph bitmaps
+ * Corresponds to LoadType 0x04 (Charset) in UTSP protocol
+ */
+declare class BitmapFont {
+    private fontId;
+    private config;
+    constructor(fontId: number, config: BitmapFontConfig);
+    /**
+     * Get the unique font ID
+     */
+    getFontId(): number;
+    /**
+     * Get the full configuration (deep copy)
+     */
+    getConfig(): BitmapFontConfig;
+    /**
+     * Get the glyph width in pixels (actual bitmap size)
+     */
+    getCharWidth(): number;
+    /**
+     * Get the glyph height in pixels (actual bitmap size)
+     */
+    getCharHeight(): number;
+    /**
+     * Get the target cell width in pixels (rendering size)
+     * Defaults to glyph width if not specified
+     */
+    getCellWidth(): number;
+    /**
+     * Get the target cell height in pixels (rendering size)
+     * Defaults to glyph height if not specified
+     */
+    getCellHeight(): number;
+    /**
+     * Get the bitmap data for a specific character
+     * @param charCode Character code (0-255)
+     * @returns Bitmap data or undefined if not found
+     */
+    getGlyph(charCode: number): Uint8Array | undefined;
+    /**
+     * Check if a glyph exists for a character
+     * @param charCode Character code (0-255)
+     */
+    hasGlyph(charCode: number): boolean;
+    /**
+     * Get the number of glyphs in this font
+     */
+    getGlyphCount(): number;
+    /**
+     * Get all character codes that have glyphs
+     */
+    getCharCodes(): number[];
+}
+
+/**
+ * Network representation of a display
+ * Layers are NO LONGER under displays - they are at User level
+ */
+interface NetworkDisplay {
+    /** Display ID (0-255) */
+    id: number;
+    /** Origin X position in virtual world (0-65535) */
+    originX: number;
+    /** Origin Y position in virtual world (0-65535) */
+    originY: number;
+    /** Display width in cells (1-256) */
+    sizeX: number;
+    /** Display height in cells (1-256) */
+    sizeY: number;
+}
+
+/**
+ * Base interface for all network orders
+ */
+interface NetworkOrder {
+    type: number;
+}
+/**
+ * 0x01 - Char: Renders a single character at a specific position
+ */
+interface CharOrder extends NetworkOrder {
+    type: 0x01;
+    posX: number;
+    posY: number;
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+/**
+ * 0x02 - Text: Renders a string of characters with uniform colors
+ */
+interface TextOrder extends NetworkOrder {
+    type: 0x02;
+    posX: number;
+    posY: number;
+    text: string;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+/**
+ * 0x17 - TextMultiline: Renders multiple lines of text (\n for line breaks)
+ */
+interface TextMultilineOrder extends NetworkOrder {
+    type: 0x17;
+    posX: number;
+    posY: number;
+    text: string;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+/**
+ * 0x03 - SubFrame: Renders a rectangular region with uniform colors
+ */
+interface SubFrameOrder extends NetworkOrder {
+    type: 0x03;
+    posX: number;
+    posY: number;
+    sizeX: number;
+    sizeY: number;
+    bgColorCode: number;
+    fgColorCode: number;
+    frame: number[];
+}
+/**
+ * 0x04 - SubFrameMultiColor: Rectangular region with per-cell colors
+ */
+interface SubFrameMultiColorOrder extends NetworkOrder {
+    type: 0x04;
+    posX: number;
+    posY: number;
+    sizeX: number;
+    sizeY: number;
+    frame: Array<{
+        charCode: number;
+        bgColorCode: number;
+        fgColorCode: number;
+    }>;
+}
+/**
+ * 0x05 - FullFrame: Renders entire screen with uniform colors
+ */
+interface FullFrameOrder extends NetworkOrder {
+    type: 0x05;
+    bgColorCode: number;
+    fgColorCode: number;
+    frame: number[];
+}
+/**
+ * 0x06 - FullFrameMultiColor: Entire screen with per-cell colors
+ */
+interface FullFrameMultiColorOrder extends NetworkOrder {
+    type: 0x06;
+    frame: Array<{
+        charCode: number;
+        bgColorCode: number;
+        fgColorCode: number;
+    }>;
+}
+/**
+ * 0x07 - Sprite: Renders a preloaded unicolor sprite
+ */
+interface SpriteOrder extends NetworkOrder {
+    type: 0x07;
+    posX: number;
+    posY: number;
+    spriteIndex: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+/**
+ * 0x08 - SpriteMultiColor: Renders a preloaded multicolor sprite
+ */
+interface SpriteMultiColorOrder extends NetworkOrder {
+    type: 0x08;
+    posX: number;
+    posY: number;
+    spriteIndex: number;
+}
+/**
+ * 0x09 - ColorMap: Applies colors to a region without changing characters
+ */
+interface ColorMapOrder extends NetworkOrder {
+    type: 0x09;
+    posX: number;
+    posY: number;
+    sizeX: number;
+    sizeY: number;
+    colorData: Array<{
+        bgColorCode: number;
+        fgColorCode: number;
+    }>;
+}
+/**
+ * 0x0A - Shape: Renders geometric shapes
+ */
+interface ShapeOrder extends NetworkOrder {
+    type: 0x0a;
+    shapeType: ShapeType;
+    shapeData: ShapeData;
+}
+declare enum ShapeType {
+    Rectangle = 1,
+    Circle = 2,
+    Line = 3,
+    Ellipse = 4,
+    Triangle = 5
+}
+type ShapeData = RectangleShape | CircleShape | LineShape | EllipseShape | TriangleShape;
+interface RectangleShape {
+    posX: number;
+    posY: number;
+    width: number;
+    height: number;
+    filled: boolean;
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+interface CircleShape {
+    centerX: number;
+    centerY: number;
+    radius: number;
+    filled: boolean;
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+interface LineShape {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+interface EllipseShape {
+    centerX: number;
+    centerY: number;
+    radiusX: number;
+    radiusY: number;
+    filled: boolean;
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+interface TriangleShape {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x3: number;
+    y3: number;
+    filled: boolean;
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+/**
+ * 0x0B - DotCloud: Same character at multiple positions (up to 65535)
+ */
+interface DotCloudOrder extends NetworkOrder {
+    type: 0x0b;
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+    positions: Array<{
+        posX: number;
+        posY: number;
+    }>;
+}
+/**
+ * 0x0C - DotCloudMultiColor: Different characters at multiple positions
+ */
+interface DotCloudMultiColorOrder extends NetworkOrder {
+    type: 0x0c;
+    dots: Array<{
+        charCode: number;
+        bgColorCode: number;
+        fgColorCode: number;
+        posX: number;
+        posY: number;
+    }>;
+}
+/**
+ * 0x0D - SpriteCloud: Same unicolor sprite at multiple positions
+ */
+interface SpriteCloudOrder extends NetworkOrder {
+    type: 0x0d;
+    spriteIndex: number;
+    bgColorCode: number;
+    fgColorCode: number;
+    positions: Array<{
+        posX: number;
+        posY: number;
+    }>;
+}
+/**
+ * 0x0E - SpriteCloudMultiColor: Same multicolor sprite at multiple positions
+ */
+interface SpriteCloudMultiColorOrder extends NetworkOrder {
+    type: 0x0e;
+    spriteIndex: number;
+    positions: Array<{
+        posX: number;
+        posY: number;
+    }>;
+}
+/**
+ * 0x0F - SpriteCloudVaried: Different unicolor sprites at multiple positions
+ */
+interface SpriteCloudVariedOrder extends NetworkOrder {
+    type: 0x0f;
+    sprites: Array<{
+        spriteIndex: number;
+        bgColorCode: number;
+        fgColorCode: number;
+        posX: number;
+        posY: number;
+    }>;
+}
+/**
+ * 0x10 - SpriteCloudVariedMultiColor: Different multicolor sprites at multiple positions
+ */
+interface SpriteCloudVariedMultiColorOrder extends NetworkOrder {
+    type: 0x10;
+    sprites: Array<{
+        spriteIndex: number;
+        posX: number;
+        posY: number;
+    }>;
+}
+/**
+ * 0x11 - Bitmask: Renders a rectangular region with bitpacked presence mask
+ * Each bit represents presence (1) or absence (0) of the character at that position
+ * Ideal for: ore veins, destructible terrain, collision maps, fog of war, etc.
+ */
+interface BitmaskOrder extends NetworkOrder {
+    type: 0x11;
+    posX: number;
+    posY: number;
+    sizeX: number;
+    sizeY: number;
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+    override: boolean;
+    mask: Uint8Array;
+}
+/**
+ * 0x13 - Clear: Fills entire layer with single character and colors
+ */
+interface ClearOrder extends NetworkOrder {
+    type: 0x13;
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+/**
+ * 0x14 - FillChar: Fills layer with repeating character pattern
+ */
+interface FillCharOrder extends NetworkOrder {
+    type: 0x14;
+    patternWidth: number;
+    patternHeight: number;
+    bgColorCode: number;
+    fgColorCode: number;
+    pattern: number[];
+}
+/**
+ * 0x15 - FillSprite: Fills layer with repeating unicolor sprite
+ */
+interface FillSpriteOrder extends NetworkOrder {
+    type: 0x15;
+    spriteIndex: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+/**
+ * 0x16 - FillSpriteMultiColor: Fills layer with repeating multicolor sprite
+ */
+interface FillSpriteMultiColorOrder extends NetworkOrder {
+    type: 0x16;
+    spriteIndex: number;
+}
+/**
+ * 0x20 - TriggerSound: Triggers positional sound effect
+ */
+interface TriggerSoundOrder extends NetworkOrder {
+    type: 0x20;
+    posX: number;
+    posY: number;
+    soundId: number;
+    loop: boolean;
+}
+/**
+ * 0x21 - TriggerGlobalSound: Triggers global (non-positional) sound
+ */
+interface TriggerGlobalSoundOrder extends NetworkOrder {
+    type: 0x21;
+    soundId: number;
+    loop: boolean;
+}
+type AnyNetworkOrder = CharOrder | TextOrder | TextMultilineOrder | SubFrameOrder | SubFrameMultiColorOrder | FullFrameOrder | FullFrameMultiColorOrder | SpriteOrder | SpriteMultiColorOrder | ColorMapOrder | ShapeOrder | DotCloudOrder | DotCloudMultiColorOrder | BitmaskOrder | SpriteCloudOrder | SpriteCloudMultiColorOrder | SpriteCloudVariedOrder | SpriteCloudVariedMultiColorOrder | ClearOrder | FillCharOrder | FillSpriteOrder | FillSpriteMultiColorOrder | TriggerSoundOrder | TriggerGlobalSoundOrder;
+
+interface NetworkLayer {
+    id: number;
+    updateFlags: number;
+    zIndex: number;
+    originX: number;
+    originY: number;
+    width: number;
+    height: number;
+    orderCount: number;
+    orders: AnyNetworkOrder[];
+}
+
+/**
+ * Update packet according to the new UTSP protocol
+ * Layers are at the User level, not under displays
+ */
+interface UpdatePacket {
+    /** Tick counter (8 bytes) */
+    tick: number;
+    /** Number of displays (2 bytes) */
+    displayCount: number;
+    /** List of displays with their origins */
+    displays: NetworkDisplay[];
+    /** Number of layers (2 bytes) */
+    layerCount: number;
+    /** List of layers (shared across all displays) */
+    layers: NetworkLayer[];
+}
+
+/**
+ * Represents a display (camera) in the virtual world
+ *
+ * ARCHITECTURE (new protocol):
+ * - Display = camera looking into the virtual world
+ * - LAYERS are NO LONGER in Display, they are at User level
+ * - Display only defines WHICH PART of the world we see (origin)
+ */
+declare class Display {
+    private id;
+    private origin;
+    private size;
+    private previousOrigin;
+    private previousSize;
+    private toDraw;
+    constructor(id?: number, sizeX?: number, sizeY?: number);
+    /**
+     * Gets the display ID (0-255)
+     */
+    getId(): number;
+    /**
+     * Gets the origin position in the world
+     */
+    getOrigin(): Vector2;
+    /**
+     * Sets the origin position in the world
+     */
+    setOrigin(origin: Vector2): void;
+    /**
+     * Moves the origin in the world
+     */
+    moveOrigin(deltaX: number, deltaY: number): void;
+    /**
+     * Checks if display origin has changed since last tick
+     * @internal - Used to calculate if update should be sent
+     */
+    hasOriginChanged(): boolean;
+    /**
+     * Checks if display size has changed since last tick
+     * @internal - Used to calculate if update should be sent
+     */
+    hasSizeChanged(): boolean;
+    /**
+     * Checks if display has changed (origin OR size)
+     * @internal
+     */
+    hasChanged(): boolean;
+    /**
+     * Resets change tracking
+     * @internal - Called by Core.endTick() after sending updates
+     */
+    resetChangeTracking(): void;
+    /**
+     * Gets the display size
+     */
+    getSize(): Vector2;
+    /**
+     * Sets the display size
+     */
+    setSize(size: Vector2): void;
+}
+
+interface Cell {
+    charCode: number;
+    fgColorCode: number;
+    bgColorCode: number;
+}
+/**
+ * Optimized buffer for 65,536 cells with TypedArray
+ * Interleaved structure: [char0, fg0, bg0, char1, fg1, bg1, ...]
+ *
+ * Performance:
+ * - clear(): ~5-10μs (vs 826μs with object array)
+ * - Better cache locality
+ * - Less GC pressure
+ */
+declare class CellBuffer {
+    private data;
+    private size;
+    constructor(size?: number);
+    /**
+     * Optimized clear: fills with "skip" values
+     * - charCode = 0 (no character)
+     * - fgColorCode = 255 (COLOR_SKIP = transparent)
+     * - bgColorCode = 255 (COLOR_SKIP = transparent)
+     * Performance: ~5-10μs (native TypedArray)
+     */
+    clear(): void;
+    /**
+     * Optimized clear with uniform color
+     * Faster than clear() when clearing to specific char/colors
+     * Useful for background layers with uniform color
+     *
+     * Performance: ~2-5μs (loop unrolling friendly)
+     *
+     * @param charCode - Character to fill (e.g., 0x20 for space)
+     * @param fgColorCode - Foreground color (0-255)
+     * @param bgColorCode - Background color (0-255)
+     *
+     * @example
+     * // Clear to black background
+     * buffer.clearWithColor(0x20, 15, 0);
+     */
+    clearWithColor(charCode: number, fgColorCode: number, bgColorCode: number): void;
+    /**
+     * Sets a cell at given index
+     */
+    set(index: number, charCode: number, fgColorCode: number, bgColorCode: number): void;
+    /**
+     * Optimized batch fill for uniform char+colors (DotCloud, SpriteCloud)
+     * Writes only characters at multiple positions with uniform fg/bg colors
+     *
+     * Performance: 2-3x faster than individual set() calls for uniform colors
+     * Reduces memory writes by 66% (writes chars only, then batch-fills colors)
+     *
+     * @param indices - Array of cell indices to fill
+     * @param charCode - Character to write at all positions
+     * @param fgColorCode - Uniform foreground color
+     * @param bgColorCode - Uniform background color
+     *
+     * @example
+     * // Rain drops (1,500 positions with same color)
+     * const indices = raindrops.map(d => d.y * width + d.x);
+     * buffer.fillCharsUniform(indices, 58, 20, 255); // ':' char, cyan, transparent
+     */
+    fillCharsUniform(indices: number[], charCode: number, fgColorCode: number, bgColorCode: number): void;
+    /**
+     * Gets a cell at given index
+     * Returns a Cell object for compatibility
+     */
+    get(index: number): Cell;
+    /**
+     * Sets only character at given index (keeps existing colors)
+     * Useful for operations that modify chars but preserve colors
+     *
+     * @param index - Cell index
+     * @param charCode - Character code to write
+     */
+    setCharOnly(index: number, charCode: number): void;
+    /**
+     * Sets only colors at given index (keeps existing char)
+     * Useful for ColorMapOrder (updates colors, preserves chars)
+     *
+     * @param index - Cell index
+     * @param fgColorCode - Foreground color
+     * @param bgColorCode - Background color
+     */
+    setColorsOnly(index: number, fgColorCode: number, bgColorCode: number): void;
+    /**
+     * Direct value access (faster than get())
+     * Note: These are called in hot loops, keep as inline as possible
+     */
+    getCharCode(index: number): number;
+    getFgColorCode(index: number): number;
+    getBgColorCode(index: number): number;
+    /**
+     * Direct TypedArray access for batch operations
+     */
+    getRawData(): Uint8Array;
+    /**
+     * Buffer size (number of cells)
+     */
+    getSize(): number;
+}
+/**
+ * Optimized buffer to store only charcodes (unicolor sprites)
+ * Simple structure: [char0, char1, char2, ...]
+ *
+ * Performance:
+ * - 3x less memory than CellBuffer (1 byte vs 3 bytes per cell)
+ * - Ideal for unicolor sprites where colors are defined at render time
+ * - Cache-friendly with TypedArray
+ */
+declare class CharCodeBuffer {
+    private data;
+    private size;
+    constructor(size: number);
+    /**
+     * Optimized clear: fills with zeros (no character)
+     */
+    clear(): void;
+    /**
+     * Sets a charcode at given index
+     */
+    set(index: number, charCode: number): void;
+    /**
+     * Gets a charcode at given index
+     */
+    get(index: number): number;
+    /**
+     * Direct TypedArray access for batch operations
+     */
+    getRawData(): Uint8Array;
+    /**
+     * Buffer size (number of cells)
+     */
+    getSize(): number;
+}
+
+/**
+ * Unicolor sprite - Stores only charcodes
+ * Colors (fg/bg) are defined at render time via SpriteOrder
+ *
+ * Used with LoadType.Sprite (0x02) and SpriteOrder (0x07)
+ */
+interface UnicolorSprite {
+    id: number;
+    sizeX: number;
+    sizeY: number;
+    data: CharCodeBuffer;
+}
+/**
+ * Multicolor sprite - Stores charcodes + fg/bg colors
+ * Each cell contains its own color set
+ *
+ * Used with LoadType.MulticolorSprite (0x03) and SpriteMultiColorOrder (0x08)
+ */
+interface MulticolorSprite {
+    id: number;
+    sizeX: number;
+    sizeY: number;
+    data: CellBuffer;
+}
+
+/**
+ * UTSP Load Packet Types
+ * Based on UTSP Protocol v0.1 - Section 4: Load Section
+ */
+/**
+ * LoadType enumeration
+ */
+declare enum LoadType {
+    ColorPalette = 1,
+    Sprite = 2,
+    MulticolorSprite = 3,
+    BitmapFont = 4,// Formerly "Charset" - pixel-based fonts
+    Sound = 5,
+    WebFont = 6
+}
+/**
+ * Color definition with RGBA+E values
+ */
+interface Color {
+    colorId: number;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    e?: number;
+}
+/**
+ * Color Palette Load (LoadType 0x01)
+ * Loads a palette of RGBA+E colors
+ */
+interface ColorPaletteLoad {
+    loadType: LoadType.ColorPalette;
+    colors: Color[];
+}
+/**
+ * Simple Sprite Load (LoadType 0x02)
+ * Each cell contains only a character code
+ */
+interface SpriteLoad {
+    loadType: LoadType.Sprite;
+    sprites: Array<{
+        spriteId: number;
+        sizeX: number;
+        sizeY: number;
+        data: number[];
+    }>;
+}
+/**
+ * Cell in a multicolor sprite
+ */
+interface MulticolorCell {
+    charCode: number;
+    fgColorId: number;
+    bgColorId: number;
+}
+/**
+ * Multicolor Sprite Load (LoadType 0x03)
+ * Each cell contains charcode + foreground color + background color
+ */
+interface MulticolorSpriteLoad {
+    loadType: LoadType.MulticolorSprite;
+    sprites: Array<{
+        spriteId: number;
+        sizeX: number;
+        sizeY: number;
+        data: MulticolorCell[];
+    }>;
+}
+/**
+ * BitmapFont Load (LoadType 0x04)
+ * Custom character definitions (monochrome bitmaps)
+ * Formerly known as "Charset" - renamed to BitmapFont for clarity
+ */
+interface BitmapFontLoad {
+    loadType: LoadType.BitmapFont;
+    fontId: number;
+    width: number;
+    height: number;
+    cellWidth: number;
+    cellHeight: number;
+    characters: Array<{
+        charCode: number;
+        bitmap: Uint8Array;
+    }>;
+}
+/**
+ * WebFont Load (LoadType 0x06)
+ * CSS-based font definitions for browser rendering
+ * Note: The default font is "Courier New" (monospace), but users can specify non-monospace fonts
+ */
+interface WebFontLoad {
+    loadType: LoadType.WebFont;
+    fontId: number;
+    fontFamily: string;
+    fontSize: number;
+    offsetX?: number;
+    offsetY?: number;
+    charSpacing?: number;
+    lineHeight?: number;
+    fontWeight?: string;
+    fontStyle?: string;
+}
+/**
+ * Sound Load (LoadType 0x05)
+ * MIDI sound data for audio playback
+ */
+interface SoundLoad {
+    loadType: LoadType.Sound;
+    sounds: Array<{
+        soundId: number;
+        midiData: Uint8Array;
+    }>;
+}
+/**
+ * Union type for all load types
+ */
+type AnyLoad = ColorPaletteLoad | SpriteLoad | MulticolorSpriteLoad | BitmapFontLoad | SoundLoad | WebFontLoad;
+
+/**
+ * Central registry to manage unicolor and multicolor sprites
+ *
+ * Sprites are loaded via LoadPacket and referenced by their ID
+ * in Orders (SpriteOrder, SpriteMultiColorOrder, etc.)
+ *
+ * Architecture:
+ * - Two separate registries for unicolor and multicolor
+ * - No possible collision between the two types
+ * - Memory optimization with CharCodeBuffer for unicolor
+ */
+declare class SpriteRegistry {
+    private unicolorSprites;
+    private multicolorSprites;
+    /**
+     * Loads unicolor sprites from a LoadPacket
+     * Converts network format to optimized internal format
+     */
+    loadUnicolorSprites(loadData: SpriteLoad): void;
+    /**
+     * Loads multicolor sprites from a LoadPacket
+     * Converts network format to optimized internal format
+     */
+    loadMulticolorSprites(loadData: MulticolorSpriteLoad): void;
+    /**
+     * Retrieves a unicolor sprite by its ID
+     */
+    getUnicolorSprite(id: number): UnicolorSprite | undefined;
+    /**
+     * Retrieves a multicolor sprite by its ID
+     */
+    getMulticolorSprite(id: number): MulticolorSprite | undefined;
+    /**
+     * Checks if a unicolor sprite exists
+     */
+    hasUnicolorSprite(id: number): boolean;
+    /**
+     * Checks if a multicolor sprite exists
+     */
+    hasMulticolorSprite(id: number): boolean;
+    /**
+     * Removes a unicolor sprite
+     */
+    unloadUnicolorSprite(id: number): boolean;
+    /**
+     * Removes a multicolor sprite
+     */
+    unloadMulticolorSprite(id: number): boolean;
+    /**
+     * Clears all unicolor sprites
+     */
+    clearUnicolorSprites(): void;
+    /**
+     * Clears all multicolor sprites
+     */
+    clearMulticolorSprites(): void;
+    /**
+     * Clears all sprites (unicolor and multicolor)
+     */
+    clearAll(): void;
+    /**
+     * Number of loaded unicolor sprites
+     */
+    getUnicolorSpriteCount(): number;
+    /**
+     * Number of loaded multicolor sprites
+     */
+    getMulticolorSpriteCount(): number;
+    /**
+     * Total number of loaded sprites
+     */
+    getTotalSpriteCount(): number;
+}
+
+declare class Layer {
+    private id;
+    private origin;
+    private orders;
+    private zOrder;
+    private data;
+    private width;
+    private height;
+    private isStatic;
+    private spriteRegistry?;
+    private mode;
+    private previousOrigin;
+    private previousZOrder;
+    private enabled;
+    private useSetMode;
+    private needsCommit;
+    private static rasterizer;
+    constructor(origin: Vector2, zOrder: number, width: number, height: number, isStatic?: boolean);
+    /**
+     * Configures the layer's execution mode (called by User)
+     * @internal
+     */
+    setMode(mode: CoreMode): void;
+    /**
+     * Injects the SpriteRegistry into the layer (called by Core)
+     * @internal
+     */
+    setSpriteRegistry(registry: SpriteRegistry): void;
+    getOrders(): AnyNetworkOrder[];
+    /**
+     * Adds orders to the layer (incremental mode)
+     * Automatically rasterizes new orders in ADD mode
+     */
+    addOrders(orders: AnyNetworkOrder[]): void;
+    /**
+     * Replaces all orders in the layer (reset mode)
+     * Automatically rasterizes all orders in SET mode
+     */
+    setOrders(orders: AnyNetworkOrder[]): void;
+    /**
+     * Clears all orders and cleans the buffer
+     */
+    clearOrders(): void;
+    getOrigin(): Vector2;
+    /**
+     * Updates the layer's origin and rasterizes if necessary
+     *
+     * In client mode, this method automatically rasterizes the layer
+     * to reflect the new position.
+     *
+     * @param origin - New layer origin
+     */
+    setOrigin(origin: Vector2): void;
+    getZOrder(): number;
+    /**
+     * Updates the layer's z-order
+     *
+     * @param zOrder - New z-order
+     */
+    setZOrder(zOrder: number): void;
+    /**
+     * Gets the layer's unique ID
+     *
+     * Used for client-side reconstruction when applying UpdatePackets.
+     * The ID allows associating a NetworkLayer with its corresponding Layer.
+     *
+     * @returns Layer ID (0-65535)
+     */
+    getId(): number;
+    /**
+     * Sets the layer's unique ID
+     *
+     * @internal - Used by User.applyUpdate() during reconstruction
+     * @param id - Unique layer ID (0-65535)
+     */
+    setId(id: number): void;
+    getData(): CellBuffer;
+    getWidth(): number;
+    getHeight(): number;
+    getCellAt(x: number, y: number): Cell | null;
+    /**
+     * Marks this layer as static or dynamic
+     *
+     * Static layer: Sent only once to client via reliable channel,
+     * but continues to be rasterized client-side every frame.
+     * Used for UI elements, backgrounds, elements that never change.
+     *
+     * Dynamic layer: Sent every tick via volatile channel.
+     * Used for animated elements, players, projectiles, etc.
+     *
+     * @param isStatic - true for static, false for dynamic
+     */
+    setStatic(isStatic: boolean): void;
+    /**
+     * Checks if this layer is static
+     */
+    getStatic(): boolean;
+    /**
+     * Enables or disables the layer
+     * A disabled layer will not be rendered by DisplayRasterizer
+     *
+     * @param enabled - true to enable, false to disable
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Checks if layer is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Checks if layer origin changed since last tick
+     * @internal - Used to calculate UpdateFlags
+     */
+    hasOriginChanged(): boolean;
+    /**
+     * Checks if layer z-order changed since last tick
+     * @internal - Used to calculate UpdateFlags
+     */
+    hasZOrderChanged(): boolean;
+    /**
+     * Calculates UpdateFlags based on layer state and changes
+     * @internal - Used by Core.endTick()
+     * @returns Bitpacked flags (0x00 to 0x0F)
+     *
+     * Flag structure:
+     * - Bit 0 (0x01): Layer Enabled (1=active, 0=disabled)
+     * - Bit 1 (0x02): SET Mode (1=SET, 0=ADD)
+     * - Bit 2 (0x04): Position Changed
+     * - Bit 3 (0x08): Z-Order Changed
+     */
+    calculateUpdateFlags(): number;
+    /**
+     * Resets change tracking after sending a tick
+     * @internal - Used by Core.endTick()
+     */
+    resetChangeTracking(): void;
+    /**
+     * Marks the layer as needing to be sent on next tick
+     *
+     * Used to optimize bandwidth by sending only modified layers.
+     *
+     * @example
+     * ```typescript
+     * layer.addOrders([...]);
+     * layer.commit(); // Layer will be sent on next tick
+     * ```
+     */
+    commit(): void;
+    /**
+     * Checks if layer needs to be sent
+     * @internal - Used by Core.endTickSplit()
+     */
+    getNeedsCommit(): boolean;
+    /**
+     * Resets commit flag after sending
+     * @internal - Used by Core.endTickSplit()
+     */
+    resetCommit(): void;
+}
+
+/**
+ * InputBindingRegistry - Input bindings registry
+ *
+ * Allows the server to define available axes and buttons,
+ * and send them to the client via a JSON LoadPacket.
+ *
+ * Architecture:
+ * 1. Server defines bindings (bindingId ↔ name)
+ * 2. Server generates a JSON LoadPacket
+ * 3. Client receives LoadPacket and configures its mappings
+ * 4. Client sends back compressed inputs (bindingId + value)
+ * 5. Server decodes with registry (bindingId → name → setAxis/setButton)
+ */
+
+/**
+ * Input bindings registry
+ *
+ * Allows to:
+ * - Define axes and buttons (bindingId → name)
+ * - Generate a JSON LoadPacket to send to client
+ * - Decode compressed inputs received from client (future)
+ */
+declare class InputBindingRegistry {
+    private axes;
+    private buttons;
+    private axisNameToId;
+    private buttonNameToId;
+    private version;
+    /**
+     * Defines an axis binding
+     *
+     * @param bindingId - Unique axis ID (0-255)
+     * @param name - Axis name (e.g., "MoveHorizontal", "CameraX")
+     * @param sources - Physical sources (keyboard, gamepad, etc.)
+     * @param min - Minimum axis value (default: -1.0)
+     * @param max - Maximum axis value (default: +1.0)
+     * @param defaultValue - Default axis value (default: 0.0)
+     * @throws Error if bindingId or name already exists
+     *
+     * @example
+     * ```typescript
+     * import { InputDeviceType, KeyboardInput, GamepadInput } from '@utsp/types';
+     *
+     * registry.defineAxis(0, "MoveHorizontal", [
+     *   { sourceId: 0, type: InputDeviceType.Keyboard, negativeKey: KeyboardInput.ArrowLeft, positiveKey: KeyboardInput.ArrowRight },
+     *   { sourceId: 1, type: InputDeviceType.Gamepad, gamepadIndex: 0, axis: GamepadInput.LeftStickX }
+     * ], -1.0, 1.0, 0.0);
+     * ```
+     */
+    defineAxis(bindingId: number, name: string, sources?: AxisSource[], min?: number, max?: number, defaultValue?: number): void;
+    /**
+     * Defines a button binding
+     *
+     * @param bindingId - Unique button ID (0-255)
+     * @param name - Button name (e.g., "Jump", "Attack")
+     * @param sources - Physical sources (keyboard, gamepad, mouse, touch)
+     * @param defaultValue - Default button value (default: false)
+     * @throws Error if bindingId or name already exists
+     *
+     * @example
+     * ```typescript
+     * import { InputDeviceType, KeyboardInput, GamepadInput } from '@utsp/types';
+     *
+     * registry.defineButton(0, "Jump", [
+     *   { sourceId: 0, type: InputDeviceType.Keyboard, key: KeyboardInput.Space },
+     *   { sourceId: 1, type: InputDeviceType.Gamepad, gamepadIndex: 0, button: GamepadInput.A }
+     * ], false);
+     * ```
+     */
+    defineButton(bindingId: number, name: string, sources?: ButtonSource[], defaultValue?: boolean): void;
+    /**
+     * Evaluates an axis by summing all its sources
+     *
+     * This method takes raw values from each source (received from client)
+     * and sums them according to the following logic:
+     * 1. For each source: apply deadzone, scale, invert, sensitivity
+     * 2. Sum all values
+     * 3. Clamp between min and max
+     *
+     * Note: Raw source values are provided in sourceValues (Map<sourceId, value>)
+     *
+     * @param bindingId - Axis binding ID
+     * @param sourceValues - Map of raw source values (sourceId → value)
+     * @returns Final axis value (clamped), or defaultValue if binding not found
+     *
+     * @example
+     * ```typescript
+     * // Client sends: { sourceId: 0, value: -1.0 }, { sourceId: 1, value: 0.5 }
+     * const sourceValues = new Map([[0, -1.0], [1, 0.5]]);
+     * const axisValue = registry.evaluateAxis(0, sourceValues);
+     * // Result: -1.0 + 0.5 = -0.5 (clamped between min and max)
+     * ```
+     */
+    evaluateAxis(bindingId: number, sourceValues: Map<number, number>): number;
+    /**
+     * Evaluates a button with OR logic on all its sources
+     *
+     * A button is considered pressed if AT LEAST ONE source is pressed.
+     *
+     * @param bindingId - Button binding ID
+     * @param sourceValues - Map of source states (sourceId → pressed)
+     * @returns true if at least one source is pressed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Client sends: { sourceId: 0, pressed: false }, { sourceId: 1, pressed: true }
+     * const sourceValues = new Map([[0, false], [1, true]]);
+     * const buttonPressed = registry.evaluateButton(0, sourceValues);
+     * // Result: true (because at least one source is pressed)
+     * ```
+     */
+    evaluateButton(bindingId: number, sourceValues: Map<number, boolean>): boolean;
+    /**
+     * Generates a LoadPacket JSON containing all bindings
+     *
+     * This packet will be sent to the client via the Load channel to indicate
+     * which axes and buttons it should capture and send back.
+     *
+     * JSON format (not binary for now as sent rarely)
+     *
+     * @returns LoadPacket JSON as string
+     *
+     * @example
+     * ```typescript
+     * const packet = registry.toLoadPacket();
+     * websocket.send(packet); // Send to client
+     * ```
+     */
+    toLoadPacket(): string;
+    /**
+     * Generates a LoadPacket JSON as object
+     * (useful for inspection or tests)
+     *
+     * @returns LoadPacket as object
+     */
+    toLoadPacketObject(): InputBindingLoadPacket;
+    /**
+     * Retrieves an axis bindingId from its name
+     *
+     * @param name - Axis name
+     * @returns bindingId or null if not found
+     *
+     * @example
+     * ```typescript
+     * const id = registry.getAxisBindingId("MoveHorizontal");
+     * if (id !== null) {
+     *   console.log(`MoveHorizontal has bindingId ${id}`);
+     * }
+     * ```
+     */
+    getAxisBindingId(name: string): number | null;
+    /**
+     * Retrieves a button bindingId from its name
+     *
+     * @param name - Button name
+     * @returns bindingId or null if not found
+     *
+     * @example
+     * ```typescript
+     * const id = registry.getButtonBindingId("Jump");
+     * if (id !== null) {
+     *   console.log(`Jump has bindingId ${id}`);
+     * }
+     * ```
+     */
+    getButtonBindingId(name: string): number | null;
+    /**
+     * Retrieves an axis name from its bindingId
+     *
+     * @param bindingId - Binding ID
+     * @returns name or null if not found
+     *
+     * @example
+     * ```typescript
+     * const name = registry.getAxisName(0);
+     * console.log(name); // "MoveHorizontal"
+     * ```
+     */
+    getAxisName(bindingId: number): string | null;
+    /**
+     * Retrieves a button name from its bindingId
+     *
+     * @param bindingId - Binding ID
+     * @returns name or null if not found
+     *
+     * @example
+     * ```typescript
+     * const name = registry.getButtonName(0);
+     * console.log(name); // "Jump"
+     * ```
+     */
+    getButtonName(bindingId: number): string | null;
+    /**
+     * Retrieves a complete axis binding
+     *
+     * @param bindingId - Binding ID
+     * @returns binding or null if not found
+     */
+    getAxisBinding(bindingId: number): AxisBinding | null;
+    /**
+     * Retrieves a complete button binding
+     *
+     * @param bindingId - Binding ID
+     * @returns binding or null if not found
+     */
+    getButtonBinding(bindingId: number): ButtonBinding | null;
+    /**
+     * Checks if an axis is defined
+     *
+     * @param bindingId - Binding ID
+     * @returns true if defined
+     */
+    hasAxis(bindingId: number): boolean;
+    /**
+     * Checks if a button is defined
+     *
+     * @param bindingId - Binding ID
+     * @returns true if defined
+     */
+    hasButton(bindingId: number): boolean;
+    /**
+     * Counts the number of defined axes
+     *
+     * @returns number of axes
+     */
+    getAxisCount(): number;
+    /**
+     * Counts the number of defined buttons
+     *
+     * @returns number of buttons
+     */
+    getButtonCount(): number;
+    /**
+     * Retrieves all axes
+     *
+     * @returns array of all axis bindings
+     */
+    getAllAxes(): AxisBinding[];
+    /**
+     * Retrieves all buttons
+     *
+     * @returns array of all button bindings
+     */
+    getAllButtons(): ButtonBinding[];
+    /**
+     * Retrieves the current binding version
+     *
+     * @returns version (incremented with each modification)
+     */
+    getVersion(): number;
+    /**
+     * Removes an axis
+     *
+     * @param bindingId - Binding ID to remove
+     * @returns true if removed, false if not found
+     */
+    removeAxis(bindingId: number): boolean;
+    /**
+     * Removes a button
+     *
+     * @param bindingId - Binding ID to remove
+     * @returns true if removed, false if not found
+     */
+    removeButton(bindingId: number): boolean;
+    /**
+     * Removes all axes
+     */
+    clearAxes(): void;
+    /**
+     * Removes all buttons
+     */
+    clearButtons(): void;
+    /**
+     * Completely resets the registry
+     */
+    clear(): void;
+    /**
+     * Displays a summary of bindings (for debug)
+     *
+     * @returns formatted string
+     */
+    toString(): string;
+}
+
+/**
+ * Per-user performance statistics
+ * Collects user-specific metrics
+ */
+interface UserTickStats {
+    userId: string;
+    userName: string;
+    tick: number;
+    timestamp: number;
+    displayCount: number;
+    totalDisplayArea: number;
+    totalLayers: number;
+    visibleLayers: number;
+    staticLayers: number;
+    dynamicLayers: number;
+    totalOrders: number;
+    ordersByLayer: Map<number, number>;
+    staticPacketSize: number;
+    dynamicPacketSize: number;
+    totalPacketSize: number;
+    hasInput: boolean;
+    axisCount: number;
+    buttonCount: number;
+}
+declare class UserStats {
+    private enabled;
+    private currentStats;
+    private _userId;
+    private _userName;
+    constructor(userId: string, userName: string);
+    /**
+     * Enables or disables statistics collection
+     */
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    /** User ID */
+    get userId(): string;
+    /** User name */
+    get userName(): string;
+    /** Current tick number */
+    get tick(): number;
+    /** Current tick timestamp */
+    get timestamp(): number;
+    /** Number of displays */
+    get displayCount(): number;
+    /** Total display surface area (width × height) */
+    get totalDisplayArea(): number;
+    /** Total number of layers */
+    get totalLayers(): number;
+    /** Visible layers in displays */
+    get visibleLayers(): number;
+    /** Static layers */
+    get staticLayers(): number;
+    /** Dynamic layers */
+    get dynamicLayers(): number;
+    /** Total orders for this user */
+    get totalOrders(): number;
+    /** Orders par layer ID */
+    get ordersByLayer(): Map<number, number>;
+    /** Taille du packet statique (octets) */
+    get staticPacketSize(): number;
+    /** Taille du packet dynamique (octets) */
+    get dynamicPacketSize(): number;
+    /** Taille totale des packets (static + dynamic) */
+    get totalPacketSize(): number;
+    /** Estimated size after gzip compression (25% of original size) */
+    get compressedPacketSize(): number;
+    /** If user sent input this tick */
+    get hasInput(): boolean;
+    /** Number of bound axes */
+    get axisCount(): number;
+    /** Number of bound buttons */
+    get buttonCount(): number;
+    /**
+     * @internal
+     * Starts collection for a new tick
+     */
+    startTick(tickNumber: number): void;
+    /**
+     * @internal
+     * Records display information
+     */
+    recordDisplays(displayCount: number, totalArea: number): void;
+    /**
+     * @internal
+     * Enregistre les informations des layers
+     */
+    recordLayers(total: number, visible: number, staticCount: number, dynamicCount: number): void;
+    /**
+     * @internal
+     * Enregistre les orders d'un layer
+     */
+    recordLayerOrders(layerId: number, orderCount: number): void;
+    /**
+     * @internal
+     * Records network packet sizes
+     */
+    recordPacketSizes(staticSize: number, dynamicSize: number): void;
+    /**
+     * @internal
+     * Records input information
+     */
+    recordInput(hasInput: boolean, axisCount: number, buttonCount: number): void;
+    /**
+     * @internal
+     * Finalizes current tick stats
+     */
+    endTick(): void;
+    /**
+     * Resets statistics
+     */
+    reset(): void;
+}
+
+/**
+ * Represents a connected user with their displays and layers
+ *
+ * ARCHITECTURE (new protocol):
+ * - LAYERS are at the USER level (shared across all displays)
+ * - DISPLAYS are origins (cameras) that look into the world
+ * - Each display can see the same layers (if within its origin)
+ *
+ * @template TData - Application-specific data type (default: Record<string, any>)
+ */
+declare class User<TData = Record<string, any>> {
+    id: string;
+    name: string;
+    private displays;
+    private layers;
+    private spriteRegistry;
+    private mode;
+    private axes;
+    private buttons;
+    private textInputs;
+    private mouseX;
+    private mouseY;
+    private mouseOver;
+    private mouseDisplayId;
+    private touchPositions;
+    private activeTouchId;
+    private inputBindings;
+    private stats;
+    /**
+     * Application-specific data storage
+     * Use this to store game state, player data, or any custom information
+     */
+    data: TData;
+    constructor(id: string, name: string, mode: CoreMode);
+    /**
+     * Injects SpriteRegistry into the user (called by Core)
+     * @internal
+     */
+    setSpriteRegistry(registry: SpriteRegistry): void;
+    getDisplays(): Display[];
+    /**
+     * Adds a display to the user
+     *
+     * @param display - The display to add
+     */
+    addDisplay(display: Display): void;
+    /**
+     * Removes a display from the user
+     *
+     * @param display - The display to remove
+     * @returns true if display was removed, false otherwise
+     */
+    removeDisplay(display: Display): boolean;
+    /**
+     * Removes all displays from the user
+     */
+    clearDisplays(): void;
+    getLayers(): Layer[];
+    /**
+     * Adds a layer to the user
+     * Layers are shared across all displays
+     *
+     * @param layer - The layer to add
+     */
+    addLayer(layer: Layer): void;
+    /**
+     * Removes a layer from the user
+     *
+     * @param layer - The layer to remove
+     * @returns true if layer was removed, false otherwise
+     */
+    removeLayer(layer: Layer): boolean;
+    /**
+     * Removes all layers from the user
+     */
+    clearLayers(): void;
+    /**
+     * Updates mouse position (called by client)
+     *
+     * @param x - X position (0-255)
+     * @param y - Y position (0-255)
+     * @param over - Is mouse over the display?
+     *
+     * @example
+     * ```typescript
+     * user.setMousePosition(128, 64, true);
+     * ```
+     */
+    setMousePosition(x: number, y: number, over?: boolean): void;
+    /**
+     * Sets the position of a touch (multi-touch support)
+     *
+     * @param touchId - Touch ID (0-9)
+     * @param x - X position in display (0-255)
+     * @param y - Y position in display (0-255)
+     * @param over - If touch is active (true) or released (false)
+     * @param displayId - ID of concerned display (0-255)
+     *
+     * @example
+     * ```typescript
+     * // Touch ID 0 at position (128, 64)
+     * user.setTouchPosition(0, 128, 64, true, 0);
+     * ```
+     */
+    setTouchPosition(touchId: number, x: number, y: number, over?: boolean, displayId?: number): void;
+    /**
+     * Sets the value of a virtual axis
+     *
+     * Axes are floating point values between -1.0 and +1.0, typically used for:
+     * - Movement (Horizontal, Vertical)
+     * - Camera rotation (CameraX, CameraY)
+     * - Analog controls (Throttle, Steering)
+     *
+     * Axis name is free-form and defined by the application.
+     * Physical mapping (keyboard, gamepad, etc.) is handled by the client.
+     *
+     * @param axisName - Axis name (e.g., "Horizontal", "Vertical", "CameraX")
+     * @param value - Axis value (-1.0 to +1.0)
+     *
+     * @example
+     * ```typescript
+     * // Client side: map keys to axes
+     * user.setAxis("Horizontal", keyboard.arrowLeft ? -1.0 : keyboard.arrowRight ? 1.0 : 0.0);
+     * user.setAxis("Vertical", keyboard.arrowUp ? -1.0 : keyboard.arrowDown ? 1.0 : 0.0);
+     * user.setAxis("CameraX", gamepad.rightStickX); // -1.0 to +1.0
+     * ```
+     */
+    setAxis(axisName: string, value: number): void;
+    /**
+     * Gets the value of a virtual axis
+     *
+     * @param axisName - Axis name (e.g., "Horizontal", "Vertical")
+     * @returns Axis value (-1.0 to +1.0), or 0.0 if axis doesn't exist
+     *
+     * @example
+     * ```typescript
+     * // Server side: use axes for game logic
+     * const moveX = user.getAxis("Horizontal");
+     * const moveY = user.getAxis("Vertical");
+     * player.move(moveX, moveY);
+     * ```
+     */
+    getAxis(axisName: string): number;
+    /**
+     * Sets the state of a virtual button
+     *
+     * Buttons are boolean values used for actions:
+     * - Point actions (Jump, Fire, Interact)
+     * - Continuous states (Run, Crouch, Aim)
+     *
+     * Button name is free-form and defined by the application.
+     * Physical mapping (keyboard, gamepad, etc.) is handled by the client.
+     *
+     * @param buttonName - Button name (e.g., "Jump", "Fire", "Inventory")
+     * @param pressed - Button state (true = pressed, false = released)
+     *
+     * @example
+     * ```typescript
+     * // Client side: map keys to buttons
+     * user.setButton("Jump", keyboard.space || mouse.leftClick);
+     * user.setButton("Fire", mouse.rightClick);
+     * user.setButton("Inventory", keyboard.i);
+     * user.setButton("Sprint", keyboard.shift);
+     * ```
+     */
+    setButton(buttonName: string, pressed: boolean): void;
+    /**
+     * Checks if a virtual button is pressed
+     *
+     * @param buttonName - Button name (e.g., "Jump", "Fire")
+     * @returns true if button is pressed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Server side: use buttons for game logic
+     * if (user.getButton("Jump")) {
+     *   player.jump();
+     * }
+     *
+     * if (user.getButton("Fire")) {
+     *   player.shoot();
+     * }
+     *
+     * if (user.getButton("Sprint")) {
+     *   player.speed = 2.0;
+     * } else {
+     *   player.speed = 1.0;
+     * }
+     * ```
+     */
+    getButton(buttonName: string): boolean;
+    /**
+     * Checks if a virtual button was just pressed this frame
+     *
+     * @param buttonName - Button name (e.g., "Jump", "Fire")
+     * @returns true if button just transitioned from false→true
+     *
+     * @example
+     * ```typescript
+     * // Server side: single-shot actions
+     * if (user.getButtonJustPressed("Jump")) {
+     *   player.jump(); // Fires once per press, not continuously
+     * }
+     *
+     * if (user.getButtonJustPressed("ToggleInventory")) {
+     *   ui.toggleInventory(); // Won't toggle 5 times per click
+     * }
+     * ```
+     */
+    getButtonJustPressed(buttonName: string): boolean;
+    /**
+     * Checks if a virtual button was just released this frame
+     *
+     * @param buttonName - Button name (e.g., "Fire", "ChargeShot")
+     * @returns true if button just transitioned from true→false
+     *
+     * @example
+     * ```typescript
+     * // Server side: charge and release mechanics
+     * if (user.getButton("ChargeShot")) {
+     *   weapon.charge(); // Accumulate power while held
+     * }
+     * if (user.getButtonJustReleased("ChargeShot")) {
+     *   weapon.fireChargedShot(); // Release when button released
+     * }
+     * ```
+     */
+    getButtonJustReleased(buttonName: string): boolean;
+    /**
+     * Sets text input events for this frame
+     * Called internally by input decoding system
+     *
+     * @param inputs - Array of key strings (e.g., ['a', 'Backspace', 'Enter'])
+     * @internal
+     */
+    setTextInputs(inputs: string[]): void;
+    /**
+     * Gets text input events for this frame
+     * Use this in your update loop to handle input boxes, chat, etc.
+     *
+     * @returns Array of key strings typed this frame
+     *
+     * @example
+     * ```typescript
+     * // Server side: handle input box
+     * const textInputs = user.getTextInputs();
+     * for (const key of textInputs) {
+     *   if (key.length === 1) {
+     *     inputBox.addChar(key); // Regular character
+     *   } else if (key === 'Backspace') {
+     *     inputBox.deleteChar();
+     *   } else if (key === 'Enter') {
+     *     inputBox.submit();
+     *   }
+     * }
+     * ```
+     */
+    getTextInputs(): string[];
+    /**
+     * Clears text input events (called after frame processing)
+     * @internal
+     */
+    clearTextInputs(): void;
+    /**
+     * Gets all defined axis names
+     *
+     * @returns Array of axis names
+     *
+     * @example
+     * ```typescript
+     * const axisNames = user.getAxisNames();
+     * console.log(axisNames); // ["Horizontal", "Vertical", "CameraX", "CameraY"]
+     * ```
+     */
+    getAxisNames(): string[];
+    /**
+     * Gets all defined button names
+     *
+     * @returns Array of button names
+     *
+     * @example
+     * ```typescript
+     * const buttonNames = user.getButtonNames();
+     * console.log(buttonNames); // ["Jump", "Fire", "Inventory", "Interact"]
+     * ```
+     */
+    getButtonNames(): string[];
+    /**
+     * Resets all axes to 0.0
+     *
+     * @example
+     * ```typescript
+     * user.clearAxes();
+     * console.log(user.getAxis("Horizontal")); // 0.0
+     * ```
+     */
+    clearAxes(): void;
+    /**
+     * Resets all buttons to false
+     *
+     * @example
+     * ```typescript
+     * user.clearButtons();
+     * console.log(user.getButton("Jump")); // false
+     * ```
+     */
+    clearButtons(): void;
+    /**
+     * Gets detailed information about mouse position
+     *
+     * Returns mouse position in multiple coordinate spaces:
+     * - displayId: ID of the hovered display (or null if none)
+     * - localX/localY: Position in the display (0 to sizeX/sizeY)
+     * - worldX/worldY: Position in the virtual world (origin + local)
+     *
+     * Note: For now, we consider the mouse always hovers display 0
+     * if mouseOver is true and at least one display exists.
+     *
+     * @returns Mouse position information, or null if no display
+     *
+     * @example
+     * ```typescript
+     * const mouseInfo = user.getMouseDisplayInfo();
+     * if (mouseInfo) {
+     *   console.log(`Mouse over display ${mouseInfo.displayId}`);
+     *   console.log(`Local: ${mouseInfo.localX}, ${mouseInfo.localY}`);
+     *   console.log(`World: ${mouseInfo.worldX}, ${mouseInfo.worldY}`);
+     * }
+     * ```
+     */
+    getMouseDisplayInfo(): {
+        displayId: number | null;
+        localX: number;
+        localY: number;
+        worldX: number;
+        worldY: number;
+    } | null;
+    /**
+     * Gets position information for a touch relative to the display
+     *
+     * @param touchId - Touch ID (0-9), default = 0 (first finger)
+     * @returns Touch information (displayId, localX, localY, worldX, worldY) or null
+     *
+     * @example
+     * ```typescript
+     * const touchInfo = user.getTouchDisplayInfo(0);
+     * if (touchInfo) {
+     *   console.log(`Touch 0 over display ${touchInfo.displayId}`);
+     *   console.log(`Local: ${touchInfo.localX}, ${touchInfo.localY}`);
+     *   console.log(`World: ${touchInfo.worldX}, ${touchInfo.worldY}`);
+     * }
+     * ```
+     */
+    getTouchDisplayInfo(touchId?: number): {
+        displayId: number | null;
+        localX: number;
+        localY: number;
+        worldX: number;
+        worldY: number;
+    } | null;
+    /**
+     * Checks if the mouse is currently over a display
+     *
+     * @returns true if mouse is hovering a display, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (user.getIsMouseOnADisplay()) {
+     *   const info = user.getMouseDisplayInfo();
+     *   console.log(`Hovering display ${info.displayId}`);
+     * }
+     * ```
+     */
+    getIsMouseOnADisplay(): boolean;
+    /**
+     * Gets the ID of the display currently hovered by the mouse
+     *
+     * @returns Display ID (0-255) or null if no display is hovered
+     *
+     * @example
+     * ```typescript
+     * const hoveredDisplayId = user.getMouseDisplayHover();
+     * if (hoveredDisplayId !== null) {
+     *   console.log(`Hovering display ${hoveredDisplayId}`);
+     * }
+     * ```
+     */
+    getMouseDisplayHover(): number | null;
+    /**
+     * Finds a layer by its ID
+     *
+     * @param id - ID of the layer to find
+     * @returns Found layer or null
+     * @internal - Used for UpdatePacket reconstruction
+     */
+    private findLayerById;
+    /**
+     * Applies an UpdatePacket to this user (CLIENT-SIDE RECONSTRUCTION)
+     *
+     * This method reconstructs the user state from an UpdatePacket
+     * received from the server. It updates displays (viewports) and layers
+     * incrementally according to updateFlags.
+     *
+     * IMPORTANT: This method must be called in CLIENT mode only.
+     * The server generates packets, the client applies them.
+     *
+     * @param packet - Decoded UpdatePacket received from server
+     *
+     * @example
+     * ```typescript
+     * // Client side (ClientRuntime)
+     * const decoder = new UpdatePacketDecoder();
+     * const packet = decoder.decode(receivedBuffer);
+     * user.applyUpdate(packet);
+     * ```
+     */
+    applyUpdate(packet: UpdatePacket): void;
+    /**
+     * Updates displays from an UpdatePacket
+     *
+     * Adjusts the number of displays and updates their origins/sizes.
+     *
+     * @private
+     * @param networkDisplays - Displays from packet
+     */
+    private updateDisplaysFromPacket;
+    /**
+     * Updates layers from an UpdatePacket (INCREMENTAL LOGIC)
+     *
+     * This method reconstructs layers according to updateFlags:
+     * - 0x01: Update origin
+     * - 0x02: Update z-order
+     * - 0x04: Update orders (replace or add according to SET/ADD flag)
+     *
+     * If a layer doesn't exist yet, it is created automatically.
+     *
+     * IMPORTANT: In client mode, orders are automatically rasterized
+     * when calling setOrders() / addOrders().
+     *
+     * @private
+     * @param networkLayers - Layers from packet with their updateFlags
+     */
+    private updateLayersFromPacket;
+    /**
+     * Defines an axis binding
+     *
+     * Associates a bindingId (0-255) with an axis name and its physical sources.
+     * The client will receive this mapping via a JSON LoadPacket.
+     *
+     * Sources are summed on the server side after receiving raw values.
+     *
+     * @param bindingId - Unique axis ID (0-255)
+     * @param name - Axis name (e.g., "MoveHorizontal", "CameraX")
+     * @param sources - Physical sources (keyboard, gamepad, mouse, gyro, touch)
+     * @param min - Minimum value (default: -1.0)
+     * @param max - Maximum value (default: +1.0)
+     * @param defaultValue - Default value (default: 0.0)
+     *
+     * @example
+     * ```typescript
+     * import { InputDeviceType, KeyboardInput, GamepadInput } from '@utsp/types';
+     *
+     * user.defineAxisBinding(0, "MoveHorizontal", [
+     *   { sourceId: 0, type: InputDeviceType.Keyboard, negativeKey: KeyboardInput.ArrowLeft, positiveKey: KeyboardInput.ArrowRight },
+     *   { sourceId: 1, type: InputDeviceType.Gamepad, gamepadIndex: 0, axis: GamepadInput.LeftStickX }
+     * ], -1.0, 1.0, 0.0);
+     * ```
+     */
+    defineAxisBinding(bindingId: number, name: string, sources?: AxisSource[], min?: number, max?: number, defaultValue?: number): void;
+    /**
+     * Defines a button binding
+     *
+     * Associates a bindingId (0-255) with a button name and its physical sources.
+     * Sources use OR logic (at least one pressed source = button pressed).
+     *
+     * @param bindingId - Unique button ID (0-255)
+     * @param name - Button name (e.g., "Jump", "Attack")
+     * @param sources - Physical sources (keyboard, gamepad, mouse, touch)
+     * @param defaultValue - Default value (default: false)
+     *
+     * @example
+     * ```typescript
+     * import { InputDeviceType, KeyboardInput, GamepadInput } from '@utsp/types';
+     *
+     * user.defineButtonBinding(0, "Jump", [
+     *   { sourceId: 0, type: InputDeviceType.Keyboard, key: KeyboardInput.Space },
+     *   { sourceId: 1, type: InputDeviceType.Gamepad, gamepadIndex: 0, button: GamepadInput.A }
+     * ], false);
+     * ```
+     */
+    defineButtonBinding(bindingId: number, name: string, sources?: ButtonSource[], defaultValue?: boolean): void;
+    /**
+     * Defines multiple axis bindings at once
+     *
+     * @param axes - Array of axis definitions
+     *
+     * @example
+     * ```typescript
+     * import { InputDeviceType, KeyboardInput } from '@utsp/types';
+     *
+     * user.defineAxisBindings([
+     *   {
+     *     bindingId: 0,
+     *     name: "MoveHorizontal",
+     *     sources: [
+     *       { sourceId: 0, type: InputDeviceType.Keyboard, negativeKey: KeyboardInput.ArrowLeft, positiveKey: KeyboardInput.ArrowRight }
+     *     ]
+     *   },
+     *   { bindingId: 1, name: "MoveVertical", sources: [] },
+     * ]);
+     * ```
+     */
+    defineAxisBindings(axes: Array<{
+        bindingId: number;
+        name: string;
+        sources?: AxisSource[];
+        min?: number;
+        max?: number;
+        defaultValue?: number;
+    }>): void;
+    /**
+     * Defines multiple button bindings at once
+     *
+     * @param buttons - Array of button definitions
+     *
+     * @example
+     * ```typescript
+     * import { InputDeviceType, KeyboardInput } from '@utsp/types';
+     *
+     * user.defineButtonBindings([
+     *   {
+     *     bindingId: 0,
+     *     name: "Jump",
+     *     sources: [
+     *       { sourceId: 0, type: InputDeviceType.Keyboard, key: KeyboardInput.Space }
+     *     ]
+     *   },
+     *   { bindingId: 1, name: "Attack", sources: [] },
+     * ]);
+     * ```
+     */
+    defineButtonBindings(buttons: Array<{
+        bindingId: number;
+        name: string;
+        sources?: ButtonSource[];
+        defaultValue?: boolean;
+    }>): void;
+    /**
+     * Generates the JSON LoadPacket containing input bindings
+     *
+     * This packet must be sent to the client via the Load channel to indicate
+     * which axes and buttons it should capture and send back.
+     *
+     * Format: JSON string (not binary for now as it's sent rarely)
+     *
+     * @returns JSON LoadPacket as string
+     *
+     * @example
+     * ```typescript
+     * // Server: Define bindings
+     * user.defineAxisBinding(0, "MoveHorizontal");
+     * user.defineAxisBinding(1, "MoveVertical");
+     * user.defineButtonBinding(0, "Jump");
+     *
+     * // Generate and send to client
+     * const packet = user.getInputBindingsLoadPacket();
+     * websocket.send(packet);
+     * ```
+     */
+    getInputBindingsLoadPacket(): string;
+    /**
+     * Applies Input Bindings received from server (CLIENT-SIDE)
+     *
+     * This method parses the bindings JSON and configures them in the registry.
+     * The client can then capture inputs and send them compressed.
+     *
+     * @param json - JSON string of bindings from getInputBindingsLoadPacket()
+     *
+     * @example
+     * ```typescript
+     * // Client side
+     * websocket.on('input-bindings', (json: string) => {
+     *   user.applyInputBindingsLoadPacket(json);
+     *   console.log('Input bindings configured');
+     * });
+     * ```
+     */
+    applyInputBindingsLoadPacket(json: string): void;
+    /**
+     * Gets this user's InputBindingRegistry
+     *
+     * @returns InputBindingRegistry instance
+     *
+     * @example
+     * ```typescript
+     * const registry = user.getInputBindingRegistry();
+     * console.log(registry.toString());
+     * console.log(`Axes: ${registry.getAxisCount()}`);
+     * console.log(`Buttons: ${registry.getButtonCount()}`);
+     * ```
+     */
+    getInputBindingRegistry(): InputBindingRegistry;
+    /**
+     * Gets the UserStats object to access this user's statistics
+     *
+     * @returns The user's UserStats instance
+     *
+     * @example
+     * ```typescript
+     * // Enable stats
+     * user.getStats().setEnabled(true);
+     *
+     * // After a tick...
+     * const stats = user.getStats();
+     * console.log(`User ${stats.userName}:`);
+     * console.log(`  Displays: ${stats.displayCount}`);
+     * console.log(`  Layers: ${stats.visibleLayers}/${stats.totalLayers}`);
+     * console.log(`  Orders: ${stats.totalOrders}`);
+     * console.log(`  Packet size: ${stats.totalPacketSize} bytes`);
+     * ```
+     */
+    getStats(): UserStats;
+    /**
+     * Gets the bindingId of an axis from its name
+     *
+     * @param name - Axis name
+     * @returns bindingId or null if not found
+     */
+    getAxisBindingId(name: string): number | null;
+    /**
+     * Gets the bindingId of a button from its name
+     *
+     * @param name - Button name
+     * @returns bindingId or null if not found
+     */
+    getButtonBindingId(name: string): number | null;
+    /**
+     * Decodes and applies a compressed input buffer received from client (format v3)
+     *
+     * This method:
+     * 1. Decodes the binary buffer (v3 MINIMAL format - without counts)
+     * 2. Stores values in axes/buttons Maps
+     * 3. Updates mouse position + displayId
+     *
+     * Format v3: Buffer does NOT contain axes/buttons counts.
+     * Server uses its internal registry to know the expected structure.
+     *
+     * IMPORTANT: Client and server must have the SAME bindings defined!
+     *
+     * @param buffer - Encoded buffer received from client via WebSocket
+     *
+     * @example
+     * ```typescript
+     * // Server receives buffer from client
+     * websocket.on('message', (data) => {
+     *   const buffer = new Uint8Array(data);
+     *   user.decodeAndApplyCompressedInput(buffer);
+     *
+     *   // Values are now available
+     *   const move = user.getAxis("MoveHorizontal");
+     *   if (user.getButton("Jump")) { ... }
+     * });
+     * ```
+     */
+    decodeAndApplyCompressedInput(buffer: Uint8Array): void;
+}
+
+/**
+ * UTSP engine performance statistics
+ * Collects metrics per tick for analysis and optimization
+ */
+interface TickStats {
+    tick: number;
+    timestamp: number;
+    totalOrders: number;
+    ordersByLayer: Map<number, number>;
+    ordersByType: Map<number, number>;
+    totalLayers: number;
+    visibleLayers: number;
+    layersPerDisplay: Map<number, number>;
+    updatePacketSize: number;
+    displayHeaderSize: number;
+    layerHeaderSize: number;
+    orderDataSize: number;
+    compressionRatio: number;
+    totalCells: number;
+    nonEmptyCells: number;
+    cellsWithBackground: number;
+    rasterizationTimeMs: number;
+    encodingTimeMs: number;
+}
+declare class CoreStats {
+    private enabled;
+    private currentStats;
+    /**
+     * Enables or disables statistics collection
+     */
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    /** Current tick number (0 if no stats) */
+    get tick(): number;
+    /** Current tick timestamp */
+    get timestamp(): number;
+    /** Total orders processed this tick */
+    get totalOrders(): number;
+    /** Orders per layer ID */
+    get ordersByLayer(): Map<number, number>;
+    /** Orders per type (0x01, 0x02, etc.) */
+    get ordersByType(): Map<number, number>;
+    /** Nombre total de layers */
+    get totalLayers(): number;
+    /** Layers visibles (qui intersectent un display) */
+    get visibleLayers(): number;
+    /** Layers visibles par display ID */
+    get layersPerDisplay(): Map<number, number>;
+    /** Total encoded UpdatePacket size (bytes) */
+    get updatePacketSize(): number;
+    /** Display header size (bytes) */
+    get displayHeaderSize(): number;
+    /** Layer header size (bytes) */
+    get layerHeaderSize(): number;
+    /** Order data size (bytes) */
+    get orderDataSize(): number;
+    /** Estimated gzip compression ratio (0.25 = 75% compression) */
+    get compressionRatio(): number;
+    /** Estimated size after gzip compression (bytes) */
+    get compressedPacketSize(): number;
+    /** Total number of rendered cells */
+    get totalCells(): number;
+    /** Non-empty cells (char !== ' ') */
+    get nonEmptyCells(): number;
+    /** Cells with colored background */
+    get cellsWithBackground(): number;
+    /** Rasterization time (ms) */
+    get rasterizationTimeMs(): number;
+    /** Encoding time (ms) */
+    get encodingTimeMs(): number;
+    /** Static/dynamic split information for the last processed user */
+    get packetSplit(): {
+        userId: string;
+        displayCount: number;
+        staticLayerCount: number;
+        dynamicLayerCount: number;
+    } | undefined;
+    /** Details of all layers processed this tick */
+    get layerDetails(): Array<{
+        layerId: number;
+        isStatic: boolean;
+        orderCount: number;
+        updateFlags: number;
+    }> | undefined;
+    /**
+     * Starts collecting statistics for a new tick
+     */
+    startTick(tickNumber: number): void;
+    /**
+     * Records orders for a layer
+     */
+    recordLayerOrders(layerId: number, orders: any[]): void;
+    /**
+     * Records the number of layers
+     */
+    recordLayers(total: number, visible: number): void;
+    /**
+     * Records visible layers per display
+     */
+    recordDisplayLayers(displayId: number, layerCount: number): void;
+    /**
+     * Records the encoded UpdatePacket size
+     */
+    recordUpdatePacketSize(totalBytes: number, displayHeaderBytes: number, layerHeaderBytes: number, orderDataBytes: number): void;
+    /**
+     * Records static/dynamic split information
+     */
+    recordPacketSplit(userId: string, displayCount: number, staticLayerCount: number, dynamicLayerCount: number): void;
+    /**
+     * Records individual layer information
+     */
+    recordLayerInfo(layerId: number, isStatic: boolean, orderCount: number, updateFlags: number): void;
+    /**
+     * Records rendered cell statistics
+     */
+    recordRenderStats(totalCells: number, nonEmptyCells: number, cellsWithBg: number): void;
+    /**
+     * Records rasterization time
+     */
+    recordRasterizationTime(timeMs: number): void;
+    /**
+     * Records encoding time
+     */
+    recordEncodingTime(timeMs: number): void;
+    /**
+     * Finalizes stats for the current tick
+     * Stats remain available until the next startTick()
+     */
+    endTick(): void;
+    /**
+     * Resets statistics
+     */
+    reset(): void;
+}
+
+/**
+ * WebFontRegistry - Registry for CSS-based fonts
+ */
+
+/**
+ * Registry for managing WebFont instances
+ * Each font is identified by a unique fontId (0-255)
+ */
+declare class WebFontRegistry {
+    private fonts;
+    /**
+     * Load a new WebFont into the registry
+     * @param fontId Unique font identifier (0-255)
+     * @param config WebFont configuration
+     * @throws Error if font ID already exists
+     */
+    loadFont(fontId: number, config: WebFontConfig): void;
+    /**
+     * Get a WebFont by ID
+     * @param fontId Font identifier
+     * @returns WebFont instance or undefined if not found
+     */
+    getFont(fontId: number): WebFont | undefined;
+    /**
+     * Check if a font exists in the registry
+     * @param fontId Font identifier
+     * @returns true if font exists, false otherwise
+     */
+    hasFont(fontId: number): boolean;
+    /**
+     * Remove a WebFont from the registry
+     * @param fontId Font identifier
+     * @returns true if font was removed, false if not found
+     */
+    unloadFont(fontId: number): boolean;
+    /**
+     * Remove all fonts from the registry
+     */
+    clearFonts(): void;
+    /**
+     * Get all font IDs in the registry
+     * @returns Array of font IDs, sorted in ascending order
+     */
+    getFontIds(): number[];
+    /**
+     * Get all WebFont instances in the registry
+     * @returns Array of WebFont instances, sorted by font ID
+     */
+    getAllFonts(): WebFont[];
+    /**
+     * Get the number of fonts in the registry
+     * @returns Number of fonts
+     */
+    getFontCount(): number;
+}
+
+/**
+ * BitmapFontRegistry - Registry for pixel-based bitmap fonts
+ */
+
+/**
+ * Registry for managing BitmapFont instances
+ * Each font is identified by a unique fontId (0-255)
+ * BitmapFonts correspond to LoadType 0x04 (Charset) in UTSP protocol
+ */
+declare class BitmapFontRegistry {
+    private fonts;
+    /**
+     * Load a new BitmapFont into the registry
+     * @param fontId Unique font identifier (0-255)
+     * @param config BitmapFont configuration
+     * @throws Error if font ID already exists
+     */
+    loadFont(fontId: number, config: BitmapFontConfig): void;
+    /**
+     * Get a BitmapFont by ID
+     * @param fontId Font identifier
+     * @returns BitmapFont instance or undefined if not found
+     */
+    getFont(fontId: number): BitmapFont | undefined;
+    /**
+     * Check if a font exists in the registry
+     * @param fontId Font identifier
+     * @returns true if font exists, false otherwise
+     */
+    hasFont(fontId: number): boolean;
+    /**
+     * Remove a BitmapFont from the registry
+     * @param fontId Font identifier
+     * @returns true if font was removed, false if not found
+     */
+    unloadFont(fontId: number): boolean;
+    /**
+     * Remove all fonts from the registry
+     */
+    clearFonts(): void;
+    /**
+     * Get all font IDs in the registry
+     * @returns Array of font IDs, sorted in ascending order
+     */
+    getFontIds(): number[];
+    /**
+     * Get all BitmapFont instances in the registry
+     * @returns Array of BitmapFont instances, sorted by font ID
+     */
+    getAllFonts(): BitmapFont[];
+    /**
+     * Get the number of fonts in the registry
+     * @returns Number of fonts
+     */
+    getFontCount(): number;
+}
+
+/**
+ * Engine execution context type
+ */
+type CoreMode = 'server' | 'client' | 'standalone';
+/**
+ * UTSP engine configuration options
+ */
+interface CoreOptions {
+    /**
+     * Execution mode: "server", "client" or "standalone"
+     *
+     * - "server": Server-side engine
+     *   → Marks layers as dirty (change tracking)
+     *   → Does NOT rasterize (CPU savings, client-side rasterization)
+     *   → Manages multiple users (limited by maxUsers)
+     *
+     * - "client": Client-side engine
+     *   → Does NOT mark as dirty (no tracking needed)
+     *   → Rasterizes immediately (local rendering for display)
+     *   → Manages ONE local user only (fixed limit)
+     *
+     * - "standalone": Standalone engine (preview, tests, debug)
+     *   → Marks as dirty AND rasterizes
+     *   → Manages multiple users
+     *   → Useful for getRenderState(), tests, simulations
+     *
+     * @default "server"
+     */
+    mode?: CoreMode;
+    /**
+     * Maximum number of users allowed (server mode only)
+     *
+     * In client mode, this option is ignored (fixed limit of 1 user)
+     *
+     * @default 64
+     */
+    maxUsers?: number;
+    /**
+     * Enable strict validations (useful in development)
+     *
+     * @default false
+     */
+    strictMode?: boolean;
+}
+/**
+ * Core - UTSP data management engine
+ *
+ * Passive API: no loop, no network, no callbacks.
+ * Parent package (utsp-server, utsp-client) controls execution flow.
+ *
+ * Responsibilities:
+ * - Store and manage users
+ * - Provide data manipulation methods
+ * - Pure and predictable API
+ *
+ * What the core does NOT do:
+ * - No tick loop (server/client manages it)
+ * - No network (server/client manages it)
+ * - No callbacks/events (core is a passive slave)
+ */
+declare class Core {
+    private users;
+    private readonly mode;
+    private readonly maxUsers;
+    private readonly strictMode;
+    private currentTick;
+    private encoder;
+    private displayRasterizer;
+    private colorPalette;
+    private static readonly ANSI_VGA_COLORS;
+    private stats;
+    private spriteRegistry;
+    private webFontRegistry;
+    private bitmapFontRegistry;
+    private activeWebFontId;
+    private _renderCallCount;
+    private onPaletteChangedCallback?;
+    private onBitmapFontChangedCallback?;
+    /**
+     * Creates a new UTSP engine instance
+     *
+     * @param options - Configuration options
+     *
+     * @example
+     * ```typescript
+     * // Server with 100 max users
+     * const engine = new Core({
+     *   mode: "server",
+     *   maxUsers: 100
+     * });
+     *
+     * // Simple client
+     * const engine = new Core({
+     *   mode: "client"
+     * });
+     *
+     * // Default mode (server)
+     * const engine = new Core();
+     * ```
+     */
+    constructor(options?: CoreOptions);
+    /**
+     * Initialize default color palette (15 reserved UI colors + free colors)
+     * @private
+     */
+    private initializeDefaultPalette;
+    /**
+     * Returns current execution mode
+     *
+     * @returns "server", "client" or "standalone"
+     */
+    getMode(): CoreMode;
+    /**
+     * Returns maximum allowed users
+     *
+     * @returns Max number of users
+     */
+    getMaxUsers(): number;
+    /**
+     * Indicates if strict mode is enabled
+     *
+     * @returns true if strict mode is enabled
+     */
+    isStrictMode(): boolean;
+    /**
+     * Checks if core is in server mode
+     *
+     * @returns true if server mode
+     */
+    isServer(): boolean;
+    /**
+     * Checks if core is in client mode
+     *
+     * @returns true if client mode
+     */
+    isClient(): boolean;
+    /**
+     * Checks if core is in standalone mode
+     *
+     * @returns true if standalone mode
+     */
+    isStandalone(): boolean;
+    /**
+     * Creates a new user in the engine
+     *
+     * @param id - Unique user ID (string)
+     * @param name - User name
+     * @returns Created user
+     * @throws Error if ID already exists
+     *
+     * @example
+     * ```typescript
+     * const engine = new Core();
+     * const user = engine.createUser("user1", "Alice");
+     * ```
+     */
+    createUser(id: string, name: string): User;
+    /**
+     * Gets a user by ID
+     *
+     * @param id - User ID (string)
+     * @returns The user or null if not found
+     *
+     * @example
+     * ```typescript
+     * const user = engine.getUser("user1");
+     * if (user) {
+     *   console.log(user.name);
+     * }
+     * ```
+     */
+    getUser(id: string): User | null;
+    /**
+     * Gets all users from the engine
+     *
+     * @returns Array of all users
+     *
+     * @example
+     * ```typescript
+     * for (const user of engine.getUsers()) {
+     *   console.log(`User ${user.id}: ${user.name}`);
+     * }
+     * ```
+     */
+    getUsers(): User[];
+    /**
+     * Checks if a user exists
+     *
+     * @param id - User ID (string)
+     * @returns true if user exists
+     *
+     * @example
+     * ```typescript
+     * if (engine.hasUser("user1")) {
+     *   console.log("User exists");
+     * }
+     * ```
+     */
+    hasUser(id: string): boolean;
+    /**
+     * Removes a user from the engine
+     *
+     * @param id - User ID to remove (string)
+     * @returns true if user was removed, false if not found
+     *
+     * @example
+     * ```typescript
+     * const removed = engine.removeUser("user1");
+     * if (removed) {
+     *   console.log("User removed successfully");
+     * }
+     * ```
+     */
+    removeUser(id: string): boolean;
+    /**
+     * Gets total number of users
+     *
+     * @returns Number of users
+     *
+     * @example
+     * ```typescript
+     * console.log(`${engine.getUserCount()} users connected`);
+     * ```
+     */
+    getUserCount(): number;
+    /**
+     * Removes all users from the engine
+     *
+     * Useful for complete reset or cleanup before server shutdown
+     *
+     * @example
+     * ```typescript
+     * engine.clearAllUsers(); // All users removed
+     * console.log(engine.getUserCount()); // 0
+     * ```
+     */
+    clearAllUsers(): void;
+    /**
+     * Sets a color in the palette
+     *
+     * 🎨 RESERVED COLORS:
+     * - ColorIDs 240-254: Standard UI palette (CANNOT be modified)
+     * - ColorID 255: Skip/transparent color (CANNOT be modified)
+     * - ColorIDs 0-239: Free for application use (240 colors available)
+     *
+     * @param colorId - Color ID (0-239 only, 240-255 are reserved)
+     * @param r - Red component (0-255)
+     * @param g - Green component (0-255)
+     * @param b - Blue component (0-255)
+     * @param a - Alpha component (0-255, default: 255 = opaque)
+     * @param e - Emission component (0-255, default: 0 = no emission)
+     * @throws Error if colorId is reserved (240-255) or out of bounds
+     *
+     * @example
+     * ```typescript
+     * // ✅ Set a custom color in free range
+     * engine.setColor(0, 255, 0, 0, 255, 0);
+     *
+     * // ✅ Set a semi-transparent color
+     * engine.setColor(1, 0, 255, 0, 128, 0);
+     *
+     * // ✅ Set an emissive color (bloom/glow)
+     * engine.setColor(2, 0, 255, 255, 255, 255);
+     *
+     * // ❌ ERROR: ColorIDs 240-254 are reserved (UI palette)
+     * // engine.setColor(245, 255, 0, 0); // Throws error
+     *
+     * // ❌ ERROR: ColorID 255 is reserved (skip color)
+     * // engine.setColor(255, 255, 255, 255); // Throws error
+     * ```
+     */
+    setColor(colorId: number, r: number, g: number, b: number, a?: number, e?: number): void;
+    /**
+     * Register a callback to be notified when palette changes
+     *
+     * Use this to update the renderer when palette is modified via loadPalette() or setColor().
+     *
+     * @param callback - Function called with the new palette
+     *
+     * @example
+     * ```typescript
+     * core.onPaletteChanged((palette) => {
+     *   const paletteArray = Array.from(palette.values());
+     *   renderer.setPalette(paletteArray);
+     * });
+     * ```
+     */
+    onPaletteChanged(callback: (palette: Map<number, {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        e: number;
+    }>) => void): void;
+    /**
+     * Register a callback to be notified when a bitmap font is loaded.
+     *
+     * Use this to update the renderer when a font is loaded via loadBitmapFontById().
+     *
+     * @param callback - Function called with the fontId
+     *
+     * @example
+     * ```typescript
+     * core.onBitmapFontChanged((fontId) => {
+     *   const font = core.getBitmapFont(fontId);
+     *   if (font) renderer.uploadFontToGPU(font);
+     * });
+     * ```
+     */
+    onBitmapFontChanged(callback: (fontId: number) => void): void;
+    /**
+     * Gets a color from the palette
+     *
+     * @param colorId - Color ID (0-255)
+     * @returns RGBA+E color or null if ID doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const color = engine.getColor(16);
+     * if (color) {
+     *   console.log(`RGB: ${color.r}, ${color.g}, ${color.b}`);
+     *   console.log(`Emission: ${color.e}`);
+     * }
+     * ```
+     */
+    getColor(colorId: number): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        e: number;
+    } | null;
+    /**
+     * Loads a complete color palette
+     *
+     * Replaces existing colors for the specified IDs.
+     *
+     * 🎨 RESERVED COLORS (automatically forced):
+     * - ColorIDs 240-254: Standard UI palette (will be overridden even if provided)
+     * - ColorID 255: Skip/transparent color (will be overridden even if provided)
+     * - ColorIDs 0-239: Free for application use
+     *
+     * @param colors - Array of colors to load (any ColorIDs 0-255)
+     *
+     * @example
+     * ```typescript
+     * engine.loadPalette([
+     *   { colorId: 0, r: 255, g: 0, b: 0, a: 255, e: 0 },     // ✅ Custom color (free range)
+     *   { colorId: 1, r: 255, g: 255, b: 255, a: 255, e: 0 }, // ✅ Custom white
+     *   { colorId: 2, r: 255, g: 0, b: 0, a: 255, e: 0 },     // ✅ Custom red
+     *   { colorId: 3, r: 0, g: 255, b: 255, a: 255, e: 255 }, // ✅ Bright cyan
+     *   { colorId: 250, r: 255, g: 0, b: 0, a: 255, e: 0 },   // ⚠️ Will be ignored (reserved)
+     * ]);
+     * // ColorIDs 240-254 and 255 will be forced to standard values
+     * ```
+     */
+    loadPalette(colors: Array<{
+        colorId: number;
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        e?: number;
+    }>): void;
+    /**
+     * Gets the entire color palette
+     *
+     * @returns Map of colors by ID
+     *
+     * @example
+     * ```typescript
+     * const palette = engine.getPalette();
+     * palette.forEach((color, id) => {
+     *   console.log(`Color ${id}: rgba(${color.r}, ${color.g}, ${color.b}, ${color.a}) emission: ${color.e}`);
+     * });
+     * ```
+     */
+    getPalette(): Map<number, {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        e: number;
+    }>;
+    /**
+     * Resets palette to default VGA colors
+     *
+     * @example
+     * ```typescript
+     * engine.resetPalette(); // Back to VGA 16 colors palette
+     * ```
+     */
+    resetPalette(): void;
+    /**
+     * Converts a color ID to a CSS rgba() string
+     *
+     * Useful for HTML/Canvas rendering
+     *
+     * @param colorId - Color ID (0-255)
+     * @returns CSS string "rgba(r, g, b, a)" or null if ID doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const cssColor = engine.getColorCSS(16);
+     * if (cssColor) {
+     *   ctx.fillStyle = cssColor; // "rgba(255, 0, 0, 1)"
+     * }
+     * ```
+     */
+    getColorCSS(colorId: number): string | null;
+    /**
+     * Gets all user IDs
+     *
+     * @returns Array of IDs (strings)
+     *
+     * @example
+     * ```typescript
+     * const ids = engine.getUserIds(); // ["user1", "user2", ...]
+     * ```
+     */
+    getUserIds(): string[];
+    /**
+     * Iterates over all users with a callback
+     *
+     * @param callback - Function called for each user
+     *
+     * @example
+     * ```typescript
+     * engine.forEachUser((user) => {
+     *   user.displays.forEach(d => d.clear());
+     * });
+     * ```
+     */
+    forEachUser(callback: (user: User) => void): void;
+    /**
+     * Filters users according to a predicate
+     *
+     * @param predicate - Filter function
+     * @returns Array of matching users
+     *
+     * @example
+     * ```typescript
+     * const activeUsers = engine.filterUsers(user => user.displays.length > 0);
+     * ```
+     */
+    filterUsers(predicate: (user: User) => boolean): User[];
+    /**
+     * Finds a user according to a predicate
+     *
+     * @param predicate - Search function
+     * @returns First matching user or undefined
+     *
+     * @example
+     * ```typescript
+     * const alice = engine.findUser(user => user.name === "Alice");
+     * ```
+     */
+    findUser(predicate: (user: User) => boolean): User | undefined;
+    /**
+     * Gets current tick number
+     *
+     * @returns Current tick number
+     *
+     * @example
+     * ```typescript
+     * console.log(`Current tick: ${engine.getCurrentTick()}`);
+     * ```
+     */
+    getCurrentTick(): number;
+    /**
+     * Gets CoreStats object to access performance statistics
+     *
+     * @returns The engine's CoreStats instance
+     *
+     * @example
+     * ```typescript
+     * // Enable stats
+     * engine.getStats().setEnabled(true);
+     *
+     * // After a few ticks...
+     * const report = engine.getStats().generateReport(10);
+     * console.log(report);
+     *
+     * // Access averages
+     * const avg = engine.getStats().getAverageStats(100);
+     * console.log(`Avg packet size: ${avg.avgPacketSize} bytes`);
+     * ```
+     */
+    getStats(): CoreStats;
+    /**
+     * Ends current tick and generates update packets for all users
+     *
+     * This method:
+     * 1. Encodes displays and layers of each user into binary packets
+     * 2. Increments tick counter
+     * 3. Returns a Map with packets ready to send
+     *
+     * Server/client can then send these packets over the network
+     *
+     * @returns Map<userId, packet> - Encoded packets for each user
+     *
+     * @example
+     * ```typescript
+     * const packets = engine.endTick();
+     * packets.forEach((packet, userId) => {
+     *   networkSend(userId, packet);
+     * });
+     * ```
+     */
+    endTick(): Map<string, Uint8Array>;
+    /**
+     * Ends tick and generates SEPARATE packets for static and dynamic layers
+     *
+     * This method allows sending:
+     * - STATIC Layers on a reliable Socket.IO channel (guaranteed delivery)
+     * - DYNAMIC Layers on a volatile Socket.IO channel (can drop packets)
+     *
+     * Optimization: Static layers (background, pattern) must arrive,
+     * but dynamic layers (particles, trail) can skip frames.
+     *
+     * @returns Map<userId, { static: Uint8Array | null, dynamic: Uint8Array | null }>
+     *
+     * @example
+     * ```typescript
+     * const splitPackets = engine.endTickSplit();
+     * splitPackets.forEach(({ static: staticPacket, dynamic: dynamicPacket }, userId) => {
+     *   if (staticPacket) {
+     *     network.sendToClient(userId, 'update-static', staticPacket); // Reliable
+     *   }
+     *   if (dynamicPacket) {
+     *     network.sendToClientVolatile(userId, 'update-dynamic', dynamicPacket); // Volatile
+     *   }
+     * });
+     * ```
+     */
+    endTickSplit(): Map<string, {
+        static: Uint8Array | null;
+        dynamic: Uint8Array | null;
+    }>;
+    /**
+     * Generates a complete snapshot of a user's state
+     *
+     * Unlike endTick() which generates incremental updates
+     * (dynamic layers + static layers not yet sent), getSnapshot()
+     * encodes ALL layers (static + dynamic), ignoring the
+     * hasSentStatic flag.
+     *
+     * The snapshot represents the complete state at time T, while
+     * updates are cumulative deltas.
+     *
+     * Use cases:
+     * - Initial connection: Send complete state to new client
+     * - Reconnection: Resynchronize client after disconnection
+     * - Spectators: Allow observer to join mid-game
+     * - Save: Capture state for persistence
+     * - Migration: Transfer user to another server
+     * - Replay: Record initial state for replay
+     *
+     * @param userId - User ID
+     * @returns Complete binary packet (Uint8Array) or null if user doesn't exist
+     *
+     * @example
+     * ```typescript
+     * // Initial connection
+     * socket.on('connect', (userId) => {
+     *   const snapshot = engine.getSnapshot(userId);
+     *   socket.emit('initial-state', snapshot);
+     * });
+     *
+     * // Reconnection after disconnect
+     * socket.on('reconnect', (userId) => {
+     *   const snapshot = engine.getSnapshot(userId);
+     *   socket.emit('resync-state', snapshot);
+     * });
+     *
+     * // Spectator joining during game
+     * socket.on('spectate', (spectatorId, targetUserId) => {
+     *   const snapshot = engine.getSnapshot(targetUserId);
+     *   socket.to(spectatorId).emit('spectate-state', snapshot);
+     * });
+     * ```
+     */
+    getSnapshot(userId: string): Uint8Array | null;
+    /**
+     * Resets tick counter to 0
+     *
+     * Useful for complete reset or starting a new session
+     *
+     * @example
+     * ```typescript
+     * engine.resetTick();
+     * console.log(engine.getCurrentTick()); // 0
+     * ```
+     */
+    resetTick(): void;
+    /**
+     * Applies a decoded UpdatePacket to a user (CLIENT-SIDE RECONSTRUCTION)
+     *
+     * This method is the main entry point for reconstructing a user's state
+     * on the client side from a packet received from the server.
+     *
+     * It performs:
+     * 1. User validation (must exist)
+     * 2. Update application via user.applyUpdate()
+     * 3. Automatic rasterization in client mode
+     *
+     * IMPORTANT: This method should ONLY be called in CLIENT mode.
+     * The server generates packets via endTick(), the client applies them.
+     *
+     * @param userId - Target user ID
+     * @param packet - Decoded UpdatePacket (via UpdatePacketDecoder)
+     * @returns true if update was applied, false if user doesn't exist
+     *
+     * @example
+     * ```typescript
+     * // Client side (ClientRuntime)
+     * import { UpdatePacketDecoder } from '@utsp/core';
+     *
+     * const decoder = new UpdatePacketDecoder();
+     *
+     * websocket.on('update', (buffer: Uint8Array) => {
+     *   // Decode binary packet
+     *   const packet = decoder.decode(buffer);
+     *
+     *   // Apply to local user
+     *   const applied = core.applyUpdatePacket('user1', packet);
+     *
+     *   if (applied) {
+     *     // Rendering is automatically updated via getRenderState()
+     *     console.log(`Update tick ${packet.tick} applied`);
+     *   }
+     * });
+     * ```
+     */
+    applyUpdatePacket(userId: string, packet: UpdatePacket): boolean;
+    /**
+     * Applies a raw UpdatePacket buffer (decodes then applies)
+     *
+     * Convenient version that combines decoding + application in one step.
+     *
+     * @param userId - Target user ID
+     * @param buffer - Binary buffer received from server
+     * @returns true if update was applied, false if user doesn't exist
+     *
+     * @example
+     * ```typescript
+     * // Simplified version for runtime
+     * websocket.on('update', (buffer: Uint8Array) => {
+     *   core.applyUpdatePacketBuffer('user1', buffer);
+     * });
+     * ```
+     */
+    applyUpdatePacketBuffer(userId: string, buffer: Uint8Array): boolean;
+    /**
+     * Applies a LoadPacket received from the server (CLIENT-SIDE)
+     *
+     * This method automatically decodes the binary buffer and applies
+     * the asset to the Core according to its LoadType:
+     * - ColorPalette → loadPalette()
+     * - Sprite → loadUnicolorSprites()
+     * - MulticolorSprite → loadMulticolorSprites()
+     * - BitmapFont → loadBitmapFontById()
+     * - WebFont → loadWebFontById()
+     * - Sound → (TODO: implement audio system)
+     *
+     * @param buffer - Encoded binary buffer received via WebSocket
+     * @returns true if applied successfully, false on error
+     *
+     * @example
+     * ```typescript
+     * // Client side (ClientRuntime)
+     * websocket.on('load', (buffer: Uint8Array) => {
+     *   core.applyLoadPacket(buffer);
+     * });
+     * ```
+     */
+    applyLoadPacket(buffer: Uint8Array): boolean;
+    /**
+     * Generates a LoadPacket for the current color palette (SERVER-SIDE)
+     *
+     * Encodes the complete palette in binary format ready to send to clients.
+     *
+     * @returns Encoded binary buffer (or null if palette empty)
+     *
+     * @example
+     * ```typescript
+     * // Server side
+     * const palettePacket = core.generatePaletteLoadPacket();
+     * if (palettePacket) {
+     *   websocket.emit('load', palettePacket);
+     * }
+     * ```
+     */
+    generatePaletteLoadPacket(): Uint8Array | null;
+    /**
+     * Generates a LoadPacket for all unicolor sprites (SERVER-SIDE)
+     *
+     * @returns Encoded binary buffer (or null if no sprites)
+     *
+     * @example
+     * ```typescript
+     * const spritesPacket = core.generateUnicolorSpritesLoadPacket();
+     * if (spritesPacket) {
+     *   websocket.emit('load', spritesPacket);
+     * }
+     * ```
+     */
+    generateUnicolorSpritesLoadPacket(): Uint8Array | null;
+    /**
+     * Generates a LoadPacket for all multicolor sprites (SERVER-SIDE)
+     *
+     * @returns Encoded binary buffer (or null if no sprites)
+     *
+     * @example
+     * ```typescript
+     * const spritesPacket = core.generateMulticolorSpritesLoadPacket();
+     * if (spritesPacket) {
+     *   websocket.emit('load', spritesPacket);
+     * }
+     * ```
+     */
+    generateMulticolorSpritesLoadPacket(): Uint8Array | null;
+    /**
+     * Generates LoadPackets for all web fonts (SERVER-SIDE)
+     *
+     * Returns an array of buffers (one font = one packet)
+     *
+     * @returns Array of encoded buffers (or empty array if no fonts)
+     *
+     * @example
+     * ```typescript
+     * const fontPackets = core.generateWebFontsLoadPackets();
+     * fontPackets.forEach(packet => {
+     *   websocket.emit('load', packet);
+     * });
+     * ```
+     */
+    generateWebFontsLoadPackets(): Uint8Array[];
+    /**
+     * Generates LoadPackets for all bitmap fonts (SERVER-SIDE)
+     *
+     * Returns an array of buffers (one font = one packet)
+     *
+     * @returns Array of encoded buffers (or empty array if no fonts)
+     *
+     * @example
+     * ```typescript
+     * const fontPackets = core.generateBitmapFontsLoadPackets();
+     * fontPackets.forEach(packet => {
+     *   websocket.emit('load', packet);
+     * });
+     * ```
+     */
+    generateBitmapFontsLoadPackets(): Uint8Array[];
+    /**
+     * Generates ALL LoadPackets (palette + sprites + fonts) (SERVER-SIDE)
+     *
+     * Useful when a client initially connects to send them
+     * all assets at once.
+     *
+     * @returns Array of all encoded buffers ready to send
+     *
+     * @example
+     * ```typescript
+     * // When a new client connects
+     * socket.on('join', (userId) => {
+     *   const packets = core.generateAllLoadPackets();
+     *   packets.forEach(packet => {
+     *     socket.to(userId).emit('load', packet);
+     *   });
+     * });
+     * ```
+     */
+    generateAllLoadPackets(): Uint8Array[];
+    /**
+     * Applies Input Bindings to a user (CLIENT-SIDE)
+     *
+     * This method allows the client to configure input bindings
+     * that it must capture and send back to the server in compressed form.
+     *
+     * @param userId - Target user ID
+     * @param json - JSON string of bindings from user.getInputBindingsLoadPacket()
+     * @returns true if applied successfully, false if user doesn't exist
+     *
+     * @example
+     * ```typescript
+     * // Client side
+     * websocket.on('input-bindings', (json: string) => {
+     *   core.applyInputBindingsLoadPacket('user1', json);
+     * });
+     * ```
+     */
+    applyInputBindingsLoadPacket(userId: string, json: string): boolean;
+    /**
+     * Generates render state for a user
+     *
+     * This method converts a user's displays and orders into a readable
+     * format with CSS colors, useful for:
+     * - Render debugging
+     * - Server-side preview
+     * - Automated tests
+     * - Snapshot generation
+     *
+     * @param userId - User ID
+     * @returns Render state or null if user doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const state = engine.getRenderState("user1");
+     * if (state) {
+     *   console.log(`Tick: ${state.tick}`);
+     *   for (const display of state.displays) {
+     *     console.log(`Display ${display.width}x${display.height}`);
+     *     // Display cells
+     *     for (let y = 0; y < display.height; y++) {
+     *       let line = "";
+     *       for (let x = 0; x < display.width; x++) {
+     *         const cell = display.cells[y * display.width + x];
+     *         line += cell.char;
+     *       }
+     *       console.log(line);
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    getRenderState(userId: string): UserRenderState | null;
+    /**
+     * Generates render state for all users
+     *
+     * @returns Map of render states by userId
+     *
+     * @example
+     * ```typescript
+     * const allStates = engine.getAllRenderStates();
+     * allStates.forEach((state, userId) => {
+     *   console.log(`User ${userId}: ${state.displays.length} displays`);
+     * });
+     * ```
+     */
+    getAllRenderStates(): Map<string, UserRenderState>;
+    /**
+     * Enables or disables statistics collection
+     *
+     * @param enabled - true to enable, false to disable
+     *
+     * @example
+     * ```typescript
+     * engine.enableStats(true);
+     * // ... run game loop ...
+     * const report = engine.getStatsReport();
+     * console.log(report);
+     * ```
+     */
+    enableStats(enabled: boolean): void;
+    /**
+     * Returns the statistics instance
+     *
+     * @returns The CoreStats object
+     */
+    getStatsInstance(): CoreStats;
+    /**
+     * Resets statistics for the current tick
+     *
+     * @example
+     * ```typescript
+     * engine.resetStats();
+     * ```
+     */
+    resetStats(): void;
+    /**
+     * Loads unicolor sprites from a LoadPacket
+     *
+     * Unicolor sprites only store charCode (1 byte per cell).
+     * Colors are applied during rendering via Orders.
+     *
+     * @param loadData - Loading data from a LoadPacket (type 0x02)
+     *
+     * @example
+     * ```typescript
+     * // Load a 4x4 unicolor sprite
+     * engine.loadUnicolorSprites({
+     *   sprites: [
+     *     {
+     *       spriteId: 1,
+     *       sizeX: 4,
+     *       sizeY: 4,
+     *       data: [
+     *         0x2588, 0x2588, 0x2588, 0x2588,
+     *         0x2588, 0x0020, 0x0020, 0x2588,
+     *         0x2588, 0x0020, 0x0020, 0x2588,
+     *         0x2588, 0x2588, 0x2588, 0x2588
+     *       ]
+     *     }
+     *   ]
+     * });
+     * ```
+     */
+    loadUnicolorSprites(loadData: SpriteLoad): void;
+    /**
+     * Loads multicolor sprites from a LoadPacket
+     *
+     * Multicolor sprites store charCode + fgColorId + bgColorId (3 bytes per cell).
+     * Optimized for sprites with lots of visual detail.
+     *
+     * @param loadData - Loading data from a LoadPacket (type 0x03)
+     *
+     * @example
+     * ```typescript
+     * // Load a 2x2 multicolor sprite
+     * engine.loadMulticolorSprites({
+     *   sprites: [
+     *     {
+     *       spriteId: 10,
+     *       sizeX: 2,
+     *       sizeY: 2,
+     *       data: [
+     *         { charCode: 0x2588, fgColorId: 12, bgColorId: 0 },
+     *         { charCode: 0x2588, fgColorId: 14, bgColorId: 0 },
+     *         { charCode: 0x2588, fgColorId: 14, bgColorId: 0 },
+     *         { charCode: 0x2588, fgColorId: 12, bgColorId: 0 }
+     *       ]
+     *     }
+     *   ]
+     * });
+     * ```
+     */
+    loadMulticolorSprites(loadData: MulticolorSpriteLoad): void;
+    /**
+     * Unloads a unicolor sprite from memory
+     *
+     * @param spriteId - ID of the sprite to unload
+     * @returns true if sprite was found and removed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const removed = engine.unloadUnicolorSprite(1);
+     * if (removed) {
+     *   console.log("Sprite 1 unloaded");
+     * }
+     * ```
+     */
+    unloadUnicolorSprite(spriteId: number): boolean;
+    /**
+     * Unloads a multicolor sprite from memory
+     *
+     * @param spriteId - ID of the sprite to unload
+     * @returns true if sprite was found and removed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const removed = engine.unloadMulticolorSprite(10);
+     * if (removed) {
+     *   console.log("Sprite 10 unloaded");
+     * }
+     * ```
+     */
+    unloadMulticolorSprite(spriteId: number): boolean;
+    /**
+     * Clears all unicolor sprites from memory
+     *
+     * @example
+     * ```typescript
+     * engine.clearUnicolorSprites();
+     * console.log("All unicolor sprites have been unloaded");
+     * ```
+     */
+    clearUnicolorSprites(): void;
+    /**
+     * Clears all multicolor sprites from memory
+     *
+     * @example
+     * ```typescript
+     * engine.clearMulticolorSprites();
+     * console.log("All multicolor sprites have been unloaded");
+     * ```
+     */
+    clearMulticolorSprites(): void;
+    /**
+     * Clears all sprites (unicolor and multicolor)
+     *
+     * @example
+     * ```typescript
+     * engine.clearAllSprites();
+     * console.log("All sprites have been unloaded");
+     * ```
+     */
+    clearAllSprites(): void;
+    /**
+     * Counts the number of loaded unicolor sprites
+     *
+     * @returns Number of unicolor sprites in memory
+     *
+     * @example
+     * ```typescript
+     * const count = engine.getUnicolorSpriteCount();
+     * console.log(`${count} unicolor sprites loaded`);
+     * ```
+     */
+    getUnicolorSpriteCount(): number;
+    /**
+     * Counts the number of loaded multicolor sprites
+     *
+     * @returns Number of multicolor sprites in memory
+     *
+     * @example
+     * ```typescript
+     * const count = engine.getMulticolorSpriteCount();
+     * console.log(`${count} multicolor sprites loaded`);
+     * ```
+     */
+    getMulticolorSpriteCount(): number;
+    /**
+     * Counts total number of loaded sprites (unicolor + multicolor)
+     *
+     * @returns Total number of sprites in memory
+     *
+     * @example
+     * ```typescript
+     * const total = engine.getTotalSpriteCount();
+     * console.log(`${total} sprites total`);
+     * ```
+     */
+    getTotalSpriteCount(): number;
+    /**
+     * Checks if a unicolor sprite exists
+     *
+     * @param spriteId - ID of the sprite to check
+     * @returns true if sprite exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (engine.hasUnicolorSprite(1)) {
+     *   console.log("Sprite 1 available");
+     * }
+     * ```
+     */
+    hasUnicolorSprite(spriteId: number): boolean;
+    /**
+     * Checks if a multicolor sprite exists
+     *
+     * @param spriteId - ID of the sprite to check
+     * @returns true if sprite exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (engine.hasMulticolorSprite(10)) {
+     *   console.log("Sprite 10 available");
+     * }
+     * ```
+     */
+    hasMulticolorSprite(spriteId: number): boolean;
+    /**
+     * Gets the sprite registry (for rasterizer only)
+     * @internal
+     */
+    getSpriteRegistry(): SpriteRegistry;
+    /**
+     * Loads the default web font (Courier New, 16px, monospace)
+     *
+     * This font is loaded automatically during engine initialization.
+     * It uses fontId 0 (reserved for the default font).
+     *
+     * @private
+     */
+    private loadDefaultWebFont;
+    /**
+     * Loads a web font into the registry
+     *
+     * Web fonts use the CSS system for rendering (fontFamily, fontSize, etc.)
+     * FontID 0 is reserved for the default font.
+     *
+     * @param font - WebFont instance to load
+     * @throws Error if fontId is already in use
+     *
+     * @example
+     * ```typescript
+     * const customFont = new WebFont(1, {
+     *   fontFamily: "Arial",
+     *   fontSize: 20,
+     *   fontWeight: "bold"
+     * });
+     * engine.loadWebFont(customFont);
+     * ```
+     */
+    loadWebFont(font: WebFont): void;
+    /**
+     * Gets a web font by its ID
+     *
+     * @param fontId - Font ID (0-255)
+     * @returns The WebFont instance or null if not found
+     *
+     * @example
+     * ```typescript
+     * const font = engine.getWebFont(1);
+     * if (font) {
+     *   console.log(font.toCSS());
+     * }
+     * ```
+     */
+    getWebFont(fontId: number): WebFont | null;
+    /**
+     * Checks if a web font exists
+     *
+     * @param fontId - Font ID (0-255)
+     * @returns true if font exists
+     *
+     * @example
+     * ```typescript
+     * if (engine.hasWebFont(1)) {
+     *   console.log("Font 1 is loaded");
+     * }
+     * ```
+     */
+    hasWebFont(fontId: number): boolean;
+    /**
+     * Unloads a web font from the registry
+     *
+     * Note: Cannot unload the default font (fontId 0)
+     *
+     * @param fontId - Font ID to unload (1-255)
+     * @returns true if font was unloaded
+     * @throws Error if attempting to unload default font (fontId 0)
+     *
+     * @example
+     * ```typescript
+     * const removed = engine.unloadWebFont(1);
+     * if (removed) {
+     *   console.log("Font 1 unloaded");
+     * }
+     * ```
+     */
+    unloadWebFont(fontId: number): boolean;
+    /**
+     * Clears all web fonts (except default font)
+     *
+     * @example
+     * ```typescript
+     * engine.clearWebFonts();
+     * console.log("All custom web fonts cleared");
+     * ```
+     */
+    clearWebFonts(): void;
+    /**
+     * Sets the active web font
+     *
+     * The active font is used by default for character rendering.
+     *
+     * @param fontId - Font ID to activate (0-255)
+     * @throws Error if font doesn't exist
+     *
+     * @example
+     * ```typescript
+     * engine.setActiveWebFont(1);
+     * console.log(`Active font: ${engine.getActiveWebFontId()}`);
+     * ```
+     */
+    setActiveWebFont(fontId: number): void;
+    /**
+     * Gets the active web font ID
+     *
+     * @returns Active font ID (0-255)
+     *
+     * @example
+     * ```typescript
+     * const activeFontId = engine.getActiveWebFontId();
+     * console.log(`Current font: ${activeFontId}`);
+     * ```
+     */
+    getActiveWebFontId(): number;
+    /**
+     * Gets the active web font
+     *
+     * @returns The active WebFont instance
+     *
+     * @example
+     * ```typescript
+     * const activeFont = engine.getActiveWebFont();
+     * console.log(activeFont.toCSS());
+     * ```
+     */
+    getActiveWebFont(): WebFont;
+    /**
+     * Counts the number of loaded web fonts
+     *
+     * @returns Number of web fonts in memory
+     *
+     * @example
+     * ```typescript
+     * const count = engine.getWebFontCount();
+     * console.log(`${count} web fonts loaded`);
+     * ```
+     */
+    getWebFontCount(): number;
+    /**
+     * Gets all loaded web font IDs
+     *
+     * @returns Array of fontIds (0-255)
+     *
+     * @example
+     * ```typescript
+     * const fontIds = engine.getWebFontIds();
+     * console.log(`Loaded fonts: ${fontIds.join(", ")}`);
+     * ```
+     */
+    getWebFontIds(): number[];
+    /**
+     * Gets the web font registry
+     *
+     * @returns WebFontRegistry instance
+     *
+     * @example
+     * ```typescript
+     * const registry = engine.getWebFontRegistry();
+     * console.log(`Total fonts: ${registry.getFontCount()}`);
+     * ```
+     */
+    getWebFontRegistry(): WebFontRegistry;
+    /**
+     * Gets the bitmap font registry
+     *
+     * @returns BitmapFontRegistry instance
+     *
+     * @example
+     * ```typescript
+     * const registry = engine.getBitmapFontRegistry();
+     * console.log(`Total fonts: ${registry.getFontCount()}`);
+     * ```
+     */
+    getBitmapFontRegistry(): BitmapFontRegistry;
+    /**
+     * Loads a web font directly with its ID and configuration
+     *
+     * Simplified method that creates and loads the font in one step.
+     *
+     * @param fontId - Unique font ID (0-255, 0 reserved for default font)
+     * @param config - Web font configuration
+     * @throws Error if fontId is already in use
+     *
+     * @example
+     * ```typescript
+     * // Load a custom font
+     * engine.loadWebFontById(1, {
+     *   fontFamily: "Arial",
+     *   fontSize: 20,
+     *   fontWeight: "bold"
+     * });
+     *
+     * // Load a monospace font
+     * engine.loadWebFontById(2, {
+     *   fontFamily: "Consolas",
+     *   fontSize: 16,
+     *   charSpacing: 2
+     * });
+     * ```
+     */
+    loadWebFontById(fontId: number, config: WebFontConfig): void;
+    /**
+     * Loads a bitmap font directly with its ID and configuration
+     *
+     * Simplified method that loads the bitmap font in one step.
+     *
+     * @param fontId - Unique font ID (0-255)
+     * @param config - Bitmap font configuration (dimensions + glyphs)
+     * @throws Error if fontId is already in use
+     *
+     * @example
+     * ```typescript
+     * import { createASCII8x8FontLoad } from "utsp-core";
+     *
+     * // Load the ASCII 8×8 font
+     * const fontLoad = createASCII8x8FontLoad(1);
+     * engine.loadBitmapFontById(1, fontLoad.fontConfig);
+     *
+     * // Load a custom bitmap font
+     * engine.loadBitmapFontById(10, {
+     *   charWidth: 16,
+     *   charHeight: 16,
+     *   glyphs: new Map([
+     *     [65, new Uint8Array([...])], // 'A'
+     *     [66, new Uint8Array([...])], // 'B'
+     *   ])
+     * });
+     * ```
+     */
+    loadBitmapFontById(fontId: number, config: BitmapFontConfig): void;
+    /**
+     * Gets a bitmap font by its ID
+     *
+     * @param fontId - Font ID (0-255)
+     * @returns The BitmapFont instance or null if not found
+     *
+     * @example
+     * ```typescript
+     * const font = engine.getBitmapFont(1);
+     * if (font) {
+     *   console.log(`Font dimensions: ${font.getCharWidth()}×${font.getCharHeight()}`);
+     *   console.log(`Glyphs: ${font.getGlyphCount()}`);
+     * }
+     * ```
+     */
+    getBitmapFont(fontId: number): BitmapFont | null;
+    /**
+     * Checks if a bitmap font exists
+     *
+     * @param fontId - Font ID (0-255)
+     * @returns true if font exists
+     *
+     * @example
+     * ```typescript
+     * if (engine.hasBitmapFont(1)) {
+     *   console.log("Font 1 is loaded");
+     * }
+     * ```
+     */
+    hasBitmapFont(fontId: number): boolean;
+    /**
+     * Unloads a bitmap font from the registry
+     *
+     * @param fontId - Font ID to unload (0-255)
+     * @returns true if font was unloaded
+     *
+     * @example
+     * ```typescript
+     * const removed = engine.unloadBitmapFont(1);
+     * if (removed) {
+     *   console.log("Font 1 unloaded");
+     * }
+     * ```
+     */
+    unloadBitmapFont(fontId: number): boolean;
+    /**
+     * Clears all bitmap fonts
+     *
+     * @example
+     * ```typescript
+     * engine.clearBitmapFonts();
+     * console.log("All bitmap fonts cleared");
+     * ```
+     */
+    clearBitmapFonts(): void;
+    /**
+     * Counts the number of loaded bitmap fonts
+     *
+     * @returns Number of bitmap fonts in memory
+     *
+     * @example
+     * ```typescript
+     * const count = engine.getBitmapFontCount();
+     * console.log(`${count} bitmap fonts loaded`);
+     * ```
+     */
+    getBitmapFontCount(): number;
+    /**
+     * Gets all loaded bitmap font IDs
+     *
+     * @returns Array of fontIds (0-255)
+     *
+     * @example
+     * ```typescript
+     * const fontIds = engine.getBitmapFontIds();
+     * console.log(`Loaded bitmap fonts: ${fontIds.join(", ")}`);
+     * ```
+     */
+    getBitmapFontIds(): number[];
+}
+
+/**
+ * ASCII 8×8 Bitmap Font (Extended - IBM CP437)
+ * Complete character set including:
+ * - ASCII printable characters (32-126)
+ * - Extended ASCII box drawing and blocks (128-255)
+ *
+ * Each character is 8 pixels wide by 8 pixels tall
+ * 1 bit per pixel, packed into 8 bytes per character
+ *
+ * Box drawing characters support:
+ * - Single line borders: ┌ ─ ┐ │ └ ┘ ├ ┤ ┬ ┴ ┼
+ * - Double line borders: ╔ ═ ╗ ║ ╚ ╝ ╠ ╣ ╦ ╩ ╬
+ * - Block characters: █ ▓ ▒ ░ ▀ ▄ ▌ ▐
+ */
+/**
+ * 8×8 bitmap font data
+ * Key: ASCII/Extended ASCII character code (32-126, 176-223)
+ * Value: 8 bytes representing the character bitmap
+ */
+declare const ASCII_8X8_FONT: Map<number, Uint8Array>;
+/**
+ * Get the bitmap data for a specific ASCII character
+ * @param charCode ASCII character code (32-126) or Extended ASCII (176-223)
+ * @returns 8-byte bitmap or undefined if character not found
+ */
+declare function getCharBitmap(charCode: number): Uint8Array | undefined;
+/**
+ * Check if a character has a bitmap defined
+ * @param charCode ASCII character code
+ * @returns true if character is defined
+ */
+declare function hasChar(charCode: number): boolean;
+/**
+ * Get all available character codes
+ * @returns Array of ASCII codes (32-126) and Extended ASCII (176-223)
+ */
+declare function getAllCharCodes(): number[];
+/**
+ * Create a BitmapFontLoad packet for the complete ASCII font
+ * @param fontId Font identifier (0-255)
+ * @returns BitmapFontLoad object ready for encoding
+ */
+declare function createASCII8x8FontLoad(fontId: number): {
+    loadType: number;
+    fontId: number;
+    width: number;
+    height: number;
+    cellWidth: number;
+    cellHeight: number;
+    characters: Array<{
+        charCode: number;
+        bitmap: Uint8Array;
+    }>;
+};
+/**
+ * Get BitmapFontConfig for the complete ASCII 8×8 font
+ * This is a convenience function to get the config directly
+ * for use with UTSPCore.loadBitmapFontById()
+ * @returns BitmapFontConfig ready to use
+ */
+declare function getASCII8x8FontConfig(): {
+    charWidth: number;
+    charHeight: number;
+    glyphs: Map<number, Uint8Array>;
+};
+
+/**
+ * CompressedInputPacket - Ultra-compact binary format for inputs (V3)
+ *
+ * Architecture:
+ * - CLIENT: Evaluates sources → Compresses → Sends
+ * - SERVER: Receives → Decompresses → Stores in axes/buttons Maps
+ *
+ * MINIMALIST Format (V3):
+ * ┌────────┬───────────┬─────────────┬────────┬──────────┐
+ * │ Tick   │ Axes      │ Buttons     │ Mouse  │ Flags    │
+ * │ 8 bytes│ N bytes   │ M bytes     │ 3 bytes│ 1 byte   │
+ * └────────┴───────────┴─────────────┴────────┴──────────┘
+ *
+ * Tick (8 bytes)       : Frame number (uint64, little-endian)
+ * Axes (N bytes)       : 1 byte per axis (int8, -127 to +127)
+ * Buttons (M bytes)    : Bitpacking (8 buttons per byte, ⌈ButtonCount/8⌉)
+ * Mouse (3 bytes)      : displayId (1) + mouseX (1) + mouseY (1)
+ * Flags (1 byte)       : Bit 0 = mouseOverDisplay
+ *
+ * Note: axisCount and buttonCount are known in advance via InputBindingRegistry
+ * Example: 5 axes + 12 buttons = 8 + 5 + 2 + 3 + 1 = 19 bytes
+ */
+/**
+ * Represents a compressed input on the server side (after decoding)
+ *
+ * This structure contains already decompressed values:
+ * - Axes: float between -1.0 and +1.0
+ * - Buttons: boolean
+ * - Mouse: position + display + flags
+ * - TextInputs: array of key strings for text input (e.g., ['a', 'Backspace', 'Enter'])
+ */
+interface CompressedInputPacket {
+    /** Frame number (tick) - uint64 */
+    tick: bigint;
+    /** Axis values (bindingId → value between -1.0 and +1.0) */
+    axes: Map<number, number>;
+    /** Button states (bindingId → pressed) */
+    buttons: Map<number, boolean>;
+    /** ID of the display where the mouse is located (0-255) */
+    displayId: number;
+    /** Mouse X position (0-255) */
+    mouseX: number;
+    /** Mouse Y position (0-255) */
+    mouseY: number;
+    /** Is the mouse over a display? (vs off-display area) */
+    mouseOverDisplay: boolean;
+    /** Text input events (e.g., ['a', 'Backspace', 'Enter']) - for input boxes, chat, etc. */
+    textInputs: string[];
+}
+/**
+ * Creates an empty CompressedInputPacket
+ *
+ * @param tick - Frame number (bigint)
+ * @returns An empty packet with default values
+ */
+declare function createEmptyCompressedInputPacket(tick?: bigint): CompressedInputPacket;
+/**
+ * Helper: Encodes a float (-1.0 to +1.0) to int8 (-128 to +127)
+ *
+ * @param value - Value between -1.0 and +1.0
+ * @returns Value between -128 and +127
+ *
+ * @example
+ * ```typescript
+ * encodeAxisToInt8(-1.0)  // -127
+ * encodeAxisToInt8(0.0)   // 0
+ * encodeAxisToInt8(1.0)   // 127
+ * encodeAxisToInt8(-0.5)  // -63
+ * ```
+ */
+declare function encodeAxisToInt8(value: number): number;
+/**
+ * Helper: Decodes an int8 (-128 to +127) to float (-1.0 to +1.0)
+ *
+ * @param value - Value between -128 and +127
+ * @returns Value between -1.0 and +1.0
+ *
+ * @example
+ * ```typescript
+ * decodeInt8ToAxis(-127)  // -1.0
+ * decodeInt8ToAxis(0)     // 0.0
+ * decodeInt8ToAxis(127)   // 1.0
+ * decodeInt8ToAxis(-63)   // -0.496...
+ * ```
+ */
+declare function decodeInt8ToAxis(value: number): number;
+/**
+ * Helper: Calculates the number of bytes needed for N buttons (bitpacking)
+ *
+ * @param buttonCount - Number of buttons
+ * @returns Number of bytes needed
+ *
+ * @example
+ * ```typescript
+ * getButtonByteCount(0)   // 0
+ * getButtonByteCount(7)   // 1
+ * getButtonByteCount(8)   // 1
+ * getButtonByteCount(9)   // 2
+ * getButtonByteCount(16)  // 2
+ * getButtonByteCount(17)  // 3
+ * ```
+ */
+declare function getButtonByteCount(buttonCount: number): number;
+/**
+ * Calculates the total size of a compressed packet in bytes (format V3)
+ *
+ * @param axisCount - Number of axes
+ * @param buttonCount - Number of buttons
+ * @returns Size in bytes
+ *
+ * @example
+ * ```typescript
+ * getCompressedPacketSize(5, 12)  // 8 + 5 + 2 + 4 = 19 bytes
+ * getCompressedPacketSize(0, 0)   // 8 + 0 + 0 + 4 = 12 bytes (minimum)
+ * getCompressedPacketSize(2, 3)   // 8 + 2 + 1 + 4 = 15 bytes
+ * ```
+ */
+declare function getCompressedPacketSize(axisCount: number, buttonCount: number): number;
+
+/**
+ * CompressedInputEncoder - Encodes inputs in compact binary format
+ *
+ * USED BY CLIENT (utsp-client)
+ *
+ * Workflow:
+ * 1. Client evaluates sources (keyboard + gamepad + touch, etc.)
+ * 2. Client encodes final values in compact binary
+ * 3. Client sends buffer to server via WebSocket
+ *
+ * MINIMALIST V3 Format (without counts):
+ * - Tick: uint64 (8 bytes)
+ * - Axes: float (-1.0 to +1.0) → int8 (-127 to +127) = 1 byte per axis
+ * - Buttons: boolean → bitpacking = 8 buttons per byte
+ * - DisplayId: uint8 (1 byte) = display ID
+ * - Mouse: mouseX/Y (uint8) + flags = 3 bytes
+ *
+ * PREREQUISITE: Client and server must have the SAME bindings defined!
+ *
+ * Example: 5 axes + 12 buttons + mouse = 19 bytes total
+ */
+/**
+ * Encodes inputs in compact binary format v3 (CLIENT-SIDE)
+ *
+ * @param tick - Frame number (bigint for uint64)
+ * @param axes - Map of axis values (bindingId → float between -1.0 and +1.0)
+ * @param buttons - Map of button states (bindingId → pressed)
+ * @param displayId - ID of the display where the mouse is located (0-255)
+ * @param mouseX - Mouse X position (0-255)
+ * @param mouseY - Mouse Y position (0-255)
+ * @param mouseOverDisplay - Is the mouse over a display?
+ * @returns Encoded buffer (without counts, minimalist format)
+ *
+ * @example
+ * ```typescript
+ * const axes = new Map([[0, -0.7], [1, 0.5]]);
+ * const buttons = new Map([[0, true], [1, false], [2, true]]);
+ * const buffer = encodeCompressedInput(42n, axes, buttons, 0, 128, 64, true);
+ * // buffer.length = 8 + 2 + 1 + 4 = 15 bytes
+ * ```
+ */
+declare function encodeCompressedInput(tick: bigint, axes: Map<number, number>, buttons: Map<number, boolean>, displayId: number, mouseX: number, mouseY: number, mouseOverDisplay: boolean, textInputs?: string[]): Uint8Array;
+
+/**
+ * CompressedInputDecoder - Decodes inputs from compact binary format
+ *
+ * USED BY SERVER (utsp-core)
+ *
+ * Workflow:
+ * 1. Server receives binary buffer from client via WebSocket
+ * 2. Server decodes values (MINIMALIST V3 format - without counts)
+ * 3. Server stores in user.axes and user.buttons Maps
+ *
+ * MINIMALIST V3 Format (without counts):
+ * - PREREQUISITE: Client and server must have the SAME bindings defined!
+ * - Buffer does NOT contain AxisCount nor ButtonCount
+ * - Server must pass its registry to know expected structure
+ * - Tick: uint64 (8 bytes)
+ * - Axes: int8 (-127 to +127) → float (-1.0 to +1.0)
+ * - Buttons: bitpacking → boolean (8 buttons per byte)
+ * - DisplayId: uint8 (1 byte) = display ID
+ * - Mouse: uint8 → mouseX/Y + flags (mouseOverDisplay)
+ *
+ * Example (2 axes, 3 buttons):
+ * - Tick (8) + Axes (2) + Buttons (1) + DisplayId (1) + Mouse (3) = 15 bytes
+ */
+
+/**
+ * Decodes a binary buffer to CompressedInputPacket v3 (SERVER-SIDE)
+ *
+ * MINIMALIST v3 format: buffer does NOT contain counters!
+ * Server MUST pass its registry to know axisCount and buttonCount.
+ *
+ * IMPORTANT: Client and server must have the SAME bindings defined
+ * (same number of axes and buttons, same order after sorting by bindingId).
+ *
+ * @param buffer - Encoded buffer received from client
+ * @param registry - Server registry to know expected structure
+ * @returns Decoded packet with tick (bigint), axes, buttons, displayId, mouse
+ *
+ * @throws Error if buffer is too small or invalid
+ *
+ * @example
+ * ```typescript
+ * const packet = decodeCompressedInput(buffer, serverRegistry);
+ * // packet.tick → 42n (bigint)
+ * // packet.axes.get(0) → -0.7
+ * // packet.buttons.get(0) → true
+ * // packet.displayId → 0
+ * // packet.mouseOverDisplay → true
+ * ```
+ */
+declare function decodeCompressedInput(buffer: Uint8Array, registry: InputBindingRegistry): CompressedInputPacket;
+
+/**
+ * OrderBuilder - Factory to create orders easily and type-safely
+ *
+ * Instead of manually writing complex structures, use these helpers:
+ *
+ * @example Before (verbose and error-prone)
+ * ```typescript
+ * const order = {
+ *   type: 0x0a,
+ *   shapeType: 0x01,
+ *   shapeData: {
+ *     posX: 10,
+ *     posY: 20,
+ *     width: 5,
+ *     height: 3,
+ *     filled: true,
+ *     charCode: 0x31,
+ *     bgColorCode: 1,
+ *     fgColorCode: 15
+ *   }
+ * };
+ * ```
+ *
+ * @example After (simple and type-safe with string support!)
+ * ```typescript
+ * // Both syntaxes work:
+ * const order1 = OrderBuilder.rectangle(10, 20, 5, 3, {
+ *   charCode: '1',  // ✨ NEW: Use string directly!
+ *   bgColor: 1,
+ *   fgColor: 15,
+ *   filled: true
+ * });
+ *
+ * const order2 = OrderBuilder.char(10, 20, '#', 15, 0);  // ✨ String support!
+ * const order3 = OrderBuilder.char(10, 20, 0x23, 15, 0); // Number still works
+ * ```
+ */
+
+/**
+ * Common options for graphical orders
+ */
+interface ColorOptions {
+    charCode?: string | number;
+    bgColor?: number;
+    fgColor?: number;
+}
+/**
+ * OrderBuilder - Static factory to create orders
+ */
+declare class OrderBuilder {
+    /**
+     * Convert string or number to 8-bit character code
+     * @param char - Either a string (first character used) or a number (0-255)
+     * @returns 8-bit character code (0-255)
+     * @example
+     * toCharCode('#')   // → 0x23 (35)
+     * toCharCode(0x23)  // → 0x23 (35)
+     * toCharCode('ABC') // → 0x41 (65, first char only)
+     */
+    static toCharCode(char: string | number): number;
+    /**
+     * Remove common leading whitespace from multiline strings (dedent)
+     * Useful for template literals that are indented in source code
+     * @param text - Multiline text to dedent
+     * @returns Dedented text
+     * @example
+     * const text = `
+     *   Hello
+     *   World
+     * `;
+     * dedent(text) // → "Hello\nWorld"
+     */
+    static dedent(text: string): string;
+    /**
+     * 0x01 - Char: Single character at a position
+     * @param char - Character as string ('#') or charCode (0x23)
+     */
+    static char(x: number, y: number, char: string | number, fgColor?: number, bgColor?: number): CharOrder;
+    /**
+     * 0x02 - Text: Horizontal character string
+     */
+    static text(x: number, y: number, text: string, fgColor?: number, bgColor?: number): TextOrder;
+    /**
+     * 0x17 - TextMultiline: Multiple lines of text (\n for line breaks)
+     * Automatically removes common indentation (dedent) for template literals
+     * @example With explicit \n
+     * OrderBuilder.textMultiline(10, 5, 'Hello\nWorld\n!', 15, 0)
+     *
+     * @example With template literal (auto-dedented)
+     * OrderBuilder.textMultiline(10, 5, `
+     *   Score: ${score}
+     *   Lives: ${lives}
+     *   Level: ${level}
+     * `, 15, 0)
+     */
+    static textMultiline(x: number, y: number, text: string, fgColor?: number, bgColor?: number): TextMultilineOrder;
+    /**
+     * 0x03 - SubFrame: Rectangular area with uniform colors
+     * @param frame - Array of characters as strings or numbers
+     */
+    static subFrame(x: number, y: number, width: number, height: number, frame: (string | number)[], fgColor?: number, bgColor?: number): SubFrameOrder;
+    /**
+     * 0x04 - SubFrameMultiColor: Rectangular area with per-cell colors
+     * @param frame - Array of cells where charCode can be string or number
+     */
+    static subFrameMultiColor(x: number, y: number, width: number, height: number, frame: Array<{
+        charCode: string | number;
+        bgColorCode: number;
+        fgColorCode: number;
+    }>): SubFrameMultiColorOrder;
+    /**
+     * 0x05 - FullFrame: Entire layer (256×256) with uniform colors
+     * @param frame - Array of characters as strings or numbers
+     */
+    static fullFrame(frame: (string | number)[], fgColor?: number, bgColor?: number): FullFrameOrder;
+    /**
+     * 0x06 - FullFrameMultiColor: Entire layer (256×256) with per-cell colors
+     * @param frame - Array of cells where charCode can be string or number
+     */
+    static fullFrameMultiColor(frame: Array<{
+        charCode: string | number;
+        bgColorCode: number;
+        fgColorCode: number;
+    }>): FullFrameMultiColorOrder;
+    /**
+     * 0x07 - Sprite: Single-color sprite at a position
+     */
+    static sprite(x: number, y: number, spriteIndex: number, fgColor?: number, bgColor?: number): SpriteOrder;
+    /**
+     * 0x08 - SpriteMultiColor: Multi-color sprite at a position
+     */
+    static spriteMultiColor(x: number, y: number, spriteIndex: number): SpriteMultiColorOrder;
+    /**
+     * 0x09 - ColorMap: Applies colors without changing characters
+     */
+    static colorMap(x: number, y: number, width: number, height: number, colorData: Array<{
+        fgColorCode: number;
+        bgColorCode: number;
+    }>): ColorMapOrder;
+    /**
+     * 0x0A - Rectangle Shape
+     * @param options.charCode - Character as string ('█') or charCode (0x2588)
+     */
+    static rectangle(x: number, y: number, width: number, height: number, options?: {
+        charCode?: string | number;
+        bgColor?: number;
+        fgColor?: number;
+        filled?: boolean;
+    }): ShapeOrder;
+    /**
+     * 0x0A - Circle Shape
+     * @param options.charCode - Character as string ('█') or charCode (0x2588)
+     */
+    static circle(centerX: number, centerY: number, radius: number, options?: {
+        charCode?: string | number;
+        bgColor?: number;
+        fgColor?: number;
+        filled?: boolean;
+    }): ShapeOrder;
+    /**
+     * 0x0A - Line Shape
+     * @param options.charCode - Character as string ('█') or charCode (0x2588)
+     */
+    static line(x1: number, y1: number, x2: number, y2: number, options?: {
+        charCode?: string | number;
+        bgColor?: number;
+        fgColor?: number;
+    }): ShapeOrder;
+    /**
+     * 0x0A - Ellipse Shape
+     * @param options.charCode - Character as string ('█') or charCode (0x2588)
+     */
+    static ellipse(centerX: number, centerY: number, radiusX: number, radiusY: number, options?: {
+        charCode?: string | number;
+        bgColor?: number;
+        fgColor?: number;
+        filled?: boolean;
+    }): ShapeOrder;
+    /**
+     * 0x0A - Triangle Shape
+     * @param options.charCode - Character as string ('█') or charCode (0x2588)
+     */
+    static triangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, options?: {
+        charCode?: string | number;
+        bgColor?: number;
+        fgColor?: number;
+        filled?: boolean;
+    }): ShapeOrder;
+    /**
+     * 0x0B - DotCloud: Same character at multiple positions
+     * @param char - Character as string ('#') or charCode (0x23)
+     */
+    static dotCloud(positions: Array<{
+        posX: number;
+        posY: number;
+    }>, char: string | number, fgColor?: number, bgColor?: number): DotCloudOrder;
+    /**
+     * 0x0C - DotCloudMultiColor: Different characters at multiple positions
+     * @param dots - Array where charCode can be string or number
+     */
+    static dotCloudMultiColor(dots: Array<{
+        posX: number;
+        posY: number;
+        charCode: string | number;
+        bgColorCode: number;
+        fgColorCode: number;
+    }>): DotCloudMultiColorOrder;
+    /**
+     * 0x11 - Bitmask: Bitpacked presence/absence mask with uniform character
+     * Perfect for ore veins, destructible terrain, collision maps, fog of war
+     * @param mask - Flat array of booleans (row-major order: sizeX × sizeY)
+     * @param char - Character as string ('#') or charCode (0x23)
+     * @param override - true: clear absences (transparent), false: preserve existing cells
+     * @example Create a 3×3 cross pattern
+     * OrderBuilder.bitmask(10, 10, 3, 3, [
+     *   false, true,  false,
+     *   true,  true,  true,
+     *   false, true,  false
+     * ], '#', 15, 0, false)
+     */
+    static bitmask(x: number, y: number, width: number, height: number, mask: boolean[], char: string | number, fgColor?: number, bgColor?: number, override?: boolean): BitmaskOrder;
+    /**
+     * 0x0D - SpriteCloud: Same single-color sprite at multiple positions
+     */
+    static spriteCloud(spriteIndex: number, positions: Array<{
+        posX: number;
+        posY: number;
+    }>, fgColor?: number, bgColor?: number): SpriteCloudOrder;
+    /**
+     * 0x0E - SpriteCloudMultiColor: Same multi-color sprite at multiple positions
+     */
+    static spriteCloudMultiColor(spriteIndex: number, positions: Array<{
+        posX: number;
+        posY: number;
+    }>): SpriteCloudMultiColorOrder;
+    /**
+     * 0x0F - SpriteCloudVaried: Different single-color sprites at multiple positions
+     */
+    static spriteCloudVaried(sprites: Array<{
+        posX: number;
+        posY: number;
+        spriteIndex: number;
+        bgColorCode: number;
+        fgColorCode: number;
+    }>): SpriteCloudVariedOrder;
+    /**
+     * 0x10 - SpriteCloudVariedMultiColor: Different multi-color sprites at multiple positions
+     */
+    static spriteCloudVariedMultiColor(sprites: Array<{
+        posX: number;
+        posY: number;
+        spriteIndex: number;
+    }>): SpriteCloudVariedMultiColorOrder;
+    /**
+     * 0x13 - Clear: Fills entire layer with a character
+     * @param char - Character as string (' ') or charCode (0x20)
+     */
+    static clear(char?: string | number, fgColor?: number, bgColor?: number): ClearOrder;
+    /**
+     * 0x14 - FillChar: Fills layer with a repeating pattern
+     * @param pattern - Array of characters as strings or numbers
+     */
+    static fillChar(patternWidth: number, patternHeight: number, pattern: (string | number)[], fgColor?: number, bgColor?: number): FillCharOrder;
+    /**
+     * 0x15 - FillSprite: Fills layer with a repeating single-color sprite
+     */
+    static fillSprite(spriteIndex: number, fgColor?: number, bgColor?: number): FillSpriteOrder;
+    /**
+     * 0x16 - FillSpriteMultiColor: Fills layer with a repeating multi-color sprite
+     */
+    static fillSpriteMultiColor(spriteIndex: number): FillSpriteMultiColorOrder;
+    /**
+     * Helper: Create a rectangle with colored border and different interior
+     * @param borderOptions.charCode - Character as string ('█') or charCode (0x2588)
+     * @param fillOptions.charCode - Character as string ('█') or charCode (0x2588)
+     */
+    static boxWithBorder(x: number, y: number, width: number, height: number, borderOptions: ColorOptions & {
+        charCode?: string | number;
+    }, fillOptions: ColorOptions & {
+        charCode?: string | number;
+    }): ShapeOrder[];
+    /**
+     * Helper: Create a grid of points
+     * @param options.charCode - Character as string ('+') or charCode (0x2b)
+     */
+    static grid(startX: number, startY: number, cellWidth: number, cellHeight: number, rows: number, cols: number, options?: ColorOptions): DotCloudOrder;
+}
+
+/**
+ * UTSP Protocol Constants
+ * Fixed and minimum sizes for network packets (in bytes)
+ * Shared between encoding and decoding
+ */
+/**
+ * Immutable layer size (in cells)
+ * All layers are always 256×256 cells = 65536 cells total
+ */
+declare const LAYER_SIZE = 256;
+declare const LAYER_CELL_COUNT = 65536;
+/**
+ * Sentinel value to indicate "no color" (transparent)
+ * ColorCode 255 = skip this color (look in following layers)
+ * ColorCodes 0-254 = real colors definable by user
+ *
+ * IMPORTANT NOTE:
+ * - ColorID 255 is RESERVED by the engine and cannot be modified via setColor()
+ * - Palette can contain 255 customizable colors (IDs 0-254)
+ * - Total: 256 possible ColorIDs (0-255) but only 0-254 are usable
+ * - Engine forces ColorID 255 = rgba(0,0,0,0) at startup (transparency)
+ */
+declare const COLOR_SKIP = 255;
+declare const UPDATE_PACKET_HEADER_SIZE = 9;
+declare const DISPLAY_HEADER_SIZE = 5;
+declare const LAYER_HEADER_SIZE = 13;
+declare const CHAR_ORDER_SIZE = 6;
+declare const TEXT_ORDER_MIN_SIZE = 6;
+declare const TEXT_MULTILINE_ORDER_MIN_SIZE = 6;
+declare const SUBFRAME_ORDER_MIN_SIZE = 7;
+declare const SUBFRAME_MULTICOLOR_ORDER_MIN_SIZE = 5;
+declare const FULLFRAME_ORDER_MIN_SIZE = 3;
+declare const FULLFRAME_MULTICOLOR_ORDER_MIN_SIZE = 1;
+declare const SPRITE_ORDER_SIZE = 6;
+declare const SPRITE_MULTICOLOR_ORDER_SIZE = 4;
+declare const COLORMAP_ORDER_MIN_SIZE = 5;
+declare const SHAPE_ORDER_MIN_SIZE = 2;
+declare const RECTANGLE_SHAPE_SIZE = 8;
+declare const CIRCLE_SHAPE_SIZE = 7;
+declare const LINE_SHAPE_SIZE = 7;
+declare const ELLIPSE_SHAPE_SIZE = 8;
+declare const TRIANGLE_SHAPE_SIZE = 10;
+declare const DOTCLOUD_ORDER_MIN_SIZE = 6;
+declare const DOTCLOUD_MULTICOLOR_ORDER_MIN_SIZE = 3;
+declare const BITMASK_ORDER_MIN_SIZE = 9;
+declare const SPRITECLOUD_ORDER_MIN_SIZE = 6;
+declare const SPRITECLOUD_MULTICOLOR_ORDER_MIN_SIZE = 4;
+declare const SPRITECLOUD_VARIED_ORDER_MIN_SIZE = 3;
+declare const SPRITECLOUD_VARIED_MULTICOLOR_ORDER_MIN_SIZE = 3;
+declare const CLEAR_ORDER_SIZE = 4;
+declare const FILLCHAR_ORDER_MIN_SIZE = 5;
+declare const FILLSPRITE_ORDER_SIZE = 4;
+declare const FILLSPRITE_MULTICOLOR_ORDER_SIZE = 2;
+declare const TRIGGERSOUND_ORDER_SIZE = 5;
+declare const TRIGGERGLOBALSOUND_ORDER_SIZE = 3;
+
+/**
+ * UTSP Order Types Enumeration
+ *
+ * All 21 order types defined in the UTSP Protocol v0.1
+ * Use these constants instead of raw hexadecimal values for better readability
+ * and type safety.
+ *
+ * @example
+ * ```typescript
+ * import { OrderType } from 'utsp-core';
+ *
+ * // Instead of: type: 0x01
+ * const order = { type: OrderType.Char, posX: 10, posY: 5, ... };
+ * ```
+ */
+declare enum OrderType {
+    /**
+     * 0x01 - Char: Renders a single character at a specific position
+     */
+    Char = 1,
+    /**
+     * 0x02 - Text: Renders a string of characters with uniform colors
+     */
+    Text = 2,
+    /**
+     * 0x17 - TextMultiline: Renders multiple lines of text (\n for line breaks)
+     */
+    TextMultiline = 23,
+    /**
+     * 0x03 - SubFrame: Renders a rectangular region with uniform colors
+     */
+    SubFrame = 3,
+    /**
+     * 0x04 - SubFrameMultiColor: Rectangular region with per-cell colors
+     */
+    SubFrameMultiColor = 4,
+    /**
+     * 0x05 - FullFrame: Renders entire screen with uniform colors
+     */
+    FullFrame = 5,
+    /**
+     * 0x06 - FullFrameMultiColor: Entire screen with per-cell colors
+     */
+    FullFrameMultiColor = 6,
+    /**
+     * 0x07 - Sprite: Renders a preloaded unicolor sprite
+     */
+    Sprite = 7,
+    /**
+     * 0x08 - SpriteMultiColor: Renders a preloaded multicolor sprite
+     */
+    SpriteMultiColor = 8,
+    /**
+     * 0x09 - ColorMap: Applies colors to a region without changing characters
+     */
+    ColorMap = 9,
+    /**
+     * 0x0A - Shape: Renders geometric shapes
+     */
+    Shape = 10,
+    /**
+     * 0x0B - DotCloud: Same character at multiple positions (up to 65535)
+     */
+    DotCloud = 11,
+    /**
+     * 0x0C - DotCloudMultiColor: Different characters at multiple positions
+     */
+    DotCloudMultiColor = 12,
+    /**
+     * 0x0D - SpriteCloud: Same unicolor sprite at multiple positions
+     */
+    SpriteCloud = 13,
+    /**
+     * 0x0E - SpriteCloudMultiColor: Same multicolor sprite at multiple positions
+     */
+    SpriteCloudMultiColor = 14,
+    /**
+     * 0x0F - SpriteCloudVaried: Different unicolor sprites at multiple positions
+     */
+    SpriteCloudVaried = 15,
+    /**
+     * 0x10 - SpriteCloudVariedMultiColor: Different multicolor sprites at multiple positions
+     */
+    SpriteCloudVariedMultiColor = 16,
+    /**
+     * 0x11 - Bitmask: Bitpacked presence/absence mask with uniform character and colors
+     */
+    Bitmask = 17,
+    /**
+     * 0x13 - Clear: Fills entire layer with single character and colors
+     */
+    Clear = 19,
+    /**
+     * 0x14 - FillChar: Fills layer with repeating character pattern
+     */
+    FillChar = 20,
+    /**
+     * 0x15 - FillSprite: Fills layer with repeating unicolor sprite
+     */
+    FillSprite = 21,
+    /**
+     * 0x16 - FillSpriteMultiColor: Fills layer with repeating multicolor sprite
+     */
+    FillSpriteMultiColor = 22,
+    /**
+     * 0x20 - TriggerSound: Triggers positional sound effect
+     */
+    TriggerSound = 32,
+    /**
+     * 0x21 - TriggerGlobalSound: Triggers global (non-positional) sound
+     */
+    TriggerGlobalSound = 33
+}
+/**
+ * Type guard to check if a number is a valid OrderType
+ */
+declare function isValidOrderType(type: number): type is OrderType;
+/**
+ * Get human-readable name for an OrderType
+ */
+declare function getOrderTypeName(type: OrderType | number): string;
+
+/**
+ * UpdateFlags to optimize layer transmission
+ *
+ * Bitpacked flags (8 bits) to indicate layer state and changes.
+ * Allows optimizing rendering and network transmission.
+ *
+ * @see UTSP Protocol section 5.4 - Layer UpdateFlags
+ */
+declare enum UpdateFlags {
+    /**
+     * Bit 0: Layer Enabled
+     *
+     * Indicates if the layer is enabled and should be rendered.
+     * - 1 = Layer enabled, will be rendered by DisplayRasterizer
+     * - 0 = Layer disabled, ignored during rendering
+     *
+     * Use cases:
+     * - Show/hide layers without deleting them
+     * - Toggle UI elements (inventory, menu, etc.)
+     * - Temporarily disable a layer for optimization
+     *
+     * @example
+     * layer.setEnabled(true);
+     * // → UpdateFlags |= LayerEnabled (0x01)
+     */
+    LayerEnabled = 1,
+    /**
+     * Bit 1: SET Mode (vs ADD mode)
+     *
+     * Indicates the order rasterization mode:
+     * - 1 = SET mode → LayerRasterizer clears buffer before rasterizing
+     * - 0 = ADD mode → LayerRasterizer adds to existing buffer
+     *
+     * Use cases:
+     * - SET mode: layer.setOrders() - completely replaces content
+     * - ADD mode: layer.addOrders() - adds to existing content
+     *
+     * IMPORTANT: Corresponds to RasterizeMode.SET vs RasterizeMode.ADD
+     *
+     * @example
+     * layer.setOrders([...newOrders]); // SET mode
+     * // → UpdateFlags |= SetMode (0x02)
+     *
+     * layer.addOrders([...moreOrders]); // ADD mode
+     * // → UpdateFlags &= ~SetMode (bit 1 to 0)
+     */
+    SetMode = 2,
+    /**
+     * Bit 2: Update position (originX/Y)
+     *
+     * Indicates that the layer's origin has changed.
+     * If this bit is not set, the decoder keeps the existing position.
+     *
+     * Use cases:
+     * - Parallax scrolling
+     * - Camera following player
+     * - Move a layer without modifying its content
+     *
+     * @example
+     * layer.setOrigin(new Vector2(100, 50));
+     * // → UpdateFlags |= UpdatePosition (0x04)
+     */
+    UpdatePosition = 4,
+    /**
+     * Bit 3: Update z-index order
+     *
+     * Indicates that the layer's z-index has changed.
+     * If this bit is not set, the decoder keeps the existing z-index.
+     *
+     * Use cases:
+     * - Dynamically reorder layers
+     * - Change rendering priority
+     * - Bring a layer to the foreground
+     *
+     * @example
+     * layer.setZOrder(10);
+     * // → UpdateFlags |= UpdateZOrder (0x08)
+     */
+    UpdateZOrder = 8,
+    /**
+     * No changes, layer disabled
+     * Layer ignored during rendering
+     */
+    Disabled = 0,
+    /**
+     * Layer enabled, ADD mode, no changes
+     * Used to maintain an active layer without modifications
+     */
+    EnabledAddMode = 1,// 0x01
+    /**
+     * Layer enabled, SET mode, no changes
+     * Active layer in SET mode (overwrites buffer)
+     */
+    EnabledSetMode = 3,// 0x03
+    /**
+     * Layer enabled, ADD mode, position changed (parallax scrolling)
+     * Typical use case: scrolling background
+     */
+    EnabledAddMoveOnly = 5,// 0x05
+    /**
+     * Layer enabled, SET mode, position changed
+     */
+    EnabledSetMoveOnly = 7,// 0x07
+    /**
+     * Layer enabled, ADD mode, z-index changed
+     */
+    EnabledAddReorderOnly = 9,// 0x09
+    /**
+     * Layer enabled, SET mode, z-index changed
+     */
+    EnabledSetReorderOnly = 11,// 0x0B
+    /**
+     * Full update: Layer enabled, SET mode, position + z-index changed
+     * Used for a complete change
+     */
+    FullUpdate = 15
+}
+/**
+ * Helper functions to manipulate UpdateFlags
+ */
+declare namespace UpdateFlagsHelper {
+    /**
+     * Checks if a specific flag is enabled
+     */
+    function hasFlag(flags: number, flag: UpdateFlags): boolean;
+    /**
+     * Adds a flag
+     */
+    function addFlag(flags: number, flag: UpdateFlags): number;
+    /**
+     * Removes a flag
+     */
+    function removeFlag(flags: number, flag: UpdateFlags): number;
+    /**
+     * Combines multiple flags
+     */
+    function combine(...flags: UpdateFlags[]): number;
+    /**
+     * Checks if flags are valid (bits 4-7 must be 0)
+     */
+    function isValid(flags: number): boolean;
+    /**
+     * Checks if the layer is enabled (bit 0)
+     */
+    function isEnabled(flags: number): boolean;
+    /**
+     * Checks if the mode is SET (bit 1)
+     */
+    function isSetMode(flags: number): boolean;
+    /**
+     * Checks if the position has changed (bit 2)
+     */
+    function hasPositionChanged(flags: number): boolean;
+    /**
+     * Checks if the z-index has changed (bit 3)
+     */
+    function hasZOrderChanged(flags: number): boolean;
+    /**
+     * Returns a human-readable description of active flags
+     */
+    function describe(flags: number): string;
+}
+
+/**
+ * Decoder for UTSP Update Packets
+ * Decodes complete update packets following the UTSP protocol specification (new architecture)
+ */
+declare class UpdatePacketDecoder {
+    private displayDecoder;
+    private layerDecoder;
+    constructor();
+    /**
+     * Decodes an UpdatePacket from binary buffer
+     *
+     * Structure (NEW PROTOCOL):
+     * - Tick: 8 bytes (big-endian, 64-bit unsigned integer)
+     * - DisplayCount: 1 byte (8-bit unsigned integer, max 255 displays)
+     * - Displays: variable (DisplayId + OriginX + OriginY + SizeX + SizeY = 7 bytes each)
+     * - LayerCount: 2 bytes (big-endian, 16-bit unsigned integer)
+     * - Layers: variable (encoded layers)
+     *
+     * Minimum packet size: 11 bytes (Tick + DisplayCount + LayerCount)
+     */
+    decode(data: Uint8Array, offset?: number): UpdatePacket;
+    /**
+     * Checks if a buffer contains a valid update packet header
+     * Useful for validation before decoding
+     */
+    isValid(data: Uint8Array, offset?: number): boolean;
+    /**
+     * Decodes only the tick and counts without decoding the displays/layers
+     * Useful for quick inspection of packet metadata
+     */
+    decodeHeader(data: Uint8Array, offset?: number): {
+        tick: number;
+        displayCount: number;
+        layerCount: number;
+    };
+    private checkSize;
+}
+
+export { ASCII_8X8_FONT, BITMASK_ORDER_MIN_SIZE, BitmapFont, BitmapFontRegistry, CHAR_ORDER_SIZE, CIRCLE_SHAPE_SIZE, CLEAR_ORDER_SIZE, COLORMAP_ORDER_MIN_SIZE, COLOR_SKIP, CellBuffer, CharCodeBuffer, Core, CoreStats, DISPLAY_HEADER_SIZE, DOTCLOUD_MULTICOLOR_ORDER_MIN_SIZE, DOTCLOUD_ORDER_MIN_SIZE, Display, ELLIPSE_SHAPE_SIZE, FILLCHAR_ORDER_MIN_SIZE, FILLSPRITE_MULTICOLOR_ORDER_SIZE, FILLSPRITE_ORDER_SIZE, FULLFRAME_MULTICOLOR_ORDER_MIN_SIZE, FULLFRAME_ORDER_MIN_SIZE, FontType, InputBindingRegistry, LAYER_CELL_COUNT, LAYER_HEADER_SIZE, LAYER_SIZE, LINE_SHAPE_SIZE, Layer, LoadType, OrderBuilder, OrderType, RECTANGLE_SHAPE_SIZE, SHAPE_ORDER_MIN_SIZE, SPRITECLOUD_MULTICOLOR_ORDER_MIN_SIZE, SPRITECLOUD_ORDER_MIN_SIZE, SPRITECLOUD_VARIED_MULTICOLOR_ORDER_MIN_SIZE, SPRITECLOUD_VARIED_ORDER_MIN_SIZE, SPRITE_MULTICOLOR_ORDER_SIZE, SPRITE_ORDER_SIZE, SUBFRAME_MULTICOLOR_ORDER_MIN_SIZE, SUBFRAME_ORDER_MIN_SIZE, ShapeType, SpriteRegistry, TEXT_MULTILINE_ORDER_MIN_SIZE, TEXT_ORDER_MIN_SIZE, TRIANGLE_SHAPE_SIZE, TRIGGERGLOBALSOUND_ORDER_SIZE, TRIGGERSOUND_ORDER_SIZE, UPDATE_PACKET_HEADER_SIZE, UpdateFlags, UpdateFlagsHelper, UpdatePacketDecoder, User, UserStats, WebFont, WebFontRegistry, createASCII8x8FontLoad, createEmptyCompressedInputPacket, decodeCompressedInput, decodeInt8ToAxis, encodeAxisToInt8, encodeCompressedInput, getASCII8x8FontConfig, getAllCharCodes, getButtonByteCount, getCharBitmap, getCompressedPacketSize, getOrderTypeName, hasChar, isValidOrderType };
+export type { AnyLoad, BitmapFontConfig, BitmapFontLoad, Cell, CircleShape, Color, ColorPaletteLoad, CompressedInputPacket, CoreMode, CoreOptions, EllipseShape, LineShape, MulticolorCell, MulticolorSprite, MulticolorSpriteLoad, NetworkDisplay, NetworkLayer, RectangleShape, ShapeData, SoundLoad, SpriteLoad, TickStats, TriangleShape, UnicolorSprite, UpdatePacket, UserTickStats, WebFontConfig, WebFontLoad };