cubeforge 0.4.9 → 0.4.11

package/dist/index.d.ts

@@ -2,19 +2,21 @@ 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, AccessibilityOptions } from '@cubeforge/core';
-export { AccessibilityOptions, AssetProgress, Component, ECSWorld, Ease, EntityId, GameTimer, HierarchyComponent, HierarchySystem, HotReloadablePlugin, MergedRect, NavGrid, Plugin, PreloadManifest, ScriptUpdateFn, SpatialHash, TimelineEntry, TransformComponent, TweenHandle, TweenOptions, TweenTimeline, Vec2Like, WorldSnapshot, WorldTransformComponent, alignment, announceToScreenReader, arrive, cohesion, createHierarchy, createTag, createTimeline, createTimer, createTransform, definePlugin, evade, findByTag, flee, getAccessibilityOptions, getDescendants, hmrClearState, hmrLoadState, hmrSaveState, hotReloadPlugin, mergeTileColliders, patrol, preloadManifest, pursuit, removeParent, seek, separation, setAccessibilityOptions, setParent, smoothPath, tween, wander } from '@cubeforge/core';
-import { Sampling, BlendMode, SpriteShape, 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, SpriteShape, SquashStretchComponent, TextComponent, TextureFilter, TextureFilterValue, TrailComponent, chromaticAberrationEffect, createCircleShape, createGradient, createLineShape, createMask, createNineSlice, createPolygonShape, createPostProcessStack, createRenderLayerManager, createSprite, defaultLayers, scanlineEffect, vignetteEffect } from '@cubeforge/renderer';
+export { AccessibilityOptions, AssetProgress, Component, DeltaSnapshot, ECSWorld, Ease, EntityId, GameTimer, HierarchyComponent, HierarchySystem, HotReloadablePlugin, MergedRect, NavGrid, Plugin, PreloadManifest, ScriptUpdateFn, SpatialHash, TimelineEntry, TransformComponent, TweenHandle, TweenOptions, TweenTimeline, Vec2Like, WorldSnapshot, WorldTransformComponent, alignment, announceToScreenReader, applyDeltaSnapshot, arrive, cohesion, createHierarchy, createTag, createTimeline, createTimer, createTransform, definePlugin, evade, findByTag, flee, getAccessibilityOptions, getDescendants, hmrClearState, hmrLoadState, hmrSaveState, hotReloadPlugin, mergeTileColliders, patrol, preloadManifest, pursuit, removeParent, seek, separation, setAccessibilityOptions, setParent, smoothPath, tween, wander } from '@cubeforge/core';
+import { Sampling, BlendMode, SpriteShape, AnimatorStateDefinition, AnimatorParamValue, GradientType, GradientStop, MaskShape, PostProcessEffect, PostProcessOptions } 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, PostProcessOptions, PostProcessStack, RenderLayer, RenderLayerManager, RenderSystem, Sampling, SpriteComponent, SpriteShape, 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, 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';
+export { AISteering, AnimationClip, AnimationControllerResult, BindingControls, CharacterControls, CutsceneControls, CutsceneStep, DialogueBox, DialogueBoxProps, DialogueBoxStyle, DialogueControls, DialogueLine, DialogueScript, ForceControls, GameState as GameStateDefinition, GameStateMachineResult, HealthControls, HealthOptions, IDBSaveControls, IDBSaveOptions, KinematicBodyControls, LevelTransitionControls, ObjectPool, PathfindingControls, PlatformerControllerOptions, RestartControls, SaveControls, SaveOptions, TopDownMovementOptions, TransitionOptions, TransitionType, TweenControls, useAISteering, useAnimationController, useCharacterController, useCutscene, useDamageZone, useDialogue, useDropThrough, useForces, useGameStateMachine, useGameStore, useHealth, useIDBSave, 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, MusicControls, MusicOptions, SoundControls, SoundOptions, SpatialSoundControls, SpatialSoundOptions, duck, getGroupVolume, getListenerPosition, getMasterVolume, setGroupMute, setGroupVolume, setGroupVolumeFaded, setListenerPosition, setMasterVolume, stopGroup, useMusic, useSound, useSpatialSound } from '@cubeforge/audio';
+export { ContactData, EngineState, useCircleEnter, useCircleExit, useCircleStay, useCollidingWith, useCollisionEnter, useCollisionExit, useCollisionStay, useTriggerEnter, useTriggerExit, useTriggerStay } from '@cubeforge/context';
+export { AudioAnalyserControls, AudioAnalyserOptions, AudioGroup, AudioSchedulerControls, AudioSchedulerOptions, BarHandler, BeatHandler, CompressorEffectOptions, DelayEffectOptions, FilterEffectOptions, GroupEffectOptions, MusicControls, MusicOptions, PreloadAudioResult, ReverbEffectOptions, SoundControls, SoundOptions, SpatialSoundControls, SpatialSoundOptions, StreamedMusicControls, StreamedMusicOptions, clearGroupEffect, duck, getGroupVolume, getListenerPosition, getMasterVolume, loadAudioSettings, saveAudioSettings, setGroupEffect, setGroupMute, setGroupVolume, setGroupVolumeFaded, setListenerPosition, setMasterVolume, stopGroup, useAudioAnalyser, useAudioScheduler, useMusic, usePreloadAudio, useSound, useSpatialSound, useStreamedMusic } from '@cubeforge/audio';
 export { DevToolsHandle } from '@cubeforge/devtools';
+import { Room } from '@cubeforge/net';
+export { BinaryNetTransport, ClientPrediction, InterpolationBuffer, InterpolationBufferConfig, InterpolationState, NetMessage, NetTransport, NetworkInputConfig, PredictionConfig, Room, RoomConfig, SyncConfig, WebRTCTransport, WebRTCTransportConfig, WebSocketTransportOptions, createWebRTCTransport, createWebSocketTransport, isBinaryTransport, syncEntity, useNetworkInput } from '@cubeforge/net';
 
 interface GameControls {
     pause(): void;
@@ -521,8 +523,43 @@ interface ParticleEmitterProps {
     }>;
     /** Color over lifetime: array of colors to interpolate through */
     colorOverLife?: string[];
+    /**
+     * WebGL blend mode for particles.
+     * - `'normal'` (default) — standard alpha blending
+     * - `'additive'` — particles brighten the background; produces a glow effect
+     * - `'multiply'` — darkens based on particle color
+     * - `'screen'` — lightens, softer than additive
+     */
+    blendMode?: 'normal' | 'additive' | 'multiply' | 'screen';
+    /**
+     * Formation mode: particles lerp toward fixed target positions instead of
+     * being emitted with velocity. Enables logo reveals, constellations, shape morphing.
+     * - `'standard'` (default) — normal emit/gravity/lifetime behaviour
+     * - `'formation'` — particles seek `formationPoints`; no gravity, no expiry
+     */
+    mode?: 'standard' | 'formation';
+    /**
+     * Target positions for formation mode. One particle is spawned per point.
+     * Change this array to morph the formation — particles smoothly lerp to new targets.
+     */
+    formationPoints?: {
+        x: number;
+        y: number;
+    }[];
+    /**
+     * How strongly particles seek their target each frame in formation mode.
+     * Exponential lerp factor (0–1). Default 0.055 (~5.5% per frame at 60 fps).
+     */
+    seekStrength?: number;
+    /**
+     * Smoothly transition all particles to this color.
+     * Works in both standard and formation modes.
+     */
+    targetColor?: string;
+    /** Duration of the global color transition in seconds. Default 0.5. */
+    colorTransitionDuration?: number;
 }
-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;
+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, blendMode, mode, formationPoints, seekStrength, targetColor, colorTransitionDuration, }: ParticleEmitterProps): null;
 
 interface VirtualJoystickProps {
     /** Diameter of the joystick base in pixels (default 120) */
@@ -558,26 +595,62 @@ interface VirtualJoystickProps {
  */
 declare function VirtualJoystick({ size, position, style, actionButton, actionLabel, actionName, }: VirtualJoystickProps): react_jsx_runtime.JSX.Element;
 
-interface MovingPlatformProps {
-    /** Start position */
+interface Waypoint {
+    x: number;
+    y: number;
+}
+type TwoPointProps = {
+    /** Start position (two-point shorthand) */
     x1: number;
     y1: number;
-    /** End position */
+    /** End position (two-point shorthand) */
     x2: number;
     y2: number;
+    waypoints?: never;
+    /** Seconds for a full round trip in two-point mode (default 3). Ignored when waypoints is set. */
+    duration?: number;
+};
+type WaypointProps = {
+    x1?: never;
+    y1?: never;
+    x2?: never;
+    y2?: never;
+    /**
+     * Ordered list of world-space positions to travel through.
+     * The platform ping-pongs between the first and last waypoint.
+     */
+    waypoints: Waypoint[];
+    duration?: never;
+};
+type MovingPlatformProps = (TwoPointProps | WaypointProps) & {
     width?: number;
     height?: number;
-    /** Seconds for a full round trip (default 3) */
-    duration?: number;
+    /**
+     * Movement speed in world pixels per second (waypoint mode only, default 120).
+     * In two-point mode use `duration` to control timing.
+     */
+    speed?: number;
     color?: string;
-}
+};
 /**
- * A static platform that oscillates between (x1,y1) and (x2,y2).
+ * A static platform that moves along a path.
  *
- * @example
- * <MovingPlatform x1={200} y1={350} x2={450} y2={350} width={120} duration={2.5} />
+ * **Two-point mode** (backward-compatible) — oscillates sinusoidally between
+ * `(x1,y1)` and `(x2,y2)` over `duration` seconds:
+ * ```tsx
+ * <MovingPlatform x1={200} y1={350} x2={450} y2={350} duration={2.5} />
+ * ```
+ *
+ * **Waypoint mode** — travels through an ordered list of positions at a fixed
+ * speed, ping-ponging between the first and last point:
+ * ```tsx
+ * <MovingPlatform
+ *   waypoints={[{x:100,y:350},{x:300,y:350},{x:200,y:200}]}
+ *   speed={150}
+ * />
+ * ```
  */
-declare function MovingPlatform({ x1, y1, x2, y2, width, height, duration, color, }: MovingPlatformProps): React__default.ReactElement;
+declare function MovingPlatform(props: MovingPlatformProps): React__default.ReactElement;
 
 interface CheckpointProps {
     x: number;
@@ -941,6 +1014,10 @@ interface ConvexColliderProps {
     restitutionCombineRule?: CombineRule;
     enabled?: boolean;
 }
+/**
+ * @experimental Physics response for convex polygons is not yet fully implemented.
+ * This collider generates contact events but impulse resolution may be incomplete.
+ */
 declare function ConvexCollider({ vertices, offsetX, offsetY, isTrigger, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: ConvexColliderProps): null;
 
 interface TriangleColliderProps {
@@ -967,6 +1044,10 @@ interface TriangleColliderProps {
     restitutionCombineRule?: CombineRule;
     enabled?: boolean;
 }
+/**
+ * @experimental Triangle collider support is not yet complete.
+ * Collision events are generated but physics response may be unreliable.
+ */
 declare function TriangleCollider({ a, b, c, offsetX, offsetY, isTrigger, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: TriangleColliderProps): null;
 
 interface SegmentColliderProps {
@@ -988,6 +1069,10 @@ interface SegmentColliderProps {
     restitutionCombineRule?: CombineRule;
     enabled?: boolean;
 }
+/**
+ * @experimental Segment (edge) collider support is not yet complete.
+ * Suitable for static one-way platforms; dynamic response is not guaranteed.
+ */
 declare function SegmentCollider({ start, end, isTrigger, layer, mask, oneWay, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: SegmentColliderProps): null;
 
 interface HeightFieldColliderProps {
@@ -1002,6 +1087,10 @@ interface HeightFieldColliderProps {
     restitutionCombineRule?: CombineRule;
     enabled?: boolean;
 }
+/**
+ * @experimental Height field terrain collider is not yet fully implemented.
+ * Static terrain collision works; complex interactions may have edge cases.
+ */
 declare function HeightFieldCollider({ heights, scaleX, scaleY, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: HeightFieldColliderProps): null;
 
 interface HalfSpaceColliderProps {
@@ -1015,6 +1104,10 @@ interface HalfSpaceColliderProps {
     restitutionCombineRule?: CombineRule;
     enabled?: boolean;
 }
+/**
+ * @experimental Infinite half-space collider is not yet fully implemented.
+ * Useful as a static world boundary; dynamic body response may be incomplete.
+ */
 declare function HalfSpaceCollider({ normalX, normalY, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: HalfSpaceColliderProps): null;
 
 interface TriMeshColliderProps {
@@ -1031,6 +1124,10 @@ interface TriMeshColliderProps {
     restitutionCombineRule?: CombineRule;
     enabled?: boolean;
 }
+/**
+ * @experimental Triangle mesh collider is not yet fully implemented.
+ * Suitable for static complex geometry; dynamic body response may be incomplete.
+ */
 declare function TriMeshCollider({ vertices, indices, layer, mask, friction, restitution, frictionCombineRule, restitutionCombineRule, enabled, }: TriMeshColliderProps): null;
 
 declare function useGame(): EngineState;
@@ -1084,6 +1181,38 @@ interface CameraControls {
  */
 declare function useCamera(): CameraControls;
 
+interface CameraLookaheadOptions {
+    /**
+     * Maximum lookahead offset in world pixels (default 100).
+     * The camera leads by this many pixels in the entity's movement direction.
+     */
+    distance?: number;
+    /**
+     * Lerp factor per second controlling how quickly the offset follows velocity (default 3).
+     * Higher = snappier, lower = smoother.
+     */
+    smoothing?: number;
+    /**
+     * Whether to apply vertical lookahead in addition to horizontal (default false).
+     * Useful for top-down or platformers with vertical sections.
+     */
+    vertical?: boolean;
+}
+/**
+ * Automatically adjusts the active Camera2D's follow offset based on the
+ * tracked entity's velocity, creating a smooth look-ahead effect.
+ *
+ * Must be used inside `<Game>`. The entity must have a `RigidBody` component.
+ *
+ * @example
+ * function Player() {
+ *   const id = useEntity()
+ *   useCameraLookahead(id, { distance: 120, smoothing: 4 })
+ *   return <RigidBody /><BoxCollider />
+ * }
+ */
+declare function useCameraLookahead(entityId: EntityId, opts?: CameraLookaheadOptions): void;
+
 interface SnapshotControls {
     /**
      * Capture a full serialisable snapshot of all ECS entity/component data.
@@ -1448,6 +1577,48 @@ declare function useProfiler(): ProfilerData;
  */
 declare function usePostProcess(effect: PostProcessEffect): void;
 
+/**
+ * Configures native WebGL2 post-processing effects on the render system.
+ * Effects run entirely on the GPU via a scene FBO + shader pipeline.
+ *
+ * Unlike `usePostProcess` (Canvas2D, deprecated for game use), these effects
+ * work with the WebGL renderer and have no per-pixel CPU cost.
+ *
+ * @param opts - Post-process configuration. Wrap in `useMemo` for stability.
+ *
+ * @example
+ * ```tsx
+ * import { useMemo } from 'react'
+ * import { useWebGLPostProcess } from 'cubeforge'
+ *
+ * function Atmosphere() {
+ *   const pp = useMemo(() => ({
+ *     bloom: { enabled: true, threshold: 0.6, intensity: 0.5 },
+ *     vignette: { enabled: true, intensity: 0.35 },
+ *   }), [])
+ *   useWebGLPostProcess(pp)
+ *   return null
+ * }
+ * ```
+ */
+declare function useWebGLPostProcess(opts: PostProcessOptions): void;
+
+/**
+ * Automatically syncs the Web Audio API listener position to the Camera2D
+ * entity each frame, enabling accurate positional audio for spatial sounds.
+ *
+ * Must be used inside a `<Game>` component. Cleans up on unmount.
+ *
+ * @example
+ * ```tsx
+ * function GameScene() {
+ *   useAudioListener()
+ *   return <Camera2D followEntity="player" />
+ * }
+ * ```
+ */
+declare function useAudioListener(): void;
+
 interface TouchControls {
     /** All currently active touches */
     touches: TouchPoint[];
@@ -1462,6 +1633,89 @@ interface TouchControls {
 }
 declare function useTouch(): TouchControls;
 
+interface SwipeEvent {
+    /** Cardinal direction of the swipe. */
+    direction: 'up' | 'down' | 'left' | 'right';
+    /** Total distance in pixels. */
+    distance: number;
+    /** Pixels per second at the end of the gesture. */
+    velocity: number;
+}
+interface PinchEvent {
+    /** Current scale factor relative to pinch start (< 1 = pinch in, > 1 = spread). */
+    scale: number;
+    /** Change in scale since the last event. */
+    delta: number;
+}
+interface GestureHandlers {
+    /** Fires when a fast directional flick is detected. */
+    onSwipe?: (event: SwipeEvent) => void;
+    /** Fires once when a two-finger pinch/spread begins. */
+    onPinchStart?: () => void;
+    /** Fires each frame during an active pinch gesture. */
+    onPinch?: (event: PinchEvent) => void;
+    /** Fires once when a single touch is held in place without moving. */
+    onLongPress?: (x: number, y: number) => void;
+}
+interface GestureOptions {
+    /**
+     * Minimum pixel distance before a move is classified as a swipe (default 40).
+     */
+    swipeThreshold?: number;
+    /**
+     * Minimum velocity (px/s) required for swipe detection (default 200).
+     */
+    swipeVelocityThreshold?: number;
+    /**
+     * Duration in milliseconds a touch must be held before firing onLongPress (default 500).
+     */
+    longPressDelay?: number;
+    /**
+     * Maximum pixel movement allowed while waiting for a long-press (default 10).
+     */
+    longPressTolerance?: number;
+    /**
+     * Element to attach listeners to. Defaults to `window`.
+     */
+    target?: HTMLElement | null;
+}
+/**
+ * Recognizes common touch gestures (swipe, pinch, long-press) on top of the
+ * raw Touch API. Attach to any element or the whole window.
+ *
+ * @example
+ * useGestures({
+ *   onSwipe: ({ direction }) => { if (direction === 'left') nextCard() },
+ *   onPinch: ({ scale }) => setZoom(scale),
+ *   onLongPress: (x, y) => openContextMenu(x, y),
+ * })
+ */
+declare function useGestures(handlers: GestureHandlers, opts?: GestureOptions): void;
+
+/**
+ * useGamepadHaptics — triggers rumble/vibration on a connected gamepad.
+ *
+ * Uses the Gamepad `vibrationActuator` API (Chrome/Edge). No-ops gracefully
+ * in browsers that don't support it (Firefox, Safari).
+ *
+ * @example
+ * function Player() {
+ *   const haptics = useGamepadHaptics()
+ *   useCollisionEnter((other) => haptics.rumble(0.2, 0.5, 1.0))
+ * }
+ */
+declare function useGamepadHaptics(playerIndex?: number): {
+    /**
+     * Trigger a dual-rumble vibration.
+     * @param duration - Duration in seconds.
+     * @param weakMagnitude - High-frequency (right) motor strength 0–1. Default 0.5.
+     * @param strongMagnitude - Low-frequency (left) motor strength 0–1. Default 1.0.
+     */
+    rumble(duration: number, weakMagnitude?: number, strongMagnitude?: number): void;
+    /** Whether the current browser/controller supports haptics. */
+    isSupported(): boolean;
+};
+
 interface TimerControls {
     /** Start/restart the timer */
     start(): void;
@@ -1768,4 +2022,81 @@ 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 { 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, type SquashStretchControls, 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, useSquashStretch, useTimer, useTouch, useVirtualInput, useWorldQuery, wait, waitFrames, waitUntil };
+interface NetworkSyncOptions {
+    /**
+     * Sync sends per second when this peer is the owner (default 20).
+     */
+    tickRate?: number;
+}
+/**
+ * Keeps a single ECS entity synchronized with remote peers via a Room.
+ *
+ * Owner peers broadcast component state at `tickRate` Hz. Non-owner peers
+ * receive and apply incoming state. The hook automatically starts on mount
+ * and stops (unsubscribing handlers) on unmount.
+ *
+ * Must be used inside `<Game>`.
+ *
+ * @param entityId - The local ECS entity to synchronize.
+ * @param components - Component type strings to include in each broadcast.
+ * @param room - Active multiplayer Room instance.
+ * @param world - The ECS world the entity lives in.
+ * @param owner - `true` if this peer owns and sends authoritative state.
+ * @param opts - Optional configuration.
+ *
+ * @example
+ * function RemotePlayer({ entityId, room, world, isOwner }) {
+ *   useNetworkSync(entityId, ['Transform', 'RigidBody'], room, world, isOwner)
+ *   return <Sprite ... />
+ * }
+ */
+declare function useNetworkSync(entityId: EntityId, components: string[], room: Room, world: ECSWorld, owner: boolean, opts?: NetworkSyncOptions): void;
+
+interface RemotePlayerOptions {
+    /**
+     * Component types to synchronize from remote peers. If provided,
+     * incoming `entity:state` messages for these components are applied.
+     * Leave empty if you handle state application yourself.
+     */
+    syncComponents?: string[];
+}
+interface RemotePlayerControls {
+    /**
+     * Map from peerId → local EntityId for every currently connected remote peer.
+     * Read-only — updated automatically as peers join/leave.
+     */
+    readonly players: ReadonlyMap<string, EntityId>;
+}
+/**
+ * Manages spawning and despawning of local ECS entities for remote peers.
+ *
+ * When a `peer:join` message arrives the `createEntity` factory is called and
+ * the resulting EntityId is tracked. When a `peer:leave` message arrives (or
+ * the component unmounts) `destroyEntity` is called and the entity removed.
+ *
+ * Pair with `useNetworkSync` on the spawned entity to keep state in sync.
+ *
+ * @example
+ * function MultiplayerScene({ room, world }) {
+ *   const { players } = useRemotePlayer({
+ *     room,
+ *     world,
+ *     createEntity: (peerId) => {
+ *       const id = world.createEntity()
+ *       world.addComponent(id, createTransform(100, 100))
+ *       world.addComponent(id, createTag(peerId))
+ *       return id
+ *     },
+ *     destroyEntity: (id) => world.destroyEntity(id),
+ *   })
+ * }
+ */
+declare function useRemotePlayer(config: {
+    room: Room;
+    world: ECSWorld;
+    createEntity: (peerId: string) => EntityId;
+    destroyEntity?: (entityId: EntityId, peerId: string) => void;
+    opts?: RemotePlayerOptions;
+}): RemotePlayerControls;
+
+export { type AccessibilityControls, AnimatedSprite, type AnimatedSpriteProps, Animation, type AnimationSet, Animator, AssetLoader, type BoundInputMap, BoxCollider, Camera2D, type CameraControls, type CameraLookaheadOptions, CameraZone, CapsuleCollider, Checkpoint, Circle, CircleCollider, type ComboDetectorResult, CompoundCollider, ConvexCollider, type CoordinateHelpers, type CoroutineControls, type CoroutineFactory, type CoroutineYield, Entity, Game, type GameControls, type GamepadState, type GestureHandlers, type GestureOptions, Gradient, type HMRControls, HalfSpaceCollider, HeightFieldCollider, type InputContextControls, Joint, Line, Mask, MovingPlatform, type NetworkSyncOptions, NineSlice, ParallaxLayer, ParticleEmitter, type ParticlePreset, type PauseControls, type PinchEvent, Polygon, type PreloadState, type ProfilerData, type RemotePlayerControls, type RemotePlayerOptions, RigidBody, type SceneManagerControls, ScreenFlash, type ScreenFlashHandle, Script, SegmentCollider, type SnapshotControls, Sprite, type SpriteAtlas, SquashStretch, type SquashStretchControls, type SwipeEvent, Text, type TiledLayer, type TiledObject, Tilemap, type TimerControls, type TouchControls, Trail, Transform, TriMeshCollider, TriangleCollider, type VirtualInputState, VirtualJoystick, type VirtualJoystickProps, type Waypoint, World, createAtlas, defineAnimations, definePrefab, playClip, setAnimationState, setAnimatorParam, useAccessibility, useAudioListener, useCamera, useCameraLookahead, useComboDetector, useCoordinates, useCoroutine, useDestroyEntity, useEntity, useEvent, useEvents, useGame, useGamepad, useGamepadHaptics, useGestures, useHMR, useInput, useInputBuffer, useInputContext, useInputMap, useInputRecorder, useLocalMultiplayer, useNetworkSync, useParent, usePause, usePlayerInput, usePostProcess, usePreload, useProfiler, useRemotePlayer, useSceneManager, useSnapshot, useSquashStretch, useTimer, useTouch, useVirtualInput, useWebGLPostProcess, useWorldQuery, wait, waitFrames, waitUntil };