cubeforge 0.3.16 → 0.4.1

package/dist/index.d.ts

@@ -1,19 +1,19 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React from 'react';
 import React__default, { CSSProperties, ReactNode, ReactElement } from 'react';
-import { Plugin, EntityId, ECSWorld, ScriptUpdateFn, NavGrid, WorldSnapshot, EventBus } from '@cubeforge/core';
-export { AssetProgress, Component, ECSWorld, Ease, EntityId, GameTimer, HotReloadablePlugin, MergedRect, NavGrid, Plugin, PreloadManifest, ScriptUpdateFn, TimelineEntry, TransformComponent, TweenHandle, TweenTimeline, Vec2Like, WorldSnapshot, arrive, createTag, createTimeline, createTimer, createTransform, definePlugin, findByTag, flee, hotReloadPlugin, mergeTileColliders, patrol, preloadManifest, seek, tween, wander } from '@cubeforge/core';
-import { Sampling, BlendMode, AnimatorStateDefinition, AnimatorParamValue, PostProcessEffect } from '@cubeforge/renderer';
-export { AnimationClipDefinition, AnimationStateComponent, AnimatorComponent, AnimatorCondition, AnimatorParamValue, AnimatorStateDefinition, AnimatorTransition, BlendMode, MagFilterValue, NineSliceComponent, ParallaxLayerComponent, Particle, ParticlePoolComponent, PostProcessEffect, PostProcessStack, RenderLayer, RenderLayerManager, RenderSystem, Sampling, SpriteComponent, SquashStretchComponent, TextComponent, TextureFilter, TextureFilterValue, TrailComponent, chromaticAberrationEffect, createNineSlice, createPostProcessStack, createRenderLayerManager, createSprite, defaultLayers, scanlineEffect, vignetteEffect } from '@cubeforge/renderer';
-import { ColliderShape } from '@cubeforge/physics';
-export { BoxColliderComponent, CapsuleColliderComponent, CircleColliderComponent, ColliderShape, CompoundColliderComponent, RaycastHit, RigidBodyComponent, createCompoundCollider, overlapBox, overlapCircle, raycast, raycastAll, sweepBox } from '@cubeforge/physics';
-import { InputManager, ActionBindings, InputContextName, PlayerInput, InputRecorderControls } from '@cubeforge/input';
-export { ActionBindings, AxisBinding, InputContextName, InputManager, InputMap, InputRecorderControls, InputRecording, InputRecording as InputRecordingData, PlayerInput, createInputMap, createInputRecorder, createPlayerInput, globalInputContext } from '@cubeforge/input';
+import { Plugin, EntityId, ECSWorld, ScriptUpdateFn, NavGrid, WorldSnapshot, EventBus, AccessibilityOptions } from '@cubeforge/core';
+export { AccessibilityOptions, AssetProgress, Component, ECSWorld, Ease, EntityId, GameTimer, HierarchyComponent, HierarchySystem, HotReloadablePlugin, MergedRect, NavGrid, Plugin, PreloadManifest, ScriptUpdateFn, SpatialHash, TimelineEntry, TransformComponent, TweenHandle, TweenTimeline, Vec2Like, WorldSnapshot, WorldTransformComponent, announceToScreenReader, arrive, createHierarchy, createTag, createTimeline, createTimer, createTransform, definePlugin, findByTag, flee, getAccessibilityOptions, getDescendants, hmrClearState, hmrLoadState, hmrSaveState, hotReloadPlugin, mergeTileColliders, patrol, preloadManifest, removeParent, seek, setAccessibilityOptions, setParent, tween, wander } from '@cubeforge/core';
+import { Sampling, BlendMode, AnimatorStateDefinition, AnimatorParamValue, GradientType, GradientStop, MaskShape, PostProcessEffect } from '@cubeforge/renderer';
+export { AnimationClipDefinition, AnimationStateComponent, AnimatorComponent, AnimatorCondition, AnimatorParamValue, AnimatorStateDefinition, AnimatorTransition, BlendMode, CircleShapeComponent, GradientComponent, GradientStop, GradientType, LineShapeComponent, MagFilterValue, MaskComponent, MaskShape, NineSliceComponent, ParallaxLayerComponent, Particle, ParticlePoolComponent, PolygonShapeComponent, PostProcessEffect, PostProcessStack, RenderLayer, RenderLayerManager, RenderSystem, Sampling, SpriteComponent, SquashStretchComponent, TextComponent, TextureFilter, TextureFilterValue, TrailComponent, chromaticAberrationEffect, createCircleShape, createGradient, createLineShape, createMask, createNineSlice, createPolygonShape, createPostProcessStack, createRenderLayerManager, createSprite, defaultLayers, scanlineEffect, vignetteEffect } from '@cubeforge/renderer';
+import { CombineRule, ColliderShape, JointType } from '@cubeforge/physics';
+export { AxisLock, BVH, BoxColliderComponent, BroadPhaseAABB, BroadPhasePair, COLLISION_DYNAMIC_DYNAMIC, COLLISION_DYNAMIC_KINEMATIC, COLLISION_DYNAMIC_STATIC, COLLISION_KINEMATIC_KINEMATIC, COLLISION_KINEMATIC_STATIC, CapsuleColliderComponent, CharacterCollision, CharacterController, CharacterControllerConfig, CircleColliderComponent, ColliderShape, CollisionPair, CollisionPipeline, CollisionPipelineResult, CombineRule, CompoundColliderComponent, ContactManifold, ContactPoint, ConvexPolygonColliderComponent, ConvexShape, DEFAULT_ACTIVE_COLLISION_TYPES, DebugCircle, DebugLine, DebugPoint, DebugRenderBackend, DebugRenderColors, DebugRenderFlags, DebugRenderOutput, DebugRenderPipeline, EPAResult, Float64Pool, GJKContactManifold, GJKResult, HalfSpaceColliderComponent, HeightFieldColliderComponent, Island, IslandDetector, JointComponent, JointMotor, JointSnapshot, JointType, KahanSum, MotorMode, MoveResult, MultibodyArticulation, MultibodyLink, PhysicsBodySnapshot, PhysicsHooks, ObjectPool as PhysicsObjectPool, PhysicsSnapshot, PointProjection, QueryOpts, QueryShape, RaycastHit, RigidBodyComponent, SegmentColliderComponent, Spatial3, SpatialInertia3, SweepAndPrune, TOIBody, TOIResult, TriMeshColliderComponent, Triangle2D, TriangleColliderComponent, addForce, addForceAtPoint, addTorque, applyImpulse, applyImpulseAtPoint, applyTorqueImpulse, boxArea, boxShape, buildBVH, capsuleArea, capsuleShape, circleArea, circleShape, computeTOI, containsPoint, createCompoundCollider, createConvexPolygonCollider, createHalfSpaceCollider, createHeightFieldCollider, createJoint, createLink, createMultibody, createSegmentCollider, createTriMeshCollider, createTriangleCollider, dMath, deterministicAtan2, deterministicCos, deterministicSin, deterministicSqrt, epa, generateDeterministicPairs, gjk, gjkEpaQuery, intersectAABB, intersectRay, intersectShape, isDeterministicMode, kineticEnergy, overlapBox, overlapCircle, pairKey, polygonArea, polygonMassProperties, polygonShape, potentialEnergy, predictPosition, projectPoint, queryBVH, queryBVHCircle, raycast, raycastAll, recomputeMassFromColliders, resetAllPools, resetForces, resetTorques, resolveTOI, restoreSnapshot, setAdditionalMass, setDeterministicMode, setMassProperties, setNextKinematicPosition, setNextKinematicRotation, shapeCast, snapshotFromBytes, snapshotFromJSON, snapshotHash, snapshotToBytes, snapshotToJSON, sortEntities, sweepBox, takeSnapshot, triangleArea, triangleMassProperties, velocityAtPoint } from '@cubeforge/physics';
+import { InputManager, ActionBindings, InputContextName, PlayerInput, InputRecorderControls, TouchPoint, InputBufferOptions, InputBuffer, ComboDefinition } from '@cubeforge/input';
+export { ActionBindings, AxisBinding, BufferedAction, ComboDefinition, ComboDetector, ComboDetectorOptions, InputBuffer, InputBufferOptions, InputContextName, InputManager, InputMap, InputRecorderControls, InputRecording, InputRecording as InputRecordingData, PlayerInput, TouchPoint, createInputMap, createInputRecorder, createPlayerInput, globalInputContext } from '@cubeforge/input';
 import { AnimationClip } from '@cubeforge/gameplay';
-export { AISteering, AnimationClip, AnimationControllerResult, BindingControls, CutsceneControls, CutsceneStep, DialogueControls, DialogueLine, DialogueScript, GameState as GameStateDefinition, GameStateMachineResult, HealthControls, HealthOptions, KinematicBodyControls, LevelTransitionControls, ObjectPool, PathfindingControls, PlatformerControllerOptions, RestartControls, SaveControls, SaveOptions, TopDownMovementOptions, TransitionOptions, TransitionType, TweenControls, useAISteering, useAnimationController, useCutscene, useDamageZone, useDialogue, useDropThrough, useGameStateMachine, useGameStore, useHealth, useKinematicBody, useLevelTransition, useObjectPool, usePathfinding, usePersistedBindings, usePlatformerController, useRestart, useSave, useTopDownMovement, useTween } from '@cubeforge/gameplay';
+export { AISteering, AnimationClip, AnimationControllerResult, BindingControls, CharacterControls, CutsceneControls, CutsceneStep, DialogueControls, DialogueLine, DialogueScript, ForceControls, GameState as GameStateDefinition, GameStateMachineResult, HealthControls, HealthOptions, KinematicBodyControls, LevelTransitionControls, ObjectPool, PathfindingControls, PlatformerControllerOptions, RestartControls, SaveControls, SaveOptions, TopDownMovementOptions, TransitionOptions, TransitionType, TweenControls, useAISteering, useAnimationController, useCharacterController, useCutscene, useDamageZone, useDialogue, useDropThrough, useForces, useGameStateMachine, useGameStore, useHealth, useKinematicBody, useLevelTransition, useObjectPool, usePathfinding, usePersistedBindings, usePlatformerController, useRestart, useSave, useTopDownMovement, useTween } from '@cubeforge/gameplay';
 import { EngineState } from '@cubeforge/context';
 export { EngineState, useCircleEnter, useCircleExit, useCircleStay, useCollidingWith, useCollisionEnter, useCollisionExit, useCollisionStay, useTriggerEnter, useTriggerExit, useTriggerStay } from '@cubeforge/context';
-export { AudioGroup, SoundControls, duck, getGroupVolume, setGroupMute, setGroupVolume, setMasterVolume, stopGroup, useSound } from '@cubeforge/audio';
+export { AudioGroup, SoundControls, SpatialSoundControls, SpatialSoundOptions, duck, getGroupVolume, getListenerPosition, setGroupMute, setGroupVolume, setListenerPosition, setMasterVolume, stopGroup, useSound, useSpatialSound } from '@cubeforge/audio';
 export { DevToolsHandle } from '@cubeforge/devtools';
 
 interface GameControls {
@@ -129,8 +129,12 @@ interface SpriteProps {
     blendMode?: BlendMode;
     /** Render layer name — sprites are sorted by layer order first, then zIndex */
     layer?: string;
+    /** Color tint applied on top of the image (multiplied). e.g. '#ff0000' for red tint */
+    tint?: string;
+    /** Tint opacity 0-1 */
+    tintOpacity?: number;
 }
-declare function Sprite({ width, height, color, src, offsetX, offsetY, zIndex, visible, flipX, flipY, anchorX, anchorY, frameIndex, frameWidth, frameHeight, frameColumns, atlas, frame, tileX, tileY, tileSizeX, tileSizeY, sampling, blendMode, layer, }: SpriteProps): null;
+declare function Sprite({ width, height, color, src, offsetX, offsetY, zIndex, visible, flipX, flipY, anchorX, anchorY, frameIndex, frameWidth, frameHeight, frameColumns, atlas, frame, tileX, tileY, tileSizeX, tileSizeY, sampling, blendMode, layer, tint, tintOpacity, }: SpriteProps): null;
 
 interface TextProps {
     text: string;
@@ -144,14 +148,26 @@ interface TextProps {
     maxWidth?: number;
     offsetX?: number;
     offsetY?: number;
+    strokeColor?: string;
+    strokeWidth?: number;
+    shadowColor?: string;
+    shadowOffsetX?: number;
+    shadowOffsetY?: number;
+    shadowBlur?: number;
+    wordWrap?: boolean;
+    lineHeight?: number;
+    opacity?: number;
 }
-declare function Text({ text, fontSize, fontFamily, color, align, baseline, zIndex, visible, maxWidth, offsetX, offsetY, }: TextProps): null;
+declare function Text({ text, fontSize, fontFamily, color, align, baseline, zIndex, visible, maxWidth, offsetX, offsetY, strokeColor, strokeWidth, shadowColor, shadowOffsetX, shadowOffsetY, shadowBlur, wordWrap, lineHeight, opacity, }: TextProps): null;
 
 interface RigidBodyProps {
+    /** Explicit mass. 0 (default) auto-computes from density × collider area */
     mass?: number;
     gravityScale?: number;
     isStatic?: boolean;
+    /** @deprecated Use restitution on BoxCollider/CircleCollider instead */
     bounce?: number;
+    /** @deprecated Use friction on BoxCollider/CircleCollider instead */
     friction?: number;
     vx?: number;
     vy?: number;
@@ -159,6 +175,8 @@ interface RigidBodyProps {
     lockX?: boolean;
     /** Prevent any vertical movement — velocity.y is zeroed every frame (disables gravity) */
     lockY?: boolean;
+    /** Lock rotation — angular velocity stays 0 */
+    lockRotation?: boolean;
     /** Enable continuous collision detection to prevent tunneling through thin colliders */
     ccd?: boolean;
     /** Angular velocity in radians per second */
@@ -167,8 +185,24 @@ interface RigidBodyProps {
     angularDamping?: number;
     /** Linear damping (0–1): velocity reduction applied every fixed step (air resistance) */
     linearDamping?: number;
+    /** Density for auto-computing mass (mass = density × area). Default 1.0 */
+    density?: number;
+    /** Coefficient of restitution for this body (0 = no bounce, 1 = full bounce) */
+    restitution?: number;
+    /** Dominance group (-127 to 127). Higher dominance acts as infinite mass in contacts */
+    dominance?: number;
+    /** Kinematic bodies skip gravity/integration but resolve collisions without impulse response */
+    isKinematic?: boolean;
+    /** Whether this body is enabled. Disabled bodies are completely skipped */
+    enabled?: boolean;
+    /** Max linear velocity magnitude. 0 = unlimited */
+    maxLinearVelocity?: number;
+    /** Max angular velocity magnitude. 0 = unlimited */
+    maxAngularVelocity?: number;
+    /** Extra velocity solver iterations for constraints involving this body. Default 0 */
+    additionalSolverIterations?: number;
 }
-declare function RigidBody({ mass, gravityScale, isStatic, bounce, friction, vx, vy, lockX, lockY, ccd, angularVelocity, angularDamping, linearDamping, }: RigidBodyProps): null;
+declare function RigidBody({ mass, gravityScale, isStatic, bounce, friction, vx, vy, lockX, lockY, lockRotation, ccd, angularVelocity, angularDamping, linearDamping, density, restitution, dominance, isKinematic, enabled, maxLinearVelocity, maxAngularVelocity, additionalSolverIterations, }: RigidBodyProps): null;
 
 interface BoxColliderProps {
     width: number;
@@ -184,8 +218,18 @@ interface BoxColliderProps {
      * Entities below pass through freely (useful for jump-through ledges).
      */
     oneWay?: boolean;
+    /** Per-collider friction coefficient (0–1). Default 0.5 */
+    friction?: number;
+    /** Per-collider restitution (bounciness) coefficient (0–1). Default 0.0 */
+    restitution?: number;
+    /** How to combine friction with the other collider. Default 'average' */
+    frictionCombineRule?: CombineRule;
+    /** How to combine restitution with the other collider. Default 'average' */
+    restitutionCombineRule?: CombineRule;
+    /** Whether this collider is enabled. Disabled colliders skip all detection */
+    enabled?: boolean;
 }
-declare function BoxCollider({ width, height, offsetX, offsetY, isTrigger, layer, mask, oneWay, }: BoxColliderProps): null;
+declare function BoxCollider({ width, height, offsetX, offsetY, isTrigger, layer, mask, oneWay, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: BoxColliderProps): null;
 
 interface CircleColliderProps {
     radius: number;
@@ -195,8 +239,18 @@ interface CircleColliderProps {
     layer?: string;
     /** Which layers this collider interacts with. '*' = all (default). */
     mask?: string | string[];
+    /** Per-collider friction coefficient (0–1). Default 0.5 */
+    friction?: number;
+    /** Per-collider restitution (bounciness) coefficient (0–1). Default 0.0 */
+    restitution?: number;
+    /** How to combine friction with the other collider. Default 'average' */
+    frictionCombineRule?: CombineRule;
+    /** How to combine restitution with the other collider. Default 'average' */
+    restitutionCombineRule?: CombineRule;
+    /** Whether this collider is enabled. Disabled colliders skip all detection */
+    enabled?: boolean;
 }
-declare function CircleCollider({ radius, offsetX, offsetY, isTrigger, layer, mask, }: CircleColliderProps): null;
+declare function CircleCollider({ radius, offsetX, offsetY, isTrigger, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: CircleColliderProps): null;
 
 interface CapsuleColliderProps {
     width: number;
@@ -206,8 +260,13 @@ interface CapsuleColliderProps {
     isTrigger?: boolean;
     layer?: string;
     mask?: string | string[];
+    friction?: number;
+    restitution?: number;
+    frictionCombineRule?: CombineRule;
+    restitutionCombineRule?: CombineRule;
+    enabled?: boolean;
 }
-declare function CapsuleCollider({ width, height, offsetX, offsetY, isTrigger, layer, mask, }: CapsuleColliderProps): null;
+declare function CapsuleCollider({ width, height, offsetX, offsetY, isTrigger, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: CapsuleColliderProps): null;
 
 interface CompoundColliderProps {
     shapes: ColliderShape[];
@@ -216,7 +275,7 @@ interface CompoundColliderProps {
     /** Which layers this collider interacts with. '*' = all (default). */
     mask?: string | string[];
 }
-declare function CompoundCollider({ shapes, isTrigger, layer, mask, }: CompoundColliderProps): null;
+declare function CompoundCollider({ shapes, isTrigger, layer, mask }: CompoundColliderProps): null;
 
 interface ScriptProps {
     /** Called once when the entity is mounted — use to attach extra components */
@@ -426,8 +485,28 @@ interface ParticleEmitterProps {
     emitWidth?: number;
     /** Height for 'box' emission shape */
     emitHeight?: number;
+    /** Sprite/texture source for particles (if undefined, renders as colored rect) */
+    textureSrc?: string;
+    /** Enable particle rotation. Default false */
+    enableRotation?: boolean;
+    /** Random rotation speed range [min, max] in radians/s */
+    rotationSpeedRange?: [number, number];
+    /** Size over lifetime: start and end size. If set, overrides particleSize */
+    sizeOverLife?: {
+        start: number;
+        end: number;
+    };
+    /** Attractor points that pull particles toward them */
+    attractors?: Array<{
+        x: number;
+        y: number;
+        strength: number;
+        radius: number;
+    }>;
+    /** Color over lifetime: array of colors to interpolate through */
+    colorOverLife?: string[];
 }
-declare function ParticleEmitter({ active, preset, rate, speed, spread, angle, particleLife, particleSize, color, gravity, maxParticles, burstCount, emitShape, emitRadius, emitWidth, emitHeight, }: ParticleEmitterProps): null;
+declare function ParticleEmitter({ active, preset, rate, speed, spread, angle, particleLife, particleSize, color, gravity, maxParticles, burstCount, emitShape, emitRadius, emitWidth, emitHeight, textureSrc, enableRotation, rotationSpeedRange, sizeOverLife, attractors, colorOverLife, }: ParticleEmitterProps): null;
 
 interface VirtualJoystickProps {
     /** Diameter of the joystick base in pixels (default 120) */
@@ -643,7 +722,7 @@ interface CameraZoneProps {
  * <CameraZone x={500} y={300} width={200} height={150} watchTag="player" />
  * ```
  */
-declare function CameraZone({ x, y, width, height, watchTag, targetX, targetY, children, }: CameraZoneProps): react_jsx_runtime.JSX.Element;
+declare function CameraZone({ x, y, width, height, watchTag, targetX, targetY, children }: CameraZoneProps): react_jsx_runtime.JSX.Element;
 
 interface TrailProps {
     /** Maximum number of trail points (default 20) */
@@ -740,6 +819,204 @@ interface AssetLoaderProps {
  */
 declare function AssetLoader({ assets, fallback, onError, children }: AssetLoaderProps): react_jsx_runtime.JSX.Element;
 
+interface CircleProps {
+    radius?: number;
+    color?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    zIndex?: number;
+    opacity?: number;
+}
+declare function Circle({ radius, color, strokeColor, strokeWidth, zIndex, opacity, }: CircleProps): null;
+
+interface LineProps {
+    endX: number;
+    endY: number;
+    color?: string;
+    lineWidth?: number;
+    zIndex?: number;
+    opacity?: number;
+    lineCap?: CanvasLineCap;
+}
+declare function Line({ endX, endY, color, lineWidth, zIndex, opacity, lineCap, }: LineProps): null;
+
+interface PolygonProps {
+    points: {
+        x: number;
+        y: number;
+    }[];
+    color?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    zIndex?: number;
+    opacity?: number;
+    closed?: boolean;
+}
+declare function Polygon({ points, color, strokeColor, strokeWidth, zIndex, opacity, closed, }: PolygonProps): null;
+
+interface GradientProps {
+    gradientType?: GradientType;
+    stops: GradientStop[];
+    /** For linear: angle in radians (0 = left to right) */
+    angle?: number;
+    /** For radial: inner radius ratio (0-1) */
+    innerRadius?: number;
+    width: number;
+    height: number;
+    zIndex?: number;
+    visible?: boolean;
+    anchorX?: number;
+    anchorY?: number;
+}
+declare function Gradient({ gradientType, stops, angle, innerRadius, width, height, zIndex, visible, anchorX, anchorY, }: GradientProps): null;
+
+interface MaskProps {
+    shape?: MaskShape;
+    width?: number;
+    height?: number;
+    radius?: number;
+    inverted?: boolean;
+}
+/**
+ * Clips the parent entity's sprite to a shape.
+ *
+ * @example
+ * <Entity>
+ *   <Transform x={100} y={100} />
+ *   <Sprite src="/health-bar-bg.png" width={200} height={20} />
+ *   <Mask shape="rect" width={120} height={20} />
+ * </Entity>
+ */
+declare function Mask({ shape, width, height, radius, inverted }: MaskProps): null;
+
+interface JointProps {
+    type: JointType;
+    /** Entity ID of the connected entity */
+    target: string;
+    anchorA?: {
+        x: number;
+        y: number;
+    };
+    anchorB?: {
+        x: number;
+        y: number;
+    };
+    length?: number;
+    stiffness?: number;
+    damping?: number;
+    maxLength?: number;
+}
+declare function Joint({ type, target, anchorA, anchorB, length, stiffness, damping, maxLength }: JointProps): null;
+
+interface ConvexColliderProps {
+    /** Vertices in CCW order (max 8 for performance). Positions relative to entity center. */
+    vertices: {
+        x: number;
+        y: number;
+    }[];
+    offsetX?: number;
+    offsetY?: number;
+    isTrigger?: boolean;
+    layer?: string;
+    mask?: string | string[];
+    friction?: number;
+    restitution?: number;
+    frictionCombineRule?: CombineRule;
+    restitutionCombineRule?: CombineRule;
+    enabled?: boolean;
+}
+declare function ConvexCollider({ vertices, offsetX, offsetY, isTrigger, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: ConvexColliderProps): null;
+
+interface TriangleColliderProps {
+    a: {
+        x: number;
+        y: number;
+    };
+    b: {
+        x: number;
+        y: number;
+    };
+    c: {
+        x: number;
+        y: number;
+    };
+    offsetX?: number;
+    offsetY?: number;
+    isTrigger?: boolean;
+    layer?: string;
+    mask?: string | string[];
+    friction?: number;
+    restitution?: number;
+    frictionCombineRule?: CombineRule;
+    restitutionCombineRule?: CombineRule;
+    enabled?: boolean;
+}
+declare function TriangleCollider({ a, b, c, offsetX, offsetY, isTrigger, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: TriangleColliderProps): null;
+
+interface SegmentColliderProps {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    isTrigger?: boolean;
+    layer?: string;
+    mask?: string | string[];
+    oneWay?: boolean;
+    friction?: number;
+    restitution?: number;
+    frictionCombineRule?: CombineRule;
+    restitutionCombineRule?: CombineRule;
+    enabled?: boolean;
+}
+declare function SegmentCollider({ start, end, isTrigger, layer, mask, oneWay, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: SegmentColliderProps): null;
+
+interface HeightFieldColliderProps {
+    heights: number[];
+    scaleX?: number;
+    scaleY?: number;
+    layer?: string;
+    mask?: string | string[];
+    friction?: number;
+    restitution?: number;
+    frictionCombineRule?: CombineRule;
+    restitutionCombineRule?: CombineRule;
+    enabled?: boolean;
+}
+declare function HeightFieldCollider({ heights, scaleX, scaleY, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: HeightFieldColliderProps): null;
+
+interface HalfSpaceColliderProps {
+    normalX?: number;
+    normalY?: number;
+    layer?: string;
+    mask?: string | string[];
+    friction?: number;
+    restitution?: number;
+    frictionCombineRule?: CombineRule;
+    restitutionCombineRule?: CombineRule;
+    enabled?: boolean;
+}
+declare function HalfSpaceCollider({ normalX, normalY, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: HalfSpaceColliderProps): null;
+
+interface TriMeshColliderProps {
+    vertices: {
+        x: number;
+        y: number;
+    }[];
+    indices: number[];
+    layer?: string;
+    mask?: string | string[];
+    friction?: number;
+    restitution?: number;
+    frictionCombineRule?: CombineRule;
+    restitutionCombineRule?: CombineRule;
+    enabled?: boolean;
+}
+declare function TriMeshCollider({ vertices, indices, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: TriMeshColliderProps): null;
+
 declare function useGame(): EngineState;
 
 interface CameraControls {
@@ -1130,6 +1407,258 @@ declare function useProfiler(): ProfilerData;
  */
 declare function usePostProcess(effect: PostProcessEffect): void;
 
+interface TouchControls {
+    /** All currently active touches */
+    touches: TouchPoint[];
+    /** Touches that started this frame */
+    justStarted: TouchPoint[];
+    /** Touches that ended this frame */
+    justEnded: TouchPoint[];
+    /** Number of active touches */
+    count: number;
+    /** Whether any touch is active */
+    isTouching: boolean;
+}
+declare function useTouch(): TouchControls;
+
+interface TimerControls {
+    /** Start/restart the timer */
+    start(): void;
+    /** Stop the timer */
+    stop(): void;
+    /** Reset timer to initial duration */
+    reset(): void;
+    /** Whether the timer is currently running */
+    readonly isRunning: boolean;
+    /** Remaining time in seconds */
+    readonly remaining: number;
+    /** Elapsed time since start in seconds */
+    readonly elapsed: number;
+    /** Progress 0-1 (0 = just started, 1 = finished) */
+    readonly progress: number;
+}
+/**
+ * Game-loop aware timer that integrates with the engine's update cycle.
+ *
+ * @param duration - Timer duration in seconds
+ * @param onComplete - Called when timer reaches 0
+ * @param opts - { autoStart?: boolean, loop?: boolean }
+ *
+ * @example
+ * const timer = useTimer(3, () => console.log('Done!'))
+ * timer.start()
+ */
+declare function useTimer(duration: number, onComplete?: () => void, opts?: {
+    autoStart?: boolean;
+    loop?: boolean;
+}): TimerControls;
+
+type CoroutineGenerator = Generator<CoroutineYield, void, number>;
+type CoroutineFactory = () => CoroutineGenerator;
+/** What a coroutine can yield */
+type CoroutineYield = {
+    type: 'wait';
+    seconds: number;
+} | {
+    type: 'waitFrames';
+    frames: number;
+} | {
+    type: 'waitUntil';
+    condition: () => boolean;
+} | null;
+/** Convenience helpers for yielding */
+declare const wait: (seconds: number) => CoroutineYield;
+declare const waitFrames: (frames: number) => CoroutineYield;
+declare const waitUntil: (condition: () => boolean) => CoroutineYield;
+interface CoroutineControls {
+    /** Start a coroutine. Returns an ID for cancellation. */
+    start(factory: CoroutineFactory): number;
+    /** Cancel a running coroutine by ID */
+    cancel(id: number): void;
+    /** Cancel all running coroutines */
+    cancelAll(): void;
+    /** Number of running coroutines */
+    readonly activeCount: number;
+}
+/**
+ * Unity-style coroutine system for sequencing game logic.
+ *
+ * @example
+ * const co = useCoroutine()
+ *
+ * co.start(function* () {
+ *   sprite.color = '#ff0000'
+ *   yield wait(0.2)
+ *   sprite.color = '#ffffff'
+ *   yield waitFrames(10)
+ *   sprite.color = '#ff0000'
+ *   yield waitUntil(() => rb.onGround)
+ *   console.log('Landed!')
+ * })
+ */
+declare function useCoroutine(): CoroutineControls;
+
+interface SceneManagerControls {
+    /** Currently active scene (top of stack) */
+    current: string;
+    /** Full scene stack (bottom to top) */
+    stack: string[];
+    /** Push a scene onto the stack */
+    push(scene: string): void;
+    /** Pop the top scene. Returns the popped scene name or undefined if only one scene. */
+    pop(): string | undefined;
+    /** Replace the current scene */
+    replace(scene: string): void;
+    /** Replace the entire stack with a single scene */
+    reset(scene: string): void;
+    /** Check if a specific scene is in the stack */
+    has(scene: string): boolean;
+}
+/**
+ * Manages a stack of game scenes/screens.
+ *
+ * @example
+ * const scenes = useSceneManager('gameplay')
+ * // Push pause menu on top: scenes.push('pause')
+ * // Pop back to gameplay: scenes.pop()
+ * // Switch to game over: scenes.replace('gameOver')
+ * // Reset to main menu: scenes.reset('mainMenu')
+ *
+ * // In render:
+ * {scenes.current === 'gameplay' && <GameplayScene />}
+ * {scenes.current === 'pause' && <PauseMenu onResume={() => scenes.pop()} />}
+ */
+declare function useSceneManager(initialScene: string): SceneManagerControls;
+
+/**
+ * Returns a stable `InputBuffer` instance that persists across renders.
+ *
+ * Call `buffer.record(action)` when an action is pressed, and
+ * `buffer.consume(action)` to check & consume a buffered input.
+ * The buffer auto-prunes expired entries via `update()` — call it
+ * once per frame (e.g., at the top of a `<Script update>`).
+ *
+ * @example
+ * ```tsx
+ * function Player() {
+ *   const buffer = useInputBuffer({ bufferWindow: 0.15 })
+ *
+ *   return (
+ *     <Script update={(id, world, input, dt) => {
+ *       buffer.update()
+ *       if (input.justPressed('Space')) buffer.record('jump')
+ *       if (canJump && buffer.consume('jump')) doJump()
+ *     }} />
+ *   )
+ * }
+ * ```
+ */
+declare function useInputBuffer(opts?: InputBufferOptions): InputBuffer;
+
+interface ComboDetectorResult {
+    /** Feed an action into the detector */
+    feed(action: string): string | null;
+    /** Clear history */
+    clear(): void;
+    /** Last detected combo name, or null */
+    lastCombo: string | null;
+}
+/**
+ * Returns a stable combo detector that tracks input sequences.
+ *
+ * Feed actions (e.g., from `input.justPressed`) each frame. When a
+ * combo sequence is completed within the time window the combo name
+ * is returned from `feed()` and stored in `lastCombo`.
+ *
+ * @example
+ * ```tsx
+ * const combos: ComboDefinition[] = [
+ *   { name: 'hadouken', sequence: ['down', 'forward', 'punch'], maxInterval: 0.3 },
+ * ]
+ *
+ * function Fighter() {
+ *   const combo = useComboDetector(combos)
+ *
+ *   return (
+ *     <Script update={(id, world, input, dt) => {
+ *       if (input.justPressed('ArrowDown')) combo.feed('down')
+ *       if (input.justPressed('ArrowRight')) combo.feed('forward')
+ *       if (input.justPressed('KeyZ')) combo.feed('punch')
+ *       if (combo.lastCombo === 'hadouken') { ... }
+ *     }} />
+ *   )
+ * }
+ * ```
+ */
+declare function useComboDetector(combos: ComboDefinition[]): ComboDetectorResult;
+
+/**
+ * Establishes a parent-child hierarchy relationship between two entities.
+ * On mount: calls setParent(world, child, parent).
+ * On unmount: calls removeParent(world, child).
+ *
+ * Usage inside an <Entity> script or component:
+ * ```tsx
+ * const entityId = useEntity()
+ * const engine = useGame()
+ * const parentId = engine.entityIds.get('player')!
+ * useParent(entityId, parentId)
+ * ```
+ */
+declare function useParent(childEntityId: EntityId, parentEntityId: EntityId): void;
+
+interface AccessibilityControls {
+    options: Readonly<AccessibilityOptions>;
+    setOptions(opts: Partial<AccessibilityOptions>): void;
+    announce(text: string, priority?: 'polite' | 'assertive'): void;
+}
+declare function useAccessibility(): AccessibilityControls;
+
+/**
+ * Controls returned by {@link useHMR}.
+ */
+interface HMRControls {
+    /** Register a handler that serializes state before hot update */
+    onDispose(handler: () => unknown): void;
+    /** Register a handler that restores state after hot update */
+    onAccept(handler: (prevState: unknown) => void): void;
+    /** Whether this is a hot reload (vs initial load) */
+    isHotReload: boolean;
+}
+/**
+ * Hook that enables HMR-aware game development.
+ * When a module is hot-updated, preserves game state instead of full reload.
+ *
+ * Uses the Vite `import.meta.hot` API under the hood; in production builds
+ * (or bundlers without HMR support) the hook is a harmless no-op.
+ *
+ * @param hmrKey Optional stable key to identify this HMR slot. When omitted an
+ *               auto-incrementing id is used (stable across hot reloads because
+ *               the counter resets with each module re-evaluation).
+ *
+ * @example
+ * ```tsx
+ * function PlayerScript({ x, y }) {
+ *   const hmr = useHMR('player')
+ *
+ *   // Serialize state on HMR dispose
+ *   hmr.onDispose(() => ({
+ *     health: playerHealth,
+ *     position: { x: transform.x, y: transform.y },
+ *   }))
+ *
+ *   // Restore state on HMR accept
+ *   hmr.onAccept((prevState) => {
+ *     if (prevState) {
+ *       const s = prevState as { health: number }
+ *       playerHealth = s.health
+ *     }
+ *   })
+ * }
+ * ```
+ */
+declare function useHMR(hmrKey?: string): HMRControls;
+
 declare function playClip(world: ECSWorld, entityId: EntityId, clipName: string): void;
 declare function setAnimationState(world: ECSWorld, entityId: EntityId, stateName: string): void;
 declare function setAnimatorParam(world: ECSWorld, entityId: EntityId, name: string, value: AnimatorParamValue): void;
@@ -1159,4 +1688,4 @@ declare function setAnimatorParam(world: ECSWorld, entityId: EntityId, name: str
  */
 declare function definePrefab<D extends Record<string, unknown>>(name: string, defaults: D, render: (props: D) => ReactElement): React__default.FC<Partial<D>>;
 
-export { AnimatedSprite, type AnimatedSpriteProps, Animation, type AnimationSet, Animator, AssetLoader, type BoundInputMap, BoxCollider, Camera2D, type CameraControls, CameraZone, CapsuleCollider, Checkpoint, CircleCollider, CompoundCollider, type CoordinateHelpers, Entity, Game, type GameControls, type GamepadState, type InputContextControls, MovingPlatform, NineSlice, ParallaxLayer, ParticleEmitter, type ParticlePreset, type PauseControls, type PreloadState, type ProfilerData, RigidBody, ScreenFlash, type ScreenFlashHandle, Script, type SnapshotControls, Sprite, type SpriteAtlas, SquashStretch, Text, type TiledLayer, type TiledObject, Tilemap, Trail, Transform, type VirtualInputState, VirtualJoystick, type VirtualJoystickProps, World, createAtlas, defineAnimations, definePrefab, playClip, setAnimationState, setAnimatorParam, useCamera, useCoordinates, useDestroyEntity, useEntity, useEvent, useEvents, useGame, useGamepad, useInput, useInputContext, useInputMap, useInputRecorder, useLocalMultiplayer, usePause, usePlayerInput, usePostProcess, usePreload, useProfiler, useSnapshot, useVirtualInput };
+export { type AccessibilityControls, AnimatedSprite, type AnimatedSpriteProps, Animation, type AnimationSet, Animator, AssetLoader, type BoundInputMap, BoxCollider, Camera2D, type CameraControls, CameraZone, CapsuleCollider, Checkpoint, Circle, CircleCollider, type ComboDetectorResult, CompoundCollider, ConvexCollider, type CoordinateHelpers, type CoroutineControls, type CoroutineFactory, type CoroutineYield, Entity, Game, type GameControls, type GamepadState, Gradient, type HMRControls, HalfSpaceCollider, HeightFieldCollider, type InputContextControls, Joint, Line, Mask, MovingPlatform, NineSlice, ParallaxLayer, ParticleEmitter, type ParticlePreset, type PauseControls, Polygon, type PreloadState, type ProfilerData, RigidBody, type SceneManagerControls, ScreenFlash, type ScreenFlashHandle, Script, SegmentCollider, type SnapshotControls, Sprite, type SpriteAtlas, SquashStretch, Text, type TiledLayer, type TiledObject, Tilemap, type TimerControls, type TouchControls, Trail, Transform, TriMeshCollider, TriangleCollider, type VirtualInputState, VirtualJoystick, type VirtualJoystickProps, World, createAtlas, defineAnimations, definePrefab, playClip, setAnimationState, setAnimatorParam, useAccessibility, useCamera, useComboDetector, useCoordinates, useCoroutine, useDestroyEntity, useEntity, useEvent, useEvents, useGame, useGamepad, useHMR, useInput, useInputBuffer, useInputContext, useInputMap, useInputRecorder, useLocalMultiplayer, useParent, usePause, usePlayerInput, usePostProcess, usePreload, useProfiler, useSceneManager, useSnapshot, useTimer, useTouch, useVirtualInput, wait, waitFrames, waitUntil };