@utsp/core 0.5.0-nightly.20251204224600.55bf8ac → 0.6.0-nightly.20251207012530.05b8403

package/dist/index.d.ts

@@ -149,1205 +149,2002 @@ declare class BitmapFont {
 }
 
 /**
- * UTSP Audio Order Types Enumeration
- *
- * Audio orders are separate from render orders and have their own type space.
- * They are included in the UpdatePacket but processed by the AudioProcessor,
- * not the Rasterizer.
- *
- * This separation ensures:
- * - Clear distinction between visual and audio orders
- * - Independent type numbering (0x01 audio ≠ 0x01 render)
- * - Extensibility without conflicts
+ * 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;
+}
+/**
+ * Cell variant definition for Bitmask4 order
+ */
+interface Bitmask4Variant {
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+/**
+ * 0x12 - Bitmask4: Renders a rectangular region with 2-bit packed mask
+ * Each 2-bit value represents: 0 = absence, 1-3 = variant index
+ */
+interface Bitmask4Order extends NetworkOrder {
+    type: 0x12;
+    posX: number;
+    posY: number;
+    sizeX: number;
+    sizeY: number;
+    override: boolean;
+    variants: [Bitmask4Variant, Bitmask4Variant, Bitmask4Variant];
+    mask: Uint8Array;
+}
+/**
+ * Cell variant definition for Bitmask16 order
+ */
+interface Bitmask16Variant {
+    charCode: number;
+    bgColorCode: number;
+    fgColorCode: number;
+}
+/**
+ * 0x18 - Bitmask16: Renders a rectangular region with 4-bit packed mask
+ * Each 4-bit value represents: 0 = absence, 1-15 = variant index
+ */
+interface Bitmask16Order extends NetworkOrder {
+    type: 0x18;
+    posX: number;
+    posY: number;
+    sizeX: number;
+    sizeY: number;
+    override: boolean;
+    variants: Bitmask16Variant[];
+    mask: Uint8Array;
+}
+/**
+ * 0x19 - Polyline: Renders a line connecting multiple points
+ * Uses Bresenham algorithm to draw between consecutive points.
+ * Binary format: [type(1), charCode(1), fgColor(1), bgColor(1), pointCount(1), x1, y1, x2, y2, ...]
+ */
+interface PolylineOrder extends NetworkOrder {
+    type: 0x19;
+    charCode: number;
+    fgColorCode: number;
+    bgColorCode: number;
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+}
+/**
+ * 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 | Bitmask4Order | Bitmask16Order | PolylineOrder | SpriteCloudOrder | SpriteCloudMultiColorOrder | SpriteCloudVariedOrder | SpriteCloudVariedMultiColorOrder | ClearOrder | FillCharOrder | FillSpriteOrder | FillSpriteMultiColorOrder | TriggerSoundOrder | TriggerGlobalSoundOrder;
+
+/**
+ * UTSP Macro System Types
  *
- * @example
- * ```typescript
- * import { AudioOrderType } from '@utsp/core';
+ * Macros provide client-side feedback without server round-trips.
+ * Used for: UI interactions (hover, focus), particle effects, visual effects.
  *
- * const order = { type: AudioOrderType.PlaySound, soundId: 0, volume: 200 };
- * ```
+ * NOT for: synchronized gameplay, business logic, shared state.
  */
-declare enum AudioOrderType {
-    /**
-     * 0x01 - PlaySound: Play a sound with optional spatial position
-     *
-     * Parameters: soundId, instanceId, flags, volume?, pitch?, fadeIn?, posX?, posY?
-     */
-    PlaySound = 1,
-    /**
-     * 0x02 - PlayGlobalSound: Play a non-positional (global) sound
-     *
-     * Parameters: soundId, instanceId, flags, volume?, pitch?, fadeIn?
-     */
-    PlayGlobalSound = 2,
+/**
+ * Macro order types for UpdatePacket
+ * These are processed separately from render orders (like AudioOrderType)
+ */
+declare enum MacroOrderType {
     /**
-     * 0x03 - StopSound: Stop a sound immediately
-     *
-     * Parameters: targetType, target (instanceId, soundId, or 'all')
+     * 0x01 - CreateInstance: Create a new macro instance
      */
-    StopSound = 3,
+    CreateInstance = 1,
     /**
-     * 0x04 - FadeOutSound: Fade out and stop a sound
-     *
-     * Parameters: targetType, target, duration
+     * 0x02 - UpdateInstance: Update an existing instance's params
      */
-    FadeOutSound = 4,
+    UpdateInstance = 2,
     /**
-     * 0x05 - PauseSound: Pause a playing sound
-     *
-     * Parameters: targetType, target
+     * 0x03 - RemoveInstance: Remove an instance
      */
-    PauseSound = 5,
+    RemoveInstance = 3
+}
+/**
+ * Macro event types sent from client to server
+ * UI interactions that need server-side handling
+ */
+declare enum MacroEventType {
     /**
-     * 0x06 - ResumeSound: Resume a paused sound
-     *
-     * Parameters: targetType, target
+     * 0x01 - Click: Button/element was clicked
      */
-    ResumeSound = 6,
+    Click = 1,
     /**
-     * 0x07 - SetListenerPosition: Set the listener position for spatial audio
-     *
-     * Parameters: x, y (16-bit each)
+     * 0x02 - Change: Value changed (slider, checkbox, etc.)
      */
-    SetListenerPosition = 7,
+    Change = 2,
     /**
-     * 0x08 - ConfigureSpatial: Configure spatial audio parameters
-     *
-     * Parameters: maxDistance, referenceDistance, rolloffFactor, panSpread
+     * 0x03 - Submit: Text/form was submitted
      */
-    ConfigureSpatial = 8,
+    Submit = 3,
     /**
-     * 0x09 - SetSoundEffects: Set audio effects on a playing sound
-     *
-     * Parameters: instanceId, flags, lowpass?, highpass?, reverb?
+     * 0x04 - Select: Item was selected (dropdown, list, etc.)
      */
-    SetSoundEffects = 9
+    Select = 4
 }
 /**
- * Target type for stop/pause/resume/fadeout commands
+ * Macro types - determines behavior and rendering
  */
-declare enum AudioTargetType {
-    /** Target a specific instance by ID */
-    InstanceId = 0,
-    /** Target all instances of a sound by soundId */
-    SoundId = 1,
-    /** Target all sounds */
-    All = 2
+type MacroType = 'ui' | 'particle' | 'effect' | 'reveal' | 'line';
+/**
+ * UI state names for UI macros
+ */
+type UIState = 'normal' | 'hover' | 'active' | 'focused' | 'disabled';
+/**
+ * Base interface for all macro templates (loaded via LoadMacro)
+ */
+interface MacroTemplateBase {
+    /** Unique template identifier */
+    id: string;
+    /** Macro type */
+    type: MacroType;
+    /** Parameter definitions (name → type) */
+    params?: Record<string, 'string' | 'number' | 'boolean'>;
+    /** Sound triggers */
+    sounds?: {
+        hover?: string;
+        active?: string;
+        focus?: string;
+    };
 }
 /**
- * Type guard to check if a number is a valid AudioOrderType
+ * Render command for UI macros
+ * Coordinates are relative to instance position
  */
-declare function isValidAudioOrderType(type: number): type is AudioOrderType;
+type RenderCommand = {
+    fillRect: [
+        number | string,
+        number | string,
+        number | string,
+        number | string,
+        string,
+        string,
+        string
+    ];
+} | {
+    text: [number | string, number | string, string, string];
+} | {
+    setCell: [number | string, number | string, string, string, string];
+};
 /**
- * Get human-readable name for an AudioOrderType
+ * UI subtypes for specialized behavior
  */
-declare function getAudioOrderTypeName(type: AudioOrderType | number): string;
-
+type UISubtype = 'generic' | 'button';
 /**
- * UTSP Audio Orders
- *
- * Binary-encoded audio commands included in UpdatePacket.
- * Processed by AudioProcessor on client, synchronized with render orders.
- *
- * Each order has a specific binary structure optimized for network transmission.
+ * Border style for button
  */
-
+type ButtonBorderStyle = 'single' | 'double' | 'rounded' | 'none';
 /**
- * Base interface for all audio orders
+ * Button-specific configuration
  */
-interface AudioOrder {
-    /** Audio order type identifier */
-    type: AudioOrderType;
+interface ButtonConfig {
+    /** Button label (can be dynamic $paramName) */
+    label: string;
+    /** Button width (can be dynamic) */
+    width: number | string;
+    /** Button height (can be dynamic, default: 3 for bordered, 1 for none) */
+    height?: number | string;
+    /** Border style */
+    border?: ButtonBorderStyle;
+    /** Sound ID to play on hover (optional) */
+    soundHover?: number;
+    /** Sound ID to play on click (optional) */
+    soundClick?: number;
+    /** Sound ID to play on release (optional) */
+    soundRelease?: number;
+}
+/**
+ * Button state colors
+ */
+interface ButtonStateColors {
+    /** Foreground color for border/frame */
+    fg?: number | string;
+    /** Background color */
+    bg?: number | string;
+    /** Text/label foreground color */
+    textFg?: number | string;
+    /** Vertical offset (for "pressed" effect) */
+    offsetY?: number;
+}
+/**
+ * UI macro template - interactive elements (button, slider, checkbox, etc.)
+ */
+interface UIMacroTemplate extends MacroTemplateBase {
+    type: 'ui';
+    /** UI subtype for specialized behavior (default: 'generic') */
+    subtype?: UISubtype;
+    /** Button-specific configuration (required when subtype: 'button') */
+    button?: ButtonConfig;
+    /** Base render commands (executed in order) - used for generic subtype */
+    base?: RenderCommand[];
+    /** State-specific variable overrides */
+    states: {
+        normal: Record<string, unknown> | ButtonStateColors;
+        hover?: Record<string, unknown> | ButtonStateColors;
+        active?: Record<string, unknown> | ButtonStateColors;
+        focused?: Record<string, unknown> | ButtonStateColors;
+        disabled?: Record<string, unknown> | ButtonStateColors;
+    };
+}
+/**
+ * Emitter configuration for particle macros
+ */
+interface ParticleEmitter {
+    /** Spawn zone - where particles are created (relative coordinates) */
+    zone: {
+        x: number | string;
+        y: number | string;
+        width: number | string;
+        height: number | string;
+    };
+    /** Viewport zone - only particles inside this area are rendered (relative coordinates)
+     * If not specified, defaults to zone. Use this to let particles spawn outside
+     * the visible area (e.g., rain spawning above screen) */
+    viewport?: {
+        x: number | string;
+        y: number | string;
+        width: number | string;
+        height: number | string;
+    };
+    /** Particles per tick (continuous mode) */
+    rate?: number | string;
+    /** Spawn N particles at once (burst mode) */
+    burst?: number | string;
+    /** Only emit once then stop */
+    once?: boolean;
+    /** Max simultaneous particles */
+    limit?: number;
 }
 /**
- * Flags for PlaySound/PlayGlobalSound orders
- * Packed into a single byte to minimize bandwidth
+ * Particle configuration
  */
-declare enum PlaySoundFlags {
-    /** Sound should loop */
-    Loop = 1,
-    /** Volume is specified (otherwise default 100%) */
-    HasVolume = 2,
-    /** Pitch is specified (otherwise default 1.0x) */
-    HasPitch = 4,
-    /** FadeIn duration is specified (otherwise instant) */
-    HasFadeIn = 8,
-    /** Position is specified (only for PlaySound, not PlayGlobalSound) */
-    HasPosition = 16,
-    /** Low-pass filter is specified */
-    HasLowpass = 32,
-    /** High-pass filter is specified */
-    HasHighpass = 64,
-    /** Reverb mix is specified */
-    HasReverb = 128
+interface ParticleConfig {
+    /** Character(s) to display - string, char code, or array */
+    char: string | number | (string | number)[];
+    /** Foreground color - palette index 0-255 */
+    fg: number | number[];
+    /** Background color - palette index 0-255 (optional, 255 = transparent) */
+    bg?: number | number[];
+    /** Lifetime in ticks (fixed or [min, max]) */
+    lifetime: number | [number, number];
+    /** Velocity (cells per tick) */
+    velocity: {
+        x: number | string;
+        y: number | string;
+    } | {
+        angle: number | [number, number];
+        speed: number | [number, number] | string;
+    };
+    /** Fade out at end of lifetime */
+    fade?: boolean;
 }
 /**
- * 0x01 - PlaySound: Play a sound with optional spatial position
- *
- * Binary structure (variable size, 4-15 bytes):
- * - type: 1 byte (0x01)
- * - soundId: 1 byte (0-255)
- * - instanceId: 2 bytes (big-endian, unique ID for this playback)
- * - flags: 1 byte (PlaySoundFlags bitfield)
- * - volume?: 1 byte (0-255, maps to 0.0-1.0) - if HasVolume
- * - pitch?: 1 byte (0-255, maps to 0.25x-4.0x, 128=1.0x) - if HasPitch
- * - fadeIn?: 1 byte (0-255, duration in 1/10 seconds, 0=instant) - if HasFadeIn
- * - posX?: 2 bytes (big-endian, 0-65535) - if HasPosition
- * - posY?: 2 bytes (big-endian, 0-65535) - if HasPosition
- * - lowpass?: 1 byte (0-255, * 100 = Hz cutoff) - if HasLowpass
- * - highpass?: 1 byte (0-255, * 100 = Hz cutoff) - if HasHighpass
- * - reverb?: 1 byte (0-255, / 255 = wet mix 0.0-1.0) - if HasReverb
+ * Particle macro template - visual effects (rain, explosion, snow, etc.)
  */
-interface PlaySoundOrder extends AudioOrder {
-    type: AudioOrderType.PlaySound;
-    /** Sound ID (0-255) */
-    soundId: number;
-    /** Unique instance ID for this playback */
-    instanceId: number;
-    /** Flags bitfield */
-    flags: number;
-    /** Volume (0-255, maps to 0.0-1.0). Present if HasVolume flag set */
-    volume?: number;
-    /** Pitch (0-255, 128=1.0x). Present if HasPitch flag set */
-    pitch?: number;
-    /** Fade in duration in 1/10 seconds. Present if HasFadeIn flag set */
-    fadeIn?: number;
-    /** X position (0-65535). Present if HasPosition flag set */
-    posX?: number;
-    /** Y position (0-65535). Present if HasPosition flag set */
-    posY?: number;
-    /** Low-pass filter cutoff (0-255, * 100 = Hz). Present if HasLowpass flag set */
-    lowpass?: number;
-    /** High-pass filter cutoff (0-255, * 100 = Hz). Present if HasHighpass flag set */
-    highpass?: number;
-    /** Reverb wet mix (0-255, / 255 = 0.0-1.0). Present if HasReverb flag set */
-    reverb?: number;
+interface ParticleMacroTemplate extends MacroTemplateBase {
+    type: 'particle';
+    /** Emitter configuration */
+    emitter: ParticleEmitter;
+    /** Particle configuration */
+    particle: ParticleConfig;
 }
 /**
- * 0x02 - PlayGlobalSound: Play a non-positional sound
- *
- * Binary structure (variable size, 4-10 bytes):
- * - type: 1 byte (0x02)
- * - soundId: 1 byte (0-255)
- * - instanceId: 2 bytes (big-endian)
- * - flags: 1 byte (PlaySoundFlags, but HasPosition is ignored)
- * - volume?: 1 byte - if HasVolume
- * - pitch?: 1 byte - if HasPitch
- * - fadeIn?: 1 byte - if HasFadeIn
- * - lowpass?: 1 byte - if HasLowpass
- * - highpass?: 1 byte - if HasHighpass
- * - reverb?: 1 byte - if HasReverb
+ * Transform configuration for effect macros
  */
-interface PlayGlobalSoundOrder extends AudioOrder {
-    type: AudioOrderType.PlayGlobalSound;
-    /** Sound ID (0-255) */
-    soundId: number;
-    /** Unique instance ID for this playback */
-    instanceId: number;
-    /** Flags bitfield (HasPosition ignored) */
-    flags: number;
-    /** Volume (0-255). Present if HasVolume flag set */
-    volume?: number;
-    /** Pitch (0-255, 128=1.0x). Present if HasPitch flag set */
-    pitch?: number;
-    /** Fade in duration in 1/10 seconds. Present if HasFadeIn flag set */
-    fadeIn?: number;
-    /** Low-pass filter cutoff (0-255, * 100 = Hz). Present if HasLowpass flag set */
-    lowpass?: number;
-    /** High-pass filter cutoff (0-255, * 100 = Hz). Present if HasHighpass flag set */
-    highpass?: number;
-    /** Reverb wet mix (0-255, / 255 = 0.0-1.0). Present if HasReverb flag set */
-    reverb?: number;
+interface EffectTransform {
+    /** Offset applied to rendering */
+    offset?: {
+        x: number | string | {
+            random: [number | string, number | string];
+        };
+        y: number | string | {
+            random: [number | string, number | string];
+        };
+    };
+    /** Effect duration in ms */
+    duration: number | string;
+    /** Decay over time */
+    decay?: boolean;
 }
 /**
- * 0x03 - StopSound: Stop a sound immediately
- *
- * Binary structure (3-4 bytes):
- * - type: 1 byte (0x03)
- * - targetType: 1 byte (AudioTargetType)
- * - target: 1-2 bytes (instanceId=2B, soundId=1B, all=0B)
+ * Effect macro template - temporary visual effects (shake, flash, fade, etc.)
  */
-interface StopSoundOrder extends AudioOrder {
-    type: AudioOrderType.StopSound;
-    /** Type of target */
-    targetType: AudioTargetType;
-    /** Target value (instanceId, soundId, or undefined for 'all') */
-    target?: number;
+interface EffectMacroTemplate extends MacroTemplateBase {
+    type: 'effect';
+    /** Transform to apply */
+    transform: EffectTransform;
 }
 /**
- * 0x04 - FadeOutSound: Fade out and stop a sound
- *
- * Binary structure (4-5 bytes):
- * - type: 1 byte (0x04)
- * - targetType: 1 byte
- * - duration: 1 byte (1/10 seconds, 0-25.5s)
- * - target: 1-2 bytes
+ * Reveal patterns - how content is progressively shown/hidden
  */
-interface FadeOutSoundOrder extends AudioOrder {
-    type: AudioOrderType.FadeOutSound;
-    /** Type of target */
-    targetType: AudioTargetType;
-    /** Fade duration in 1/10 seconds (0-255 = 0-25.5 seconds) */
-    duration: number;
-    /** Target value */
-    target?: number;
-}
+type RevealPattern = 'typewriter' | 'typewriter-rev' | 'ltr' | 'rtl' | 'ttb' | 'btt' | 'random' | 'center-out' | 'spiral';
 /**
- * 0x05 - PauseSound: Pause a playing sound
- *
- * Binary structure (2-4 bytes):
- * - type: 1 byte (0x05)
- * - targetType: 1 byte
- * - target: 0-2 bytes
+ * Reveal direction - show or hide
  */
-interface PauseSoundOrder extends AudioOrder {
-    type: AudioOrderType.PauseSound;
-    /** Type of target */
-    targetType: AudioTargetType;
-    /** Target value */
-    target?: number;
+type RevealDirection = 'reveal' | 'hide';
+/**
+ * Cursor configuration for reveal macros
+ */
+interface RevealCursor {
+    /** Cursor character (e.g., "▌", "_", "█") or char code */
+    char: string | number;
+    /** Cursor foreground color (palette index) */
+    fg?: number;
+    /** Cursor background color (palette index) */
+    bg?: number;
+    /** Blink cursor */
+    blink?: boolean;
+    /** Blink rate in ticks (default: 15) */
+    blinkRate?: number;
 }
 /**
- * 0x06 - ResumeSound: Resume a paused sound
- *
- * Binary structure (2-4 bytes):
- * - type: 1 byte (0x06)
- * - targetType: 1 byte
- * - target: 0-2 bytes
+ * Pause configuration for reveal macros
  */
-interface ResumeSoundOrder extends AudioOrder {
-    type: AudioOrderType.ResumeSound;
-    /** Type of target */
-    targetType: AudioTargetType;
-    /** Target value */
-    target?: number;
+interface RevealPause {
+    /** Characters that trigger a pause (e.g., [".", "!", "?"]) */
+    chars: string[];
+    /** Pause duration in ticks */
+    duration: number;
 }
 /**
- * 0x07 - SetListenerPosition: Set listener position for spatial audio
- *
- * Binary structure (5 bytes):
- * - type: 1 byte (0x07)
- * - x: 2 bytes (big-endian, 0-65535)
- * - y: 2 bytes (big-endian, 0-65535)
+ * Content type for reveal macros
  */
-interface SetListenerPositionOrder extends AudioOrder {
-    type: AudioOrderType.SetListenerPosition;
-    /** X position (0-65535) */
+type RevealContentType = 'text' | 'sprite' | 'cells' | 'fill';
+/**
+ * Single cell definition for 'cells' content type
+ */
+interface RevealCellDef {
+    /** Character to display */
+    char: string | number;
+    /** Foreground color (palette index) */
+    fg: number;
+    /** Background color (palette index) */
+    bg: number;
+    /** X position relative to instance */
     x: number;
-    /** Y position (0-65535) */
+    /** Y position relative to instance */
     y: number;
 }
 /**
- * 0x08 - ConfigureSpatial: Configure spatial audio parameters
- *
- * Binary structure (5 bytes):
- * - type: 1 byte (0x08)
- * - maxDistance: 1 byte (0-255, scaled appropriately)
- * - referenceDistance: 1 byte (0-255)
- * - rolloffFactor: 1 byte (0-255, maps to 0.0-2.55)
- * - panSpread: 1 byte (0-255, maps to 0.0-1.0)
+ * Content to reveal - discriminated union with explicit type
+ * All string values can be dynamic ($paramName references)
  */
-interface ConfigureSpatialOrder extends AudioOrder {
-    type: AudioOrderType.ConfigureSpatial;
-    /** Maximum audible distance (encoded, 0-255) */
-    maxDistance: number;
-    /** Reference distance for full volume (encoded, 0-255) */
-    referenceDistance: number;
-    /** Rolloff factor (0-255, maps to 0.0-2.55) */
-    rolloffFactor: number;
-    /** Pan spread factor (0-255, maps to 0.0-1.0) */
-    panSpread: number;
-}
+type RevealContent = {
+    type: 'text';
+    /** Text to reveal (multiline with \n) */
+    text: string;
+    /** Foreground color (palette index, can be dynamic) */
+    fg?: number | string;
+    /** Background color (palette index, can be dynamic) */
+    bg?: number | string;
+} | {
+    type: 'sprite';
+    /** Sprite ID (0-255) or dynamic reference ($paramName) */
+    sprite: number | string;
+    /** For unicolor sprites: foreground color (palette index, can be dynamic) */
+    fg?: number | string;
+    /** For unicolor sprites: background color (palette index, can be dynamic) */
+    bg?: number | string;
+    /** Use multicolor sprite instead of unicolor (default: true, tries multicolor first) */
+    multicolor?: boolean;
+} | {
+    type: 'cells';
+    /** Array of cell definitions */
+    cells: RevealCellDef[];
+} | {
+    type: 'fill';
+    /** Character to fill with */
+    char: string | number;
+    /** Foreground color (palette index, can be dynamic) */
+    fg: number | string;
+    /** Background color (palette index, can be dynamic) */
+    bg: number | string;
+    /** Width of fill area (can be dynamic) */
+    width: number | string;
+    /** Height of fill area (can be dynamic) */
+    height: number | string;
+};
 /**
- * Flags for SetSoundEffects order
+ * Reveal macro template - progressive text/sprite display
  */
-declare enum SoundEffectsFlags {
-    /** Low-pass filter is specified */
-    HasLowpass = 1,
-    /** High-pass filter is specified */
-    HasHighpass = 2,
-    /** Reverb mix is specified */
-    HasReverb = 4
+interface RevealMacroTemplate extends MacroTemplateBase {
+    type: 'reveal';
+    /** Content to reveal (text or sprite) */
+    content: RevealContent;
+    /** Reveal pattern */
+    pattern: RevealPattern;
+    /** Direction: 'reveal' to show, 'hide' to hide */
+    direction: RevealDirection;
+    /** Speed in cells per tick */
+    speed: number;
+    /** Initial delay in ticks before starting */
+    delay?: number;
+    /** Cursor configuration */
+    cursor?: RevealCursor;
+    /** Pause on specific characters */
+    pauseOn?: RevealPause;
 }
 /**
- * 0x09 - SetSoundEffects: Update audio effects on a playing sound
- *
- * Binary structure (variable size, 4-7 bytes):
- * - type: 1 byte (0x09)
- * - instanceId: 2 bytes (big-endian)
- * - flags: 1 byte (SoundEffectsFlags bitfield)
- * - lowpass?: 1 byte (0-255, * 100 = Hz cutoff) - if HasLowpass
- * - highpass?: 1 byte (0-255, * 100 = Hz cutoff) - if HasHighpass
- * - reverb?: 1 byte (0-255, / 255 = wet mix 0.0-1.0) - if HasReverb
+ * Line macro template - dynamic line renderer with point history
+ * The server sends only new points, the client maintains the full path
  */
-interface SetSoundEffectsOrder extends AudioOrder {
-    type: AudioOrderType.SetSoundEffects;
-    /** Target instance ID */
-    instanceId: number;
-    /** Flags bitfield */
-    flags: number;
-    /** Low-pass filter cutoff (0-255, * 100 = Hz). Present if HasLowpass flag set */
-    lowpass?: number;
-    /** High-pass filter cutoff (0-255, * 100 = Hz). Present if HasHighpass flag set */
-    highpass?: number;
-    /** Reverb wet mix (0-255, / 255 = 0.0-1.0). Present if HasReverb flag set */
-    reverb?: number;
+interface LineMacroTemplate extends MacroTemplateBase {
+    type: 'line';
+    /** Maximum number of points to keep in history (default: 100) */
+    maxPoints?: number;
+    /** Character to draw the line with (default: '*') */
+    char: string | number;
+    /** Foreground color (palette index) */
+    fg: number;
+    /** Background color (palette index, default: 255 = transparent) */
+    bg?: number;
+    /** Fade out older points (reduces alpha/color intensity) */
+    fadeOut?: boolean;
+    /** Number of points to fade (from tail), default: all points if fadeOut is true */
+    fadeLength?: number;
+    /** Close the path (connect last point to first) */
+    closed?: boolean;
 }
 /**
- * Union of all audio order types
+ * Any macro template type
  */
-type AnyAudioOrder = PlaySoundOrder | PlayGlobalSoundOrder | StopSoundOrder | FadeOutSoundOrder | PauseSoundOrder | ResumeSoundOrder | SetListenerPositionOrder | ConfigureSpatialOrder | SetSoundEffectsOrder;
-
+type MacroTemplate = UIMacroTemplate | ParticleMacroTemplate | EffectMacroTemplate | RevealMacroTemplate | LineMacroTemplate;
 /**
- * Network representation of a display
- * Layers are NO LONGER under displays - they are at User level
+ * Base interface for macro orders
  */
-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;
+interface MacroOrder {
+    type: MacroOrderType;
 }
-
 /**
- * Base interface for all network orders
+ * CreateInstance order - creates a new macro instance
  */
-interface NetworkOrder {
-    type: number;
+interface CreateInstanceOrder extends MacroOrder {
+    type: MacroOrderType.CreateInstance;
+    /** Instance ID (0-255) */
+    instanceId: number;
+    /** Macro template ID (0-255) */
+    macroId: number;
+    /** Layer ID (0-255) */
+    layerId: number;
+    /** Position X (cells) */
+    x: number;
+    /** Position Y (cells) */
+    y: number;
+    /** Tab index for keyboard navigation (0 = not focusable) */
+    tabIndex: number;
+    /** Instance parameters (JSON) */
+    params: Record<string, unknown>;
 }
 /**
- * 0x01 - Char: Renders a single character at a specific position
+ * UpdateInstance order - updates an existing instance's params
  */
-interface CharOrder extends NetworkOrder {
-    type: 0x01;
-    posX: number;
-    posY: number;
-    charCode: number;
-    bgColorCode: number;
-    fgColorCode: number;
+interface UpdateInstanceOrder extends MacroOrder {
+    type: MacroOrderType.UpdateInstance;
+    /** Instance ID (0-255) */
+    instanceId: number;
+    /** Updated parameters (JSON) */
+    params: Record<string, unknown>;
 }
 /**
- * 0x02 - Text: Renders a string of characters with uniform colors
+ * RemoveInstance order - removes an instance
  */
-interface TextOrder extends NetworkOrder {
-    type: 0x02;
-    posX: number;
-    posY: number;
-    text: string;
-    bgColorCode: number;
-    fgColorCode: number;
+interface RemoveInstanceOrder extends MacroOrder {
+    type: MacroOrderType.RemoveInstance;
+    /** Instance ID (0-255) */
+    instanceId: number;
+}
+/**
+ * Any macro order type
+ */
+type AnyMacroOrder = CreateInstanceOrder | UpdateInstanceOrder | RemoveInstanceOrder;
+/**
+ * Base interface for macro events
+ */
+interface MacroEvent {
+    type: MacroEventType;
+    /** Instance ID (0-255) */
+    instanceId: number;
 }
 /**
- * 0x17 - TextMultiline: Renders multiple lines of text (\n for line breaks)
+ * Click event - element was clicked
  */
-interface TextMultilineOrder extends NetworkOrder {
-    type: 0x17;
-    posX: number;
-    posY: number;
-    text: string;
-    bgColorCode: number;
-    fgColorCode: number;
+interface ClickEvent extends MacroEvent {
+    type: MacroEventType.Click;
 }
 /**
- * 0x03 - SubFrame: Renders a rectangular region with uniform colors
+ * Change event - value changed
  */
-interface SubFrameOrder extends NetworkOrder {
-    type: 0x03;
-    posX: number;
-    posY: number;
-    sizeX: number;
-    sizeY: number;
-    bgColorCode: number;
-    fgColorCode: number;
-    frame: number[];
+interface ChangeEvent extends MacroEvent {
+    type: MacroEventType.Change;
+    /** New value (number or boolean) */
+    value: number | boolean;
 }
 /**
- * 0x04 - SubFrameMultiColor: Rectangular region with per-cell colors
+ * Submit event - text was submitted
  */
-interface SubFrameMultiColorOrder extends NetworkOrder {
-    type: 0x04;
-    posX: number;
-    posY: number;
-    sizeX: number;
-    sizeY: number;
-    frame: Array<{
-        charCode: number;
-        bgColorCode: number;
-        fgColorCode: number;
-    }>;
+interface SubmitEvent extends MacroEvent {
+    type: MacroEventType.Submit;
+    /** Submitted text */
+    text: string;
 }
 /**
- * 0x05 - FullFrame: Renders entire screen with uniform colors
+ * Select event - item was selected
  */
-interface FullFrameOrder extends NetworkOrder {
-    type: 0x05;
-    bgColorCode: number;
-    fgColorCode: number;
-    frame: number[];
+interface SelectEvent extends MacroEvent {
+    type: MacroEventType.Select;
+    /** Selected index */
+    index: number;
 }
 /**
- * 0x06 - FullFrameMultiColor: Entire screen with per-cell colors
+ * Any macro event type
  */
-interface FullFrameMultiColorOrder extends NetworkOrder {
-    type: 0x06;
-    frame: Array<{
-        charCode: number;
-        bgColorCode: number;
-        fgColorCode: number;
-    }>;
-}
+type AnyMacroEvent = ClickEvent | ChangeEvent | SubmitEvent | SelectEvent;
 /**
- * 0x07 - Sprite: Renders a preloaded unicolor sprite
+ * Check if a number is a valid MacroOrderType
  */
-interface SpriteOrder extends NetworkOrder {
-    type: 0x07;
-    posX: number;
-    posY: number;
-    spriteIndex: number;
-    bgColorCode: number;
+declare function isValidMacroOrderType(type: number): type is MacroOrderType;
+/**
+ * Check if a number is a valid MacroEventType
+ */
+declare function isValidMacroEventType(type: number): type is MacroEventType;
+/**
+ * Get human-readable name for a MacroOrderType
+ */
+declare function getMacroOrderTypeName(type: MacroOrderType): string;
+/**
+ * Get human-readable name for a MacroEventType
+ */
+declare function getMacroEventTypeName(type: MacroEventType): string;
+
+interface Cell {
+    charCode: number;
     fgColorCode: number;
+    bgColorCode: number;
 }
 /**
- * 0x08 - SpriteMultiColor: Renders a preloaded multicolor sprite
+ * 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
  */
-interface SpriteMultiColorOrder extends NetworkOrder {
-    type: 0x08;
-    posX: number;
-    posY: number;
-    spriteIndex: number;
+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;
 }
 /**
- * 0x09 - ColorMap: Applies colors to a region without changing characters
+ * 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
  */
-interface ColorMapOrder extends NetworkOrder {
-    type: 0x09;
-    posX: number;
-    posY: number;
+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;
-    colorData: Array<{
-        bgColorCode: number;
-        fgColorCode: number;
-    }>;
+    data: CharCodeBuffer;
 }
 /**
- * 0x0A - Shape: Renders geometric shapes
+ * Multicolor sprite - Stores charcodes + fg/bg colors
+ * Each cell contains its own color set
+ *
+ * Used with LoadType.MulticolorSprite (0x03) and SpriteMultiColorOrder (0x08)
  */
-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 MulticolorSprite {
+    id: number;
+    sizeX: number;
+    sizeY: number;
+    data: CellBuffer;
 }
-interface LineShape {
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-    charCode: number;
-    bgColorCode: number;
-    fgColorCode: number;
+
+/**
+ * UTSP Macro Load Packet
+ *
+ * LoadType 0x07 - Macro template loading
+ * JSON-based (not binary) since it's only loaded once at init time.
+ */
+
+/**
+ * Macro Load (LoadType 0x07)
+ * Loads a macro template for client-side instantiation
+ */
+interface MacroLoad {
+    loadType: 0x07;
+    /** Macro ID (0-255) - numeric ID for network transmission */
+    macroId: number;
+    /** Macro template definition (JSON) */
+    template: MacroTemplate;
 }
-interface EllipseShape {
-    centerX: number;
-    centerY: number;
-    radiusX: number;
-    radiusY: number;
-    filled: boolean;
-    charCode: number;
-    bgColorCode: number;
-    fgColorCode: number;
+
+/**
+ * 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,// CSS-based fonts for browser rendering
+    Macro = 7
 }
-interface TriangleShape {
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-    x3: number;
-    y3: number;
-    filled: boolean;
-    charCode: number;
-    bgColorCode: number;
-    fgColorCode: number;
+/**
+ * Color definition with RGBA+E values
+ */
+interface Color {
+    colorId: number;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    e?: number;
 }
 /**
- * 0x0B - DotCloud: Same character at multiple positions (up to 65535)
+ * Color Palette Load (LoadType 0x01)
+ * Loads a palette of RGBA+E colors
  */
-interface DotCloudOrder extends NetworkOrder {
-    type: 0x0b;
-    charCode: number;
-    bgColorCode: number;
-    fgColorCode: number;
-    positions: Array<{
-        posX: number;
-        posY: number;
-    }>;
+interface ColorPaletteLoad {
+    loadType: LoadType.ColorPalette;
+    colors: Color[];
 }
 /**
- * 0x0C - DotCloudMultiColor: Different characters at multiple positions
+ * Simple Sprite Load (LoadType 0x02)
+ * Each cell contains only a character code
  */
-interface DotCloudMultiColorOrder extends NetworkOrder {
-    type: 0x0c;
-    dots: Array<{
-        charCode: number;
-        bgColorCode: number;
-        fgColorCode: number;
-        posX: number;
-        posY: number;
+interface SpriteLoad {
+    loadType: LoadType.Sprite;
+    sprites: Array<{
+        spriteId: number;
+        sizeX: number;
+        sizeY: number;
+        data: number[];
     }>;
 }
 /**
- * 0x0D - SpriteCloud: Same unicolor sprite at multiple positions
+ * Cell in a multicolor sprite
  */
-interface SpriteCloudOrder extends NetworkOrder {
-    type: 0x0d;
-    spriteIndex: number;
-    bgColorCode: number;
-    fgColorCode: number;
-    positions: Array<{
-        posX: number;
-        posY: number;
-    }>;
+interface MulticolorCell {
+    charCode: number;
+    fgColorId: number;
+    bgColorId: number;
 }
 /**
- * 0x0E - SpriteCloudMultiColor: Same multicolor sprite at multiple positions
+ * Multicolor Sprite Load (LoadType 0x03)
+ * Each cell contains charcode + foreground color + background color
  */
-interface SpriteCloudMultiColorOrder extends NetworkOrder {
-    type: 0x0e;
-    spriteIndex: number;
-    positions: Array<{
-        posX: number;
-        posY: number;
+interface MulticolorSpriteLoad {
+    loadType: LoadType.MulticolorSprite;
+    sprites: Array<{
+        spriteId: number;
+        sizeX: number;
+        sizeY: number;
+        data: MulticolorCell[];
     }>;
 }
 /**
- * 0x0F - SpriteCloudVaried: Different unicolor sprites at multiple positions
+ * BitmapFont Load (LoadType 0x04)
+ * Custom character definitions (monochrome bitmaps)
+ * Formerly known as "Charset" - renamed to BitmapFont for clarity
  */
-interface SpriteCloudVariedOrder extends NetworkOrder {
-    type: 0x0f;
-    sprites: Array<{
-        spriteIndex: number;
-        bgColorCode: number;
-        fgColorCode: number;
-        posX: number;
-        posY: number;
+interface BitmapFontLoad {
+    loadType: LoadType.BitmapFont;
+    fontId: number;
+    width: number;
+    height: number;
+    cellWidth: number;
+    cellHeight: number;
+    characters: Array<{
+        charCode: number;
+        bitmap: Uint8Array;
     }>;
 }
 /**
- * 0x10 - SpriteCloudVariedMultiColor: Different multicolor sprites at multiple positions
+ * 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 SpriteCloudVariedMultiColorOrder extends NetworkOrder {
-    type: 0x10;
-    sprites: Array<{
-        spriteIndex: number;
-        posX: number;
-        posY: number;
+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;
     }>;
 }
+
 /**
- * 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.
+ * Union type for all load types
  */
-interface BitmaskOrder extends NetworkOrder {
-    type: 0x11;
-    posX: number;
-    posY: number;
-    sizeX: number;
-    sizeY: number;
-    charCode: number;
-    bgColorCode: number;
-    fgColorCode: number;
-    override: boolean;
-    mask: Uint8Array;
+type AnyLoad = ColorPaletteLoad | SpriteLoad | MulticolorSpriteLoad | BitmapFontLoad | SoundLoad | WebFontLoad | MacroLoad;
+
+/**
+ * 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;
 }
+
 /**
- * Cell variant definition for Bitmask4 order
+ * MacroHandler - Base interface for macro type handlers
+ *
+ * Each handler manages a specific type of macro:
+ * - UIHandler: Buttons, interactive elements
+ * - ParticleHandler: Particle systems (rain, snow, explosions)
+ * - EffectHandler: Screen effects (shake, flash)
+ * - RevealHandler: Progressive text/sprite reveal
  */
-interface Bitmask4Variant {
-    charCode: number;
-    bgColorCode: number;
-    fgColorCode: number;
-}
+
 /**
- * 0x12 - Bitmask4: Renders a rectangular region with 2-bit packed mask
- * Each 2-bit value represents: 0 = absence, 1-3 = variant index
+ * Base interface for macro instance
  */
-interface Bitmask4Order extends NetworkOrder {
-    type: 0x12;
-    posX: number;
-    posY: number;
-    sizeX: number;
-    sizeY: number;
-    override: boolean;
-    variants: [Bitmask4Variant, Bitmask4Variant, Bitmask4Variant];
-    mask: Uint8Array;
+interface BaseMacroInstance {
+    instanceId: number;
+    macroId: number;
+    layerId: number;
+    x: number;
+    y: number;
+    params: Record<string, unknown>;
 }
 /**
- * Cell variant definition for Bitmask16 order
+ * UI macro instance with state tracking
  */
-interface Bitmask16Variant {
-    charCode: number;
-    bgColorCode: number;
-    fgColorCode: number;
+interface UIInstance extends BaseMacroInstance {
+    type: 'ui';
+    tabIndex: number;
+    isHovered: boolean;
+    isFocused: boolean;
+    isActive: boolean;
+    isDisabled: boolean;
 }
 /**
- * 0x18 - Bitmask16: Renders a rectangular region with 4-bit packed mask
- * Each 4-bit value represents: 0 = absence, 1-15 = variant index
+ * Single particle in a particle system
  */
-interface Bitmask16Order extends NetworkOrder {
-    type: 0x18;
-    posX: number;
-    posY: number;
-    sizeX: number;
-    sizeY: number;
-    override: boolean;
-    variants: Bitmask16Variant[];
-    mask: Uint8Array;
+interface Particle {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    char: string;
+    fg: number;
+    bg?: number;
+    lifetime: number;
+    maxLifetime: number;
 }
 /**
- * 0x13 - Clear: Fills entire layer with single character and colors
+ * Particle macro instance with active particles
  */
-interface ClearOrder extends NetworkOrder {
-    type: 0x13;
-    charCode: number;
-    bgColorCode: number;
-    fgColorCode: number;
+interface ParticleInstance extends BaseMacroInstance {
+    type: 'particle';
+    particles: Particle[];
+    timeSinceEmit: number;
+    emitDone: boolean;
 }
 /**
- * 0x14 - FillChar: Fills layer with repeating character pattern
+ * Effect macro instance with animation state
  */
-interface FillCharOrder extends NetworkOrder {
-    type: 0x14;
-    patternWidth: number;
-    patternHeight: number;
-    bgColorCode: number;
-    fgColorCode: number;
-    pattern: number[];
+interface EffectInstance extends BaseMacroInstance {
+    type: 'effect';
+    elapsed: number;
+    duration: number;
+    currentOffsetX: number;
+    currentOffsetY: number;
 }
 /**
- * 0x15 - FillSprite: Fills layer with repeating unicolor sprite
+ * Cell data for reveal macro
  */
-interface FillSpriteOrder extends NetworkOrder {
-    type: 0x15;
-    spriteIndex: number;
-    bgColorCode: number;
-    fgColorCode: number;
+interface RevealCell {
+    char: string;
+    fg: number;
+    bg: number;
+    x: number;
+    y: number;
+    revealOrder: number;
 }
 /**
- * 0x16 - FillSpriteMultiColor: Fills layer with repeating multicolor sprite
+ * Reveal macro instance with progressive display state
  */
-interface FillSpriteMultiColorOrder extends NetworkOrder {
-    type: 0x16;
-    spriteIndex: number;
+interface RevealInstance extends BaseMacroInstance {
+    type: 'reveal';
+    cells: RevealCell[];
+    revealedCount: number;
+    totalCells: number;
+    delayRemaining: number;
+    pauseRemaining: number;
+    finished: boolean;
+    direction: 'reveal' | 'hide';
+    speed: number;
+    blinkState: boolean;
+    blinkTimer: number;
 }
 /**
- * 0x20 - TriggerSound: Triggers positional sound effect
+ * Point in a line renderer
  */
-interface TriggerSoundOrder extends NetworkOrder {
-    type: 0x20;
-    posX: number;
-    posY: number;
-    soundId: number;
-    loop: boolean;
+interface LinePoint {
+    x: number;
+    y: number;
+    addedAt: number;
 }
 /**
- * 0x21 - TriggerGlobalSound: Triggers global (non-positional) sound
+ * Line macro instance with point history
  */
-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 | Bitmask4Order | Bitmask16Order | 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[];
+interface LineInstance extends BaseMacroInstance {
+    type: 'line';
+    points: LinePoint[];
+    currentTick: number;
 }
+/**
+ * Union of all macro instance types
+ */
+type MacroInstance = UIInstance | ParticleInstance | EffectInstance | RevealInstance | LineInstance;
 
 /**
- * Update packet according to the new UTSP protocol
+ * MacroEngine - Client-side macro execution engine
  *
- * Structure:
- * - Tick (8 bytes): Frame counter for synchronization
- * - Displays: Viewport definitions
- * - Layers: Render orders for visual output
- * - Audio Orders: Audio commands synchronized with the frame
+ * Manages:
+ * - Macro template storage
+ * - Instance lifecycle
+ * - UI state machine (hover, focus, active)
+ * - Particle systems
+ * - Effect animations
+ * - Order generation for rendering
  *
- * Audio orders are in the same packet as render orders to ensure
- * perfect frame-level synchronization between visuals and sound.
+ * This engine is part of @utsp/core and runs on the client side.
+ * It receives macro orders from the server and generates render orders locally.
  */
-interface UpdatePacket {
-    /** Tick counter (8 bytes) */
-    tick: number;
-    /** Number of displays (1 byte) */
-    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[];
-    /** Number of audio orders (1 byte) */
-    audioOrderCount: number;
-    /** List of audio orders (synchronized with this frame) */
-    audioOrders: AnyAudioOrder[];
-}
 
 /**
- * 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)
+ * Result of macro engine update
+ * Only contains events to send to server - sounds are played directly via callback
  */
-declare class Display {
-    private id;
-    private origin;
-    private size;
-    private previousOrigin;
-    private previousSize;
-    private toDraw;
-    constructor(id?: number, sizeX?: number, sizeY?: number);
+interface MacroUpdateResult {
+    /** Events to send to server (click, change, etc.) */
+    events: {
+        instanceId: number;
+        event: string;
+        data?: unknown;
+    }[];
+}
+/**
+ * MacroEngine - Executes macros on the client side
+ */
+declare class MacroEngine {
+    private templates;
+    private instances;
+    private spriteRegistry;
+    private playSound;
+    private focusedInstanceId;
+    private focusableInstances;
+    private mouseX;
+    private mouseY;
+    private mouseDown;
+    private readonly particleHandler;
+    private readonly effectHandler;
+    private readonly revealHandler;
+    private readonly lineHandler;
+    private instancesToDelete;
     /**
-     * Gets the display ID (0-255)
+     * Injects SpriteRegistry (called by User when setting up)
+     * Required for reveal macros with sprite content
      */
-    getId(): number;
+    setSpriteRegistry(registry: SpriteRegistry): void;
     /**
-     * Gets the origin position in the world
+     * Sets audio callback for playing sounds directly from macros
+     * Sounds are played immediately on state changes (hover, click, etc.)
+     *
+     * @param callback - Function that plays a sound by ID
      */
-    getOrigin(): Vector2;
+    setAudioCallback(callback: (soundId: number) => void): void;
     /**
-     * Sets the origin position in the world
+     * Create the context object used by handlers
      */
-    setOrigin(origin: Vector2): void;
+    private createContext;
     /**
-     * Moves the origin in the world
+     * Load a macro template (called when receiving LoadMacro packet)
      */
-    moveOrigin(deltaX: number, deltaY: number): void;
+    loadTemplate(macroId: number, template: MacroTemplate): void;
     /**
-     * Checks if display origin has changed since last tick
-     * @internal - Used to calculate if update should be sent
+     * Get a template by ID
      */
-    hasOriginChanged(): boolean;
+    getTemplate(macroId: number): MacroTemplate | undefined;
     /**
-     * Checks if display size has changed since last tick
-     * @internal - Used to calculate if update should be sent
+     * Check if a template is loaded
      */
-    hasSizeChanged(): boolean;
+    hasTemplate(macroId: number): boolean;
     /**
-     * Checks if display has changed (origin OR size)
-     * @internal
+     * Apply a macro order (called when decoding UpdatePacket)
      */
-    hasChanged(): boolean;
+    applyOrder(order: AnyMacroOrder): void;
     /**
-     * Resets change tracking
-     * @internal - Called by Core.endTick() after sending updates
+     * Create a new instance
      */
-    resetChangeTracking(): void;
+    private createInstance;
     /**
-     * Gets the display size
+     * Update an existing instance
      */
-    getSize(): Vector2;
+    private updateInstance;
     /**
-     * Sets the display size
+     * Remove an instance
      */
-    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);
+    private removeInstance;
+    private addToFocusableList;
+    private removeFromFocusableList;
     /**
-     * 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)
+     * Move focus to next focusable element
      */
-    clear(): void;
+    focusNext(): 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);
+     * Move focus to previous focusable element
      */
-    clearWithColor(charCode: number, fgColorCode: number, bgColorCode: number): void;
+    focusPrevious(): void;
     /**
-     * Sets a cell at given index
+     * Set focus to a specific instance
      */
-    set(index: number, charCode: number, fgColorCode: number, bgColorCode: number): void;
+    setFocus(instanceId: number | null): 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
+     * Update mouse state for UI interaction
+     * @param x - Mouse X position in cells (world coordinates)
+     * @param y - Mouse Y position in cells (world coordinates)
+     * @param isDown - Whether the mouse button is pressed
      */
-    fillCharsUniform(indices: number[], charCode: number, fgColorCode: number, bgColorCode: number): void;
+    updateMouse(x: number, y: number, isDown: boolean): void;
     /**
-     * Gets a cell at given index
-     * Returns a Cell object for compatibility
+     * Estimate UI element size from template configuration
      */
-    get(index: number): Cell;
+    private estimateUISize;
     /**
-     * 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
+     * Activate the currently focused element (trigger click)
      */
-    setCharOnly(index: number, charCode: number): void;
+    activateFocused(): void;
     /**
-     * Sets only colors at given index (keeps existing char)
-     * Useful for ColorMapOrder (updates colors, preserves chars)
+     * Update all instances (called each tick)
      *
-     * @param index - Cell index
-     * @param fgColorCode - Foreground color
-     * @param bgColorCode - Background color
+     * @returns Update result with events to send to server
+     */
+    update(): MacroUpdateResult;
+    /**
+     * Get render orders grouped by layer
+     */
+    getOrdersByLayer(): Map<number, AnyNetworkOrder[]>;
+    /**
+     * Render a single instance to orders
+     */
+    private renderInstance;
+    /**
+     * Resolve a value that may be a parameter reference ($param)
+     */
+    private resolveValue;
+    /**
+     * Resolve a random value (number or [min, max])
      */
-    setColorsOnly(index: number, fgColorCode: number, bgColorCode: number): void;
+    private resolveRandomValue;
     /**
-     * Direct value access (faster than get())
-     * Note: These are called in hot loops, keep as inline as possible
+     * Get the current effect offset (for screen shake, etc.)
      */
-    getCharCode(index: number): number;
-    getFgColorCode(index: number): number;
-    getBgColorCode(index: number): number;
+    getEffectOffset(): {
+        x: number;
+        y: number;
+    };
     /**
-     * Direct TypedArray access for batch operations
+     * Get all active instances
      */
-    getRawData(): Uint8Array;
+    getAllInstances(): MacroInstance[];
     /**
-     * Buffer size (number of cells)
+     * Get instance count
      */
-    getSize(): number;
+    getInstanceCount(): number;
+    /**
+     * Clear all templates and instances
+     */
+    clear(): void;
 }
+
 /**
- * Optimized buffer to store only charcodes (unicolor sprites)
- * Simple structure: [char0, char1, char2, ...]
+ * UTSP Audio Order Types Enumeration
  *
- * 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
+ * Audio orders are separate from render orders and have their own type space.
+ * They are included in the UpdatePacket but processed by the AudioProcessor,
+ * not the Rasterizer.
+ *
+ * This separation ensures:
+ * - Clear distinction between visual and audio orders
+ * - Independent type numbering (0x01 audio ≠ 0x01 render)
+ * - Extensibility without conflicts
+ *
+ * @example
+ * ```typescript
+ * import { AudioOrderType } from '@utsp/core';
+ *
+ * const order = { type: AudioOrderType.PlaySound, soundId: 0, volume: 200 };
+ * ```
  */
-declare class CharCodeBuffer {
-    private data;
-    private size;
-    constructor(size: number);
+declare enum AudioOrderType {
     /**
-     * Optimized clear: fills with zeros (no character)
+     * 0x01 - PlaySound: Play a sound with optional spatial position
+     *
+     * Parameters: soundId, instanceId, flags, volume?, pitch?, fadeIn?, posX?, posY?
      */
-    clear(): void;
+    PlaySound = 1,
     /**
-     * Sets a charcode at given index
+     * 0x02 - PlayGlobalSound: Play a non-positional (global) sound
+     *
+     * Parameters: soundId, instanceId, flags, volume?, pitch?, fadeIn?
      */
-    set(index: number, charCode: number): void;
+    PlayGlobalSound = 2,
     /**
-     * Gets a charcode at given index
+     * 0x03 - StopSound: Stop a sound immediately
+     *
+     * Parameters: targetType, target (instanceId, soundId, or 'all')
      */
-    get(index: number): number;
+    StopSound = 3,
     /**
-     * Direct TypedArray access for batch operations
+     * 0x04 - FadeOutSound: Fade out and stop a sound
+     *
+     * Parameters: targetType, target, duration
      */
-    getRawData(): Uint8Array;
+    FadeOutSound = 4,
     /**
-     * Buffer size (number of cells)
+     * 0x05 - PauseSound: Pause a playing sound
+     *
+     * Parameters: targetType, target
      */
-    getSize(): number;
+    PauseSound = 5,
+    /**
+     * 0x06 - ResumeSound: Resume a paused sound
+     *
+     * Parameters: targetType, target
+     */
+    ResumeSound = 6,
+    /**
+     * 0x07 - SetListenerPosition: Set the listener position for spatial audio
+     *
+     * Parameters: x, y (16-bit each)
+     */
+    SetListenerPosition = 7,
+    /**
+     * 0x08 - ConfigureSpatial: Configure spatial audio parameters
+     *
+     * Parameters: maxDistance, referenceDistance, rolloffFactor, panSpread
+     */
+    ConfigureSpatial = 8,
+    /**
+     * 0x09 - SetSoundEffects: Set audio effects on a playing sound
+     *
+     * Parameters: instanceId, flags, lowpass?, highpass?, reverb?
+     */
+    SetSoundEffects = 9
 }
+/**
+ * Target type for stop/pause/resume/fadeout commands
+ */
+declare enum AudioTargetType {
+    /** Target a specific instance by ID */
+    InstanceId = 0,
+    /** Target all instances of a sound by soundId */
+    SoundId = 1,
+    /** Target all sounds */
+    All = 2
+}
+/**
+ * Type guard to check if a number is a valid AudioOrderType
+ */
+declare function isValidAudioOrderType(type: number): type is AudioOrderType;
+/**
+ * Get human-readable name for an AudioOrderType
+ */
+declare function getAudioOrderTypeName(type: AudioOrderType | number): string;
 
 /**
- * Unicolor sprite - Stores only charcodes
- * Colors (fg/bg) are defined at render time via SpriteOrder
+ * UTSP Audio Orders
  *
- * Used with LoadType.Sprite (0x02) and SpriteOrder (0x07)
+ * Binary-encoded audio commands included in UpdatePacket.
+ * Processed by AudioProcessor on client, synchronized with render orders.
+ *
+ * Each order has a specific binary structure optimized for network transmission.
  */
-interface UnicolorSprite {
-    id: number;
-    sizeX: number;
-    sizeY: number;
-    data: CharCodeBuffer;
+
+/**
+ * Base interface for all audio orders
+ */
+interface AudioOrder {
+    /** Audio order type identifier */
+    type: AudioOrderType;
 }
 /**
- * Multicolor sprite - Stores charcodes + fg/bg colors
- * Each cell contains its own color set
+ * Flags for PlaySound/PlayGlobalSound orders
+ * Packed into a single byte to minimize bandwidth
+ */
+declare enum PlaySoundFlags {
+    /** Sound should loop */
+    Loop = 1,
+    /** Volume is specified (otherwise default 100%) */
+    HasVolume = 2,
+    /** Pitch is specified (otherwise default 1.0x) */
+    HasPitch = 4,
+    /** FadeIn duration is specified (otherwise instant) */
+    HasFadeIn = 8,
+    /** Position is specified (only for PlaySound, not PlayGlobalSound) */
+    HasPosition = 16,
+    /** Low-pass filter is specified */
+    HasLowpass = 32,
+    /** High-pass filter is specified */
+    HasHighpass = 64,
+    /** Reverb mix is specified */
+    HasReverb = 128
+}
+/**
+ * 0x01 - PlaySound: Play a sound with optional spatial position
  *
- * Used with LoadType.MulticolorSprite (0x03) and SpriteMultiColorOrder (0x08)
+ * Binary structure (variable size, 4-15 bytes):
+ * - type: 1 byte (0x01)
+ * - soundId: 1 byte (0-255)
+ * - instanceId: 2 bytes (big-endian, unique ID for this playback)
+ * - flags: 1 byte (PlaySoundFlags bitfield)
+ * - volume?: 1 byte (0-255, maps to 0.0-1.0) - if HasVolume
+ * - pitch?: 1 byte (0-255, maps to 0.25x-4.0x, 128=1.0x) - if HasPitch
+ * - fadeIn?: 1 byte (0-255, duration in 1/10 seconds, 0=instant) - if HasFadeIn
+ * - posX?: 2 bytes (big-endian, 0-65535) - if HasPosition
+ * - posY?: 2 bytes (big-endian, 0-65535) - if HasPosition
+ * - lowpass?: 1 byte (0-255, * 100 = Hz cutoff) - if HasLowpass
+ * - highpass?: 1 byte (0-255, * 100 = Hz cutoff) - if HasHighpass
+ * - reverb?: 1 byte (0-255, / 255 = wet mix 0.0-1.0) - if HasReverb
  */
-interface MulticolorSprite {
-    id: number;
-    sizeX: number;
-    sizeY: number;
-    data: CellBuffer;
+interface PlaySoundOrder extends AudioOrder {
+    type: AudioOrderType.PlaySound;
+    /** Sound ID (0-255) */
+    soundId: number;
+    /** Unique instance ID for this playback */
+    instanceId: number;
+    /** Flags bitfield */
+    flags: number;
+    /** Volume (0-255, maps to 0.0-1.0). Present if HasVolume flag set */
+    volume?: number;
+    /** Pitch (0-255, 128=1.0x). Present if HasPitch flag set */
+    pitch?: number;
+    /** Fade in duration in 1/10 seconds. Present if HasFadeIn flag set */
+    fadeIn?: number;
+    /** X position (0-65535). Present if HasPosition flag set */
+    posX?: number;
+    /** Y position (0-65535). Present if HasPosition flag set */
+    posY?: number;
+    /** Low-pass filter cutoff (0-255, * 100 = Hz). Present if HasLowpass flag set */
+    lowpass?: number;
+    /** High-pass filter cutoff (0-255, * 100 = Hz). Present if HasHighpass flag set */
+    highpass?: number;
+    /** Reverb wet mix (0-255, / 255 = 0.0-1.0). Present if HasReverb flag set */
+    reverb?: number;
 }
-
 /**
- * UTSP Load Packet Types
- * Based on UTSP Protocol v0.1 - Section 4: Load Section
+ * 0x02 - PlayGlobalSound: Play a non-positional sound
+ *
+ * Binary structure (variable size, 4-10 bytes):
+ * - type: 1 byte (0x02)
+ * - soundId: 1 byte (0-255)
+ * - instanceId: 2 bytes (big-endian)
+ * - flags: 1 byte (PlaySoundFlags, but HasPosition is ignored)
+ * - volume?: 1 byte - if HasVolume
+ * - pitch?: 1 byte - if HasPitch
+ * - fadeIn?: 1 byte - if HasFadeIn
+ * - lowpass?: 1 byte - if HasLowpass
+ * - highpass?: 1 byte - if HasHighpass
+ * - reverb?: 1 byte - if HasReverb
  */
+interface PlayGlobalSoundOrder extends AudioOrder {
+    type: AudioOrderType.PlayGlobalSound;
+    /** Sound ID (0-255) */
+    soundId: number;
+    /** Unique instance ID for this playback */
+    instanceId: number;
+    /** Flags bitfield (HasPosition ignored) */
+    flags: number;
+    /** Volume (0-255). Present if HasVolume flag set */
+    volume?: number;
+    /** Pitch (0-255, 128=1.0x). Present if HasPitch flag set */
+    pitch?: number;
+    /** Fade in duration in 1/10 seconds. Present if HasFadeIn flag set */
+    fadeIn?: number;
+    /** Low-pass filter cutoff (0-255, * 100 = Hz). Present if HasLowpass flag set */
+    lowpass?: number;
+    /** High-pass filter cutoff (0-255, * 100 = Hz). Present if HasHighpass flag set */
+    highpass?: number;
+    /** Reverb wet mix (0-255, / 255 = 0.0-1.0). Present if HasReverb flag set */
+    reverb?: number;
+}
 /**
- * LoadType enumeration
+ * 0x03 - StopSound: Stop a sound immediately
+ *
+ * Binary structure (3-4 bytes):
+ * - type: 1 byte (0x03)
+ * - targetType: 1 byte (AudioTargetType)
+ * - target: 1-2 bytes (instanceId=2B, soundId=1B, all=0B)
  */
-declare enum LoadType {
-    ColorPalette = 1,
-    Sprite = 2,
-    MulticolorSprite = 3,
-    BitmapFont = 4,// Formerly "Charset" - pixel-based fonts
-    Sound = 5,
-    WebFont = 6
+interface StopSoundOrder extends AudioOrder {
+    type: AudioOrderType.StopSound;
+    /** Type of target */
+    targetType: AudioTargetType;
+    /** Target value (instanceId, soundId, or undefined for 'all') */
+    target?: number;
 }
 /**
- * Color definition with RGBA+E values
+ * 0x04 - FadeOutSound: Fade out and stop a sound
+ *
+ * Binary structure (4-5 bytes):
+ * - type: 1 byte (0x04)
+ * - targetType: 1 byte
+ * - duration: 1 byte (1/10 seconds, 0-25.5s)
+ * - target: 1-2 bytes
  */
-interface Color {
-    colorId: number;
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-    e?: number;
+interface FadeOutSoundOrder extends AudioOrder {
+    type: AudioOrderType.FadeOutSound;
+    /** Type of target */
+    targetType: AudioTargetType;
+    /** Fade duration in 1/10 seconds (0-255 = 0-25.5 seconds) */
+    duration: number;
+    /** Target value */
+    target?: number;
 }
 /**
- * Color Palette Load (LoadType 0x01)
- * Loads a palette of RGBA+E colors
+ * 0x05 - PauseSound: Pause a playing sound
+ *
+ * Binary structure (2-4 bytes):
+ * - type: 1 byte (0x05)
+ * - targetType: 1 byte
+ * - target: 0-2 bytes
  */
-interface ColorPaletteLoad {
-    loadType: LoadType.ColorPalette;
-    colors: Color[];
+interface PauseSoundOrder extends AudioOrder {
+    type: AudioOrderType.PauseSound;
+    /** Type of target */
+    targetType: AudioTargetType;
+    /** Target value */
+    target?: number;
 }
 /**
- * Simple Sprite Load (LoadType 0x02)
- * Each cell contains only a character code
+ * 0x06 - ResumeSound: Resume a paused sound
+ *
+ * Binary structure (2-4 bytes):
+ * - type: 1 byte (0x06)
+ * - targetType: 1 byte
+ * - target: 0-2 bytes
  */
-interface SpriteLoad {
-    loadType: LoadType.Sprite;
-    sprites: Array<{
-        spriteId: number;
-        sizeX: number;
-        sizeY: number;
-        data: number[];
-    }>;
+interface ResumeSoundOrder extends AudioOrder {
+    type: AudioOrderType.ResumeSound;
+    /** Type of target */
+    targetType: AudioTargetType;
+    /** Target value */
+    target?: number;
 }
 /**
- * Cell in a multicolor sprite
+ * 0x07 - SetListenerPosition: Set listener position for spatial audio
+ *
+ * Binary structure (5 bytes):
+ * - type: 1 byte (0x07)
+ * - x: 2 bytes (big-endian, 0-65535)
+ * - y: 2 bytes (big-endian, 0-65535)
  */
-interface MulticolorCell {
-    charCode: number;
-    fgColorId: number;
-    bgColorId: number;
+interface SetListenerPositionOrder extends AudioOrder {
+    type: AudioOrderType.SetListenerPosition;
+    /** X position (0-65535) */
+    x: number;
+    /** Y position (0-65535) */
+    y: number;
 }
 /**
- * Multicolor Sprite Load (LoadType 0x03)
- * Each cell contains charcode + foreground color + background color
+ * 0x08 - ConfigureSpatial: Configure spatial audio parameters
+ *
+ * Binary structure (5 bytes):
+ * - type: 1 byte (0x08)
+ * - maxDistance: 1 byte (0-255, scaled appropriately)
+ * - referenceDistance: 1 byte (0-255)
+ * - rolloffFactor: 1 byte (0-255, maps to 0.0-2.55)
+ * - panSpread: 1 byte (0-255, maps to 0.0-1.0)
  */
-interface MulticolorSpriteLoad {
-    loadType: LoadType.MulticolorSprite;
-    sprites: Array<{
-        spriteId: number;
-        sizeX: number;
-        sizeY: number;
-        data: MulticolorCell[];
-    }>;
+interface ConfigureSpatialOrder extends AudioOrder {
+    type: AudioOrderType.ConfigureSpatial;
+    /** Maximum audible distance (encoded, 0-255) */
+    maxDistance: number;
+    /** Reference distance for full volume (encoded, 0-255) */
+    referenceDistance: number;
+    /** Rolloff factor (0-255, maps to 0.0-2.55) */
+    rolloffFactor: number;
+    /** Pan spread factor (0-255, maps to 0.0-1.0) */
+    panSpread: number;
 }
 /**
- * BitmapFont Load (LoadType 0x04)
- * Custom character definitions (monochrome bitmaps)
- * Formerly known as "Charset" - renamed to BitmapFont for clarity
+ * Flags for SetSoundEffects order
  */
-interface BitmapFontLoad {
-    loadType: LoadType.BitmapFont;
-    fontId: number;
-    width: number;
-    height: number;
-    cellWidth: number;
-    cellHeight: number;
-    characters: Array<{
-        charCode: number;
-        bitmap: Uint8Array;
-    }>;
+declare enum SoundEffectsFlags {
+    /** Low-pass filter is specified */
+    HasLowpass = 1,
+    /** High-pass filter is specified */
+    HasHighpass = 2,
+    /** Reverb mix is specified */
+    HasReverb = 4
 }
 /**
- * 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
+ * 0x09 - SetSoundEffects: Update audio effects on a playing sound
+ *
+ * Binary structure (variable size, 4-7 bytes):
+ * - type: 1 byte (0x09)
+ * - instanceId: 2 bytes (big-endian)
+ * - flags: 1 byte (SoundEffectsFlags bitfield)
+ * - lowpass?: 1 byte (0-255, * 100 = Hz cutoff) - if HasLowpass
+ * - highpass?: 1 byte (0-255, * 100 = Hz cutoff) - if HasHighpass
+ * - reverb?: 1 byte (0-255, / 255 = wet mix 0.0-1.0) - if HasReverb
  */
-interface WebFontLoad {
-    loadType: LoadType.WebFont;
-    fontId: number;
-    fontFamily: string;
-    fontSize: number;
-    offsetX?: number;
-    offsetY?: number;
-    charSpacing?: number;
-    lineHeight?: number;
-    fontWeight?: string;
-    fontStyle?: string;
+interface SetSoundEffectsOrder extends AudioOrder {
+    type: AudioOrderType.SetSoundEffects;
+    /** Target instance ID */
+    instanceId: number;
+    /** Flags bitfield */
+    flags: number;
+    /** Low-pass filter cutoff (0-255, * 100 = Hz). Present if HasLowpass flag set */
+    lowpass?: number;
+    /** High-pass filter cutoff (0-255, * 100 = Hz). Present if HasHighpass flag set */
+    highpass?: number;
+    /** Reverb wet mix (0-255, / 255 = 0.0-1.0). Present if HasReverb flag set */
+    reverb?: number;
 }
 /**
- * Sound Load (LoadType 0x05)
- * MIDI sound data for audio playback
+ * Union of all audio order types
  */
-interface SoundLoad {
-    loadType: LoadType.Sound;
-    sounds: Array<{
-        soundId: number;
-        midiData: Uint8Array;
-    }>;
-}
+type AnyAudioOrder = PlaySoundOrder | PlayGlobalSoundOrder | StopSoundOrder | FadeOutSoundOrder | PauseSoundOrder | ResumeSoundOrder | SetListenerPositionOrder | ConfigureSpatialOrder | SetSoundEffectsOrder;
+
 /**
- * Union type for all load types
+ * Network representation of a display
+ * Layers are NO LONGER under displays - they are at User level
  */
-type AnyLoad = ColorPaletteLoad | SpriteLoad | MulticolorSpriteLoad | BitmapFontLoad | SoundLoad | WebFontLoad;
+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;
+}
+
+interface NetworkLayer {
+    id: number;
+    updateFlags: number;
+    zIndex: number;
+    originX: number;
+    originY: number;
+    width: number;
+    height: number;
+    orderCount: number;
+    orders: AnyNetworkOrder[];
+}
 
 /**
- * Central registry to manage unicolor and multicolor sprites
+ * Update packet according to the new UTSP protocol
  *
- * Sprites are loaded via LoadPacket and referenced by their ID
- * in Orders (SpriteOrder, SpriteMultiColorOrder, etc.)
+ * Structure:
+ * - Tick (8 bytes): Frame counter for synchronization
+ * - Displays: Viewport definitions
+ * - Layers: Render orders for visual output
+ * - Audio Orders: Audio commands synchronized with the frame
+ * - Macro Orders: Macro instance commands (create, update, remove)
  *
- * Architecture:
- * - Two separate registries for unicolor and multicolor
- * - No possible collision between the two types
- * - Memory optimization with CharCodeBuffer for unicolor
+ * Audio orders are in the same packet as render orders to ensure
+ * perfect frame-level synchronization between visuals and sound.
  */
-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;
+interface UpdatePacket {
+    /** Tick counter (8 bytes) */
+    tick: number;
+    /** Number of displays (1 byte) */
+    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[];
+    /** Number of audio orders (1 byte) */
+    audioOrderCount: number;
+    /** List of audio orders (synchronized with this frame) */
+    audioOrders: AnyAudioOrder[];
+    /** Number of macro orders (1 byte) */
+    macroOrderCount: number;
+    /** List of macro orders (create, update, remove instances) */
+    macroOrders: AnyMacroOrder[];
+}
+
+/**
+ * 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);
     /**
-     * Checks if a unicolor sprite exists
+     * Gets the display ID (0-255)
      */
-    hasUnicolorSprite(id: number): boolean;
+    getId(): number;
     /**
-     * Checks if a multicolor sprite exists
+     * Gets the origin position in the world
      */
-    hasMulticolorSprite(id: number): boolean;
+    getOrigin(): Vector2;
     /**
-     * Removes a unicolor sprite
+     * Sets the origin position in the world
      */
-    unloadUnicolorSprite(id: number): boolean;
+    setOrigin(origin: Vector2): void;
     /**
-     * Removes a multicolor sprite
+     * Moves the origin in the world
      */
-    unloadMulticolorSprite(id: number): boolean;
+    moveOrigin(deltaX: number, deltaY: number): void;
     /**
-     * Clears all unicolor sprites
+     * Checks if display origin has changed since last tick
+     * @internal - Used to calculate if update should be sent
      */
-    clearUnicolorSprites(): void;
+    hasOriginChanged(): boolean;
     /**
-     * Clears all multicolor sprites
+     * Checks if display size has changed since last tick
+     * @internal - Used to calculate if update should be sent
      */
-    clearMulticolorSprites(): void;
+    hasSizeChanged(): boolean;
     /**
-     * Clears all sprites (unicolor and multicolor)
+     * Checks if display has changed (origin OR size)
+     * @internal
      */
-    clearAll(): void;
+    hasChanged(): boolean;
     /**
-     * Number of loaded unicolor sprites
+     * Resets change tracking
+     * @internal - Called by Core.endTick() after sending updates
      */
-    getUnicolorSpriteCount(): number;
+    resetChangeTracking(): void;
     /**
-     * Number of loaded multicolor sprites
+     * Gets the display size
      */
-    getMulticolorSpriteCount(): number;
+    getSize(): Vector2;
     /**
-     * Total number of loaded sprites
+     * Sets the display size
      */
-    getTotalSpriteCount(): number;
+    setSize(size: Vector2): void;
 }
 
 declare class Layer {
@@ -1384,6 +2181,12 @@ declare class Layer {
      * Automatically rasterizes new orders in ADD mode
      */
     addOrders(orders: AnyNetworkOrder[]): void;
+    /**
+     * Adds temporary orders that are rasterized but not stored
+     * Used for macro-generated content (particles, UI) that is regenerated each frame
+     * Uses SET mode to clear previous content before drawing
+     */
+    addTemporaryOrders(orders: AnyNetworkOrder[]): void;
     /**
      * Replaces all orders in the layer (reset mode)
      * Automatically rasterizes all orders in SET mode
@@ -1509,6 +2312,169 @@ declare class Layer {
     resetCommit(): void;
 }
 
+/**
+ * MacroRegistry - Registry for macro templates and instances
+ *
+ * Manages:
+ * - Macro templates (loaded via loadMacro)
+ * - Macro instances (created via createInstance)
+ * - Name → ID mappings for network transmission
+ *
+ * Used on both server (for encoding) and client (for decoding and execution).
+ */
+
+/**
+ * Internal representation of a registered macro template
+ */
+interface MacroEntry {
+    /** Unique macro identifier (0-255) */
+    macroId: number;
+    /** Human-readable name (from template.id) */
+    name: string;
+    /** Full template definition */
+    template: MacroTemplate;
+}
+/**
+ * Internal representation of an active macro instance
+ */
+interface MacroInstanceEntry {
+    /** Unique instance identifier (0-255) */
+    instanceId: number;
+    /** Human-readable name */
+    name: string;
+    /** Reference to macro template ID */
+    macroId: number;
+    /** Reference to layer ID */
+    layerId: number;
+    /** Position X (cells) */
+    x: number;
+    /** Position Y (cells) */
+    y: number;
+    /** Tab index for keyboard navigation */
+    tabIndex: number;
+    /** Current parameters */
+    params: Record<string, unknown>;
+}
+/**
+ * Configuration for creating a macro instance
+ */
+interface CreateInstanceConfig {
+    /** Instance name (will be mapped to numeric ID) */
+    id: string;
+    /** Macro template name (must be loaded first) */
+    macro: string;
+    /** Layer name (must exist) */
+    layer: string;
+    /** Position X (cells) */
+    x: number;
+    /** Position Y (cells) */
+    y: number;
+    /** Tab index for keyboard navigation (0 = not focusable) */
+    tabIndex?: number;
+    /** Instance parameters */
+    params?: Record<string, unknown>;
+}
+/**
+ * MacroRegistry - Manages macro templates and instances
+ */
+declare class MacroRegistry {
+    private macros;
+    private macroNameToId;
+    private nextMacroId;
+    private instances;
+    private instanceNameToId;
+    private nextInstanceId;
+    private layerNameToId;
+    private pendingOrders;
+    /**
+     * Register a macro template
+     *
+     * @param template - The macro template definition
+     * @returns The assigned macro ID
+     */
+    registerMacro(template: MacroTemplate): number;
+    /**
+     * Get macro template by name
+     */
+    getMacroByName(name: string): MacroEntry | undefined;
+    /**
+     * Get macro template by ID
+     */
+    getMacroById(macroId: number): MacroEntry | undefined;
+    /**
+     * Get macro ID by name
+     */
+    getMacroId(name: string): number | undefined;
+    /**
+     * Generate MacroLoad packet for a template
+     */
+    toMacroLoad(macroId: number): MacroLoad | undefined;
+    /**
+     * Generate all MacroLoad packets
+     */
+    toAllMacroLoads(): MacroLoad[];
+    /**
+     * Set layer name → ID mapping (called by User when layers change)
+     */
+    setLayerMapping(layerName: string, layerId: number): void;
+    /**
+     * Create a new macro instance
+     * Generates a CreateInstanceOrder for the next update packet
+     *
+     * @param config - Instance configuration
+     * @returns The assigned instance ID, or undefined if macro/layer not found
+     */
+    createInstance(config: CreateInstanceConfig): number | undefined;
+    /**
+     * Update an existing instance's parameters
+     *
+     * @param name - Instance name
+     * @param params - Parameters to update (merged with existing)
+     * @returns true if instance was found and updated
+     */
+    updateInstance(name: string, params: Record<string, unknown>): boolean;
+    /**
+     * Remove an instance
+     *
+     * @param name - Instance name
+     * @returns true if instance was found and removed
+     */
+    removeInstance(name: string): boolean;
+    /**
+     * Get instance by name
+     */
+    getInstanceByName(name: string): MacroInstanceEntry | undefined;
+    /**
+     * Get instance by ID
+     */
+    getInstanceById(instanceId: number): MacroInstanceEntry | undefined;
+    /**
+     * Get instance name by ID (for event handling)
+     */
+    getInstanceName(instanceId: number): string | undefined;
+    /**
+     * Get pending orders and clear the queue
+     * Called by UpdatePacketEncoder to include macro orders
+     */
+    flushPendingOrders(): AnyMacroOrder[];
+    /**
+     * Check if there are pending orders
+     */
+    hasPendingOrders(): boolean;
+    /**
+     * Get all active instances
+     */
+    getAllInstances(): MacroInstanceEntry[];
+    /**
+     * Clear all instances (but keep templates)
+     */
+    clearInstances(): void;
+    /**
+     * Clear everything (templates and instances)
+     */
+    clear(): void;
+}
+
 /**
  * InputBindingRegistry - Input bindings registry
  *
@@ -1945,6 +2911,9 @@ declare class User<TData = Record<string, any>> {
     private loadedSounds;
     private soundLoadErrors;
     private playingSounds;
+    private macroRegistry;
+    private macroEngine;
+    private macroEventHandlers;
     /**
      * Application-specific data storage
      * Use this to store game state, player data, or any custom information
@@ -1975,13 +2944,21 @@ declare class User<TData = Record<string, any>> {
      */
     clearDisplays(): void;
     getLayers(): Layer[];
+    /**
+     * Gets a layer by its ID
+     *
+     * @param layerId - The layer ID to find
+     * @returns The layer, or undefined if not found
+     */
+    getLayerById(layerId: number): Layer | undefined;
     /**
      * Adds a layer to the user
      * Layers are shared across all displays
      *
      * @param layer - The layer to add
+     * @param name - Optional name for macro system (used in createInstance)
      */
-    addLayer(layer: Layer): void;
+    addLayer(layer: Layer, name?: string): void;
     /**
      * Removes a layer from the user
      *
@@ -3007,6 +3984,205 @@ declare class User<TData = Record<string, any>> {
      * Get the number of sounds currently playing on the client
      */
     getPlayingSoundCount(): number;
+    /**
+     * Load a macro template
+     * The template will be sent to the client in the next config packet
+     *
+     * @param name - Template name (used for createInstance)
+     * @param template - Macro template definition
+     * @returns The assigned macro ID
+     *
+     * @example
+     * ```typescript
+     * user.loadMacro('button', {
+     *   id: 'button',
+     *   type: 'ui',
+     *   params: { text: 'string', width: 'number' },
+     *   base: [{ fillRect: [0, 0, '$width', 3, ' ', '$fg', '$bg'] }],
+     *   states: { normal: { fg: '#FFFFFF', bg: '#333333' } }
+     * });
+     * ```
+     */
+    loadMacro(name: string, template: MacroTemplate): number;
+    /**
+     * Create a macro instance
+     * The instance will be created on the client in the next update packet
+     *
+     * @param config - Instance configuration
+     * @returns The assigned instance ID, or undefined if macro/layer not found
+     *
+     * @example
+     * ```typescript
+     * user.createInstance({
+     *   id: 'btn-play',
+     *   macro: 'button',
+     *   layer: 'ui',
+     *   x: 10, y: 5,
+     *   tabIndex: 1,
+     *   params: { text: 'Play', width: 8 }
+     * });
+     * ```
+     */
+    createInstance(config: CreateInstanceConfig): number | undefined;
+    /**
+     * Update a macro instance's parameters
+     *
+     * @param name - Instance name
+     * @param params - Parameters to update (merged with existing)
+     * @returns true if instance was found and updated
+     *
+     * @example
+     * ```typescript
+     * user.updateInstance('weather', { intensity: 20 });
+     * ```
+     */
+    updateInstance(name: string, params: Record<string, unknown>): boolean;
+    /**
+     * Remove a macro instance
+     *
+     * @param name - Instance name
+     * @returns true if instance was found and removed
+     *
+     * @example
+     * ```typescript
+     * user.removeInstance('btn-play');
+     * ```
+     */
+    removeInstance(name: string): boolean;
+    /**
+     * Register a handler for macro events
+     *
+     * @param instanceName - Instance name to listen to
+     * @param eventType - Event type ('click', 'change', 'submit', 'select')
+     * @param handler - Handler function
+     *
+     * @example
+     * ```typescript
+     * user.onMacroEvent('btn-play', 'click', () => {
+     *   console.log('Play button clicked!');
+     * });
+     *
+     * user.onMacroEvent('slider-volume', 'change', (value: number) => {
+     *   console.log('Volume changed to:', value);
+     * });
+     * ```
+     */
+    onMacroEvent(instanceName: string, eventType: string, handler: (data?: unknown) => void): void;
+    /**
+     * Remove a macro event handler
+     *
+     * @param instanceName - Instance name
+     * @param eventType - Event type to remove (optional, removes all if not specified)
+     */
+    offMacroEvent(instanceName: string, eventType?: string): void;
+    /**
+     * Handle a macro event received from the client
+     * @internal - Called by the server runtime
+     */
+    handleMacroEvent(event: AnyMacroEvent): void;
+    /**
+     * Get pending macro orders for the next update packet
+     * @internal - Called by UpdatePacketEncoder
+     */
+    flushMacroOrders(): AnyMacroOrder[];
+    /**
+     * Check if there are pending macro orders
+     * @internal
+     */
+    hasPendingMacroOrders(): boolean;
+    /**
+     * Apply macro orders directly (for standalone/local mode)
+     *
+     * This is the local equivalent of receiving macro orders via network.
+     * In local mode, macro orders don't go through encode/decode - they're
+     * applied directly to the MacroEngine.
+     *
+     * @param orders - Array of macro orders to apply
+     * @internal
+     */
+    applyMacroOrders(orders: AnyMacroOrder[]): void;
+    /**
+     * Get the macro registry (for advanced usage)
+     * @internal
+     */
+    getMacroRegistry(): MacroRegistry;
+    /**
+     * Get all MacroLoad packets for this user's registered macros
+     * @internal - Called by Core.generateAllLoadPackets()
+     */
+    getMacroLoads(): MacroLoad[];
+    /**
+     * Update layer name → ID mappings in the macro registry
+     * @internal
+     */
+    private updateLayerMappings;
+    /**
+     * Register a layer with a name for macro system
+     * This maps a layer name to its ID for createInstance()
+     *
+     * @param name - Layer name (used in createInstance)
+     * @param layer - The layer object
+     */
+    registerLayerName(name: string, layer: Layer): void;
+    /**
+     * Load a macro template into the client-side MacroEngine
+     * Called when receiving a LoadType.Macro packet
+     *
+     * @param macroId - The numeric ID of the macro
+     * @param template - The macro template
+     * @internal
+     */
+    loadMacroTemplate(macroId: number, template: MacroTemplate): void;
+    /**
+     * Update the client-side macro engine
+     * Should be called once per tick (tick-based updates)
+     *
+     * @returns Update result with events and sounds to play
+     */
+    updateMacros(): MacroUpdateResult;
+    /**
+     * Update mouse state for the macro engine
+     * Converts display-local coordinates to world coordinates using the display's origin
+     *
+     * @param displayX - Mouse X position in display cells (local to display)
+     * @param displayY - Mouse Y position in display cells (local to display)
+     * @param isDown - Whether the mouse button is pressed
+     */
+    updateMacroMouse(displayX: number, displayY: number, isDown: boolean): void;
+    /**
+     * Get render orders generated by the macro engine, grouped by layer
+     * Orders are converted from world coordinates to display coordinates
+     * by subtracting the display's origin.
+     *
+     * @returns Map of layerId → render orders (in display coordinates)
+     */
+    getMacroRenderOrders(): Map<number, AnyNetworkOrder[]>;
+    /**
+     * Get the effect offset (for screen shake, etc.)
+     *
+     * @returns Current offset from effect macros
+     */
+    getMacroEffectOffset(): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Get the macro engine (for advanced usage)
+     * @internal
+     */
+    getMacroEngine(): MacroEngine;
+    /**
+     * Move focus to next focusable macro element
+     */
+    macroFocusNext(): void;
+    /**
+     * Move focus to previous focusable macro element
+     */
+    macroFocusPrevious(): void;
+    /**
+     * Activate the currently focused macro element
+     */
+    macroActivateFocused(): void;
 }
 
 /**
@@ -4183,6 +5359,13 @@ declare class Core {
      * ```
      */
     generateAllLoadPackets(): Uint8Array[];
+    /**
+     * Generates MacroLoad packets for a specific user's registered macros
+     *
+     * @param userId - Target user ID
+     * @returns Array of encoded MacroLoad packets
+     */
+    generateMacroLoadPackets(userId: string): Uint8Array[];
     /**
      * Applies Input Bindings to a user (CLIENT-SIDE)
      *
@@ -4985,20 +6168,22 @@ declare function getASCII8x8FontConfig(): {
  * - 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   │ Axes      │ Buttons     │ Mouse  │ Flags    │ MacroEvents │
+ * │ 8 bytes│ N bytes   │ M bytes     │ 3 bytes│ 1 byte   │ variable    │
+ * └────────┴───────────┴─────────────┴────────┴──────────┴─────────────┘
  *
  * 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
+ * MacroEvents (var)    : 1 byte count + encoded events (see MacroEventEncoder)
  *
  * Note: axisCount and buttonCount are known in advance via InputBindingRegistry
- * Example: 5 axes + 12 buttons = 8 + 5 + 2 + 3 + 1 = 19 bytes
+ * Example: 5 axes + 12 buttons = 8 + 5 + 2 + 3 + 1 = 19 bytes (+ macro events)
  */
+
 /**
  * Represents a compressed input on the server side (after decoding)
  *
@@ -5007,6 +6192,7 @@ declare function getASCII8x8FontConfig(): {
  * - Buttons: boolean
  * - Mouse: position + display + flags
  * - TextInputs: array of key strings for text input (e.g., ['a', 'Backspace', 'Enter'])
+ * - MacroEvents: array of macro events (clicks, changes, submits, selects)
  */
 interface CompressedInputPacket {
     /** Frame number (tick) - uint64 */
@@ -5025,6 +6211,8 @@ interface CompressedInputPacket {
     mouseOverDisplay: boolean;
     /** Text input events (e.g., ['a', 'Backspace', 'Enter']) - for input boxes, chat, etc. */
     textInputs: string[];
+    /** Macro events (clicks, changes, submits, selects) from client-side macros */
+    macroEvents: AnyMacroEvent[];
 }
 /**
  * Creates an empty CompressedInputPacket
@@ -5112,11 +6300,14 @@ declare function getCompressedPacketSize(axisCount: number, buttonCount: number)
  * - Buttons: boolean → bitpacking = 8 buttons per byte
  * - DisplayId: uint8 (1 byte) = display ID
  * - Mouse: mouseX/Y (uint8) + flags = 3 bytes
+ * - TextInputs: 1 byte count + length-prefixed strings
+ * - MacroEvents: 1 byte count + encoded events
  *
  * PREREQUISITE: Client and server must have the SAME bindings defined!
  *
- * Example: 5 axes + 12 buttons + mouse = 19 bytes total
+ * Example: 5 axes + 12 buttons + mouse = 19 bytes total (+ text inputs + macro events)
  */
+
 /**
  * Encodes inputs in compact binary format v3 (CLIENT-SIDE)
  *
@@ -5127,6 +6318,8 @@ declare function getCompressedPacketSize(axisCount: number, buttonCount: number)
  * @param mouseX - Mouse X position (0-255)
  * @param mouseY - Mouse Y position (0-255)
  * @param mouseOverDisplay - Is the mouse over a display?
+ * @param textInputs - Array of text input strings
+ * @param macroEvents - Array of macro events (clicks, changes, submits, selects)
  * @returns Encoded buffer (without counts, minimalist format)
  *
  * @example
@@ -5134,10 +6327,10 @@ declare function getCompressedPacketSize(axisCount: number, buttonCount: number)
  * 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
+ * // buffer.length = 8 + 2 + 1 + 4 = 15 bytes (+ text inputs + macro events)
  * ```
  */
-declare function encodeCompressedInput(tick: bigint, axes: Map<number, number>, buttons: Map<number, boolean>, displayId: number, mouseX: number, mouseY: number, mouseOverDisplay: boolean, textInputs?: string[]): Uint8Array;
+declare function encodeCompressedInput(tick: bigint, axes: Map<number, number>, buttons: Map<number, boolean>, displayId: number, mouseX: number, mouseY: number, mouseOverDisplay: boolean, textInputs?: string[], macroEvents?: AnyMacroEvent[]): Uint8Array;
 
 /**
  * CompressedInputDecoder - Decodes inputs from compact binary format
@@ -5158,9 +6351,11 @@ declare function encodeCompressedInput(tick: bigint, axes: Map<number, number>,
  * - Buttons: bitpacking → boolean (8 buttons per byte)
  * - DisplayId: uint8 (1 byte) = display ID
  * - Mouse: uint8 → mouseX/Y + flags (mouseOverDisplay)
+ * - TextInputs: 1 byte count + length-prefixed strings
+ * - MacroEvents: 1 byte count + encoded events
  *
  * Example (2 axes, 3 buttons):
- * - Tick (8) + Axes (2) + Buttons (1) + DisplayId (1) + Mouse (3) = 15 bytes
+ * - Tick (8) + Axes (2) + Buttons (1) + DisplayId (1) + Mouse (3) = 15 bytes (+ text inputs + macro events)
  */
 
 /**
@@ -5520,6 +6715,75 @@ declare class OrderBuilder {
      * @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;
+    /**
+     * 0x19 - Polyline: Connected line segments through multiple points
+     * Uses Bresenham algorithm to draw lines between consecutive points
+     *
+     * @param points - Array of points to connect (minimum 2 for a line)
+     * @param char - Character as string ('*') or charCode (0x2A)
+     * @param fgColor - Foreground color (default: 15 = white)
+     * @param bgColor - Background color (default: 0 = black)
+     *
+     * @example Simple line
+     * ```typescript
+     * OrderBuilder.polyline(
+     *   [{ x: 0, y: 0 }, { x: 10, y: 5 }],
+     *   '*', 14, 0
+     * )
+     * ```
+     *
+     * @example Path with multiple points
+     * ```typescript
+     * OrderBuilder.polyline(
+     *   [
+     *     { x: 10, y: 10 },
+     *     { x: 20, y: 15 },
+     *     { x: 30, y: 10 },
+     *     { x: 40, y: 20 }
+     *   ],
+     *   '#', 11, 0
+     * )
+     * ```
+     */
+    static polyline(points: Array<{
+        x: number;
+        y: number;
+    }>, char?: string | number, fgColor?: number, bgColor?: number): PolylineOrder;
+    /**
+     * Helper: Create a polyline from flat coordinate array
+     * @param coords - Flat array of coordinates [x1, y1, x2, y2, ...]
+     * @param char - Character as string ('*') or charCode
+     *
+     * @example
+     * ```typescript
+     * OrderBuilder.polylineFromCoords(
+     *   [0, 0, 10, 5, 20, 0],  // 3 points
+     *   '-', 14
+     * )
+     * ```
+     */
+    static polylineFromCoords(coords: number[], char?: string | number, fgColor?: number, bgColor?: number): PolylineOrder;
+    /**
+     * Helper: Create a closed polygon (polyline that returns to start)
+     * @param points - Array of points forming the polygon
+     * @param char - Character as string ('*') or charCode
+     *
+     * @example Triangle
+     * ```typescript
+     * OrderBuilder.polygon(
+     *   [
+     *     { x: 20, y: 5 },
+     *     { x: 10, y: 15 },
+     *     { x: 30, y: 15 }
+     *   ],
+     *   '#', 12
+     * )
+     * ```
+     */
+    static polygon(points: Array<{
+        x: number;
+        y: number;
+    }>, char?: string | number, fgColor?: number, bgColor?: number): PolylineOrder;
 }
 
 /**
@@ -5569,6 +6833,7 @@ declare const DOTCLOUD_MULTICOLOR_ORDER_MIN_SIZE = 3;
 declare const BITMASK_ORDER_MIN_SIZE = 9;
 declare const BITMASK4_ORDER_MIN_SIZE = 15;
 declare const BITMASK16_ORDER_MIN_SIZE = 51;
+declare const POLYLINE_ORDER_MIN_SIZE = 5;
 declare const SPRITECLOUD_ORDER_MIN_SIZE = 6;
 declare const SPRITECLOUD_MULTICOLOR_ORDER_MIN_SIZE = 4;
 declare const SPRITECLOUD_VARIED_ORDER_MIN_SIZE = 3;
@@ -5688,6 +6953,11 @@ declare enum OrderType {
      * 4 bits per cell: 0 = absence, 1-15 = variant index
      */
     Bitmask16 = 24,
+    /**
+     * 0x19 - Polyline: Renders a line connecting multiple points
+     * Uses Bresenham algorithm to draw between consecutive points
+     */
+    Polyline = 25,
     /**
      * 0x13 - Clear: Fills entire layer with single character and colors
      */
@@ -5893,6 +7163,7 @@ declare class UpdatePacketDecoder {
     private displayDecoder;
     private layerDecoder;
     private audioOrderDecoder;
+    private macroOrderDecoder;
     constructor();
     /**
      * Decodes an UpdatePacket from binary buffer
@@ -5905,8 +7176,10 @@ declare class UpdatePacketDecoder {
      * - Layers: variable (encoded layers)
      * - AudioOrderCount: 1 byte (max 255 audio orders)
      * - AudioOrders: variable (encoded audio orders)
+     * - MacroOrderCount: 1 byte (max 255 macro orders)
+     * - MacroOrders: variable (encoded macro orders)
      *
-     * Minimum packet size: 12 bytes (Tick + DisplayCount + LayerCount + AudioOrderCount)
+     * Minimum packet size: 13 bytes (Tick + DisplayCount + LayerCount + AudioOrderCount + MacroOrderCount)
      */
     decode(data: Uint8Array, offset?: number): UpdatePacket;
     /**
@@ -5915,7 +7188,7 @@ declare class UpdatePacketDecoder {
      */
     isValid(data: Uint8Array, offset?: number): boolean;
     /**
-     * Decodes only the tick and counts without decoding the displays/layers/audio
+     * Decodes only the tick and counts without decoding the displays/layers/audio/macros
      * Useful for quick inspection of packet metadata
      */
     decodeHeader(data: Uint8Array, offset?: number): {
@@ -5923,6 +7196,7 @@ declare class UpdatePacketDecoder {
         displayCount: number;
         layerCount: number;
         audioOrderCount?: number;
+        macroOrderCount?: number;
     };
     private checkSize;
 }
@@ -5985,6 +7259,10 @@ declare class BufferCompat {
     writeBigInt64BE(value: bigint, offset: number): void;
     writeBigUInt64LE(value: bigint, offset: number): void;
     writeBigInt64LE(value: bigint, offset: number): void;
+    readFloatBE(offset: number): number;
+    readFloatLE(offset: number): number;
+    writeFloatBE(value: number, offset: number): void;
+    writeFloatLE(value: number, offset: number): void;
     /**
      * Copies data from this buffer to another
      * @param target Destination buffer
@@ -6164,5 +7442,5 @@ declare class AudioOrderCollector {
     private encodeReverb;
 }
 
-export { ASCII_8X8_FONT, AUDIO_CONFIGURE_SPATIAL_SIZE, AUDIO_FADEOUT_SOUND_MIN_SIZE, AUDIO_PAUSE_SOUND_MIN_SIZE, AUDIO_PLAY_GLOBAL_SOUND_MIN_SIZE, AUDIO_PLAY_SOUND_MIN_SIZE, AUDIO_RESUME_SOUND_MIN_SIZE, AUDIO_SET_LISTENER_POSITION_SIZE, AUDIO_SET_SOUND_EFFECTS_MIN_SIZE, AUDIO_STOP_SOUND_MIN_SIZE, AudioOrderCollector, AudioOrderDecoder, AudioOrderType, AudioTargetType, BITMASK16_ORDER_MIN_SIZE, BITMASK4_ORDER_MIN_SIZE, 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, PlaySoundFlags, 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, SoundEffectsFlags, SoundRegistry, 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, getAudioOrderTypeName, getButtonByteCount, getCharBitmap, getCompressedPacketSize, getOrderTypeName, hasChar, isValidAudioOrderType, isValidOrderType };
-export type { AnyAudioOrder, AnyLoad, AudioOrder, BitmapFontConfig, BitmapFontLoad, Bitmask16Order, Bitmask16Variant, Bitmask4Order, Bitmask4Variant, BitmaskOrder, Cell, CircleShape, Color, ColorPaletteLoad, CompressedInputPacket, ConfigureSpatialOrder, CoreMode, CoreOptions, EllipseShape, FadeOutSoundOrder, LineShape, MulticolorCell, MulticolorSprite, MulticolorSpriteLoad, NetworkDisplay, NetworkLayer, PauseSoundOrder, PlayGlobalSoundOrder, PlaySoundOrder, RectangleShape, ResumeSoundOrder, SetListenerPositionOrder, SetSoundEffectsOrder, ShapeData, SoundEntry, SoundLoad, SpriteLoad, StopSoundOrder, TickStats, TriangleShape, UnicolorSprite, UpdatePacket, UserTickStats, WebFontConfig, WebFontLoad };
+export { ASCII_8X8_FONT, AUDIO_CONFIGURE_SPATIAL_SIZE, AUDIO_FADEOUT_SOUND_MIN_SIZE, AUDIO_PAUSE_SOUND_MIN_SIZE, AUDIO_PLAY_GLOBAL_SOUND_MIN_SIZE, AUDIO_PLAY_SOUND_MIN_SIZE, AUDIO_RESUME_SOUND_MIN_SIZE, AUDIO_SET_LISTENER_POSITION_SIZE, AUDIO_SET_SOUND_EFFECTS_MIN_SIZE, AUDIO_STOP_SOUND_MIN_SIZE, AudioOrderCollector, AudioOrderDecoder, AudioOrderType, AudioTargetType, BITMASK16_ORDER_MIN_SIZE, BITMASK4_ORDER_MIN_SIZE, 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, MacroEngine, MacroEventType, MacroOrderType, MacroRegistry, OrderBuilder, OrderType, POLYLINE_ORDER_MIN_SIZE, PlaySoundFlags, 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, SoundEffectsFlags, SoundRegistry, 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, getAudioOrderTypeName, getButtonByteCount, getCharBitmap, getCompressedPacketSize, getMacroEventTypeName, getMacroOrderTypeName, getOrderTypeName, hasChar, isValidAudioOrderType, isValidMacroEventType, isValidMacroOrderType, isValidOrderType };
+export type { AnyAudioOrder, AnyLoad, AnyMacroEvent, AnyMacroOrder, AudioOrder, BitmapFontConfig, BitmapFontLoad, Bitmask16Order, Bitmask16Variant, Bitmask4Order, Bitmask4Variant, BitmaskOrder, ButtonBorderStyle, ButtonConfig, ButtonStateColors, Cell, ChangeEvent, CircleShape, ClickEvent, Color, ColorPaletteLoad, CompressedInputPacket, ConfigureSpatialOrder, CoreMode, CoreOptions, CreateInstanceConfig, CreateInstanceOrder, EffectMacroTemplate, EffectTransform, EllipseShape, FadeOutSoundOrder, LineMacroTemplate, LineShape, MacroEntry, MacroEvent, MacroInstanceEntry, MacroLoad, MacroOrder, MacroTemplate, MacroTemplateBase, MacroType, MacroUpdateResult, MulticolorCell, MulticolorSprite, MulticolorSpriteLoad, NetworkDisplay, NetworkLayer, ParticleConfig, ParticleEmitter, ParticleMacroTemplate, PauseSoundOrder, PlayGlobalSoundOrder, PlaySoundOrder, RectangleShape, RemoveInstanceOrder, RenderCommand, ResumeSoundOrder, RevealCellDef, RevealContent, RevealContentType, RevealCursor, RevealDirection, RevealMacroTemplate, RevealPattern, RevealPause, SelectEvent, SetListenerPositionOrder, SetSoundEffectsOrder, ShapeData, SoundEntry, SoundLoad, SpriteLoad, StopSoundOrder, SubmitEvent, TickStats, TriangleShape, UIMacroTemplate, UIState, UISubtype, UnicolorSprite, UpdateInstanceOrder, UpdatePacket, UserTickStats, WebFontConfig, WebFontLoad };