@aura3d/engine 1.0.2 → 1.0.5

package/dist/engine/agent-api/GameRuntime.d.ts

@@ -0,0 +1,931 @@
+export type GameVec3 = readonly [number, number, number];
+export type GameSubsystemOwner = "aura3d" | "app" | "shared";
+export type GameRuntimeSubsystemId = "runtime-nodes" | "frame-loop" | "input" | "kinematic-bodies" | "combat" | "effects" | "camera" | "animation" | "assets" | "stage" | "hud" | "accessibility";
+export interface GameRuntimeSubsystemOwnership {
+    readonly subsystem: GameRuntimeSubsystemId | string;
+    readonly owner: GameSubsystemOwner;
+    readonly configured: boolean;
+    readonly evidence: string;
+}
+export type GameHudBindingKind = "health" | "meter" | "timer" | "combo" | "round" | "debug-toggle";
+export type GameHudValueFormat = "number" | "percent" | "clock" | "text" | "boolean";
+export type GameHudSourceKind = "combat" | "round" | "input" | "runtime" | "debug" | "app-state";
+export interface GameHudBinding {
+    readonly kind: "aura-game-hud-binding";
+    readonly binding: GameHudBindingKind;
+    readonly id: string;
+    readonly label: string;
+    readonly owner: "app";
+    readonly source: GameHudSourceKind;
+    readonly targetId?: string;
+    readonly valuePath: string;
+    readonly maxPath?: string;
+    readonly format: GameHudValueFormat;
+    readonly a11yLabel: string;
+    readonly debugOnly: boolean;
+    readonly interactive: boolean;
+    readonly visibleWhen?: string;
+}
+export type GameHudResolvedValue = string | number | boolean | undefined;
+export interface GameHudSnapshotItem {
+    readonly kind: "aura-game-hud-value";
+    readonly id: string;
+    readonly binding: GameHudBindingKind;
+    readonly label: string;
+    readonly source: GameHudSourceKind;
+    readonly targetId?: string;
+    readonly valuePath: string;
+    readonly value: GameHudResolvedValue;
+    readonly max?: GameHudResolvedValue;
+    readonly formatted: string;
+    readonly changed: boolean;
+    readonly debugOnly: boolean;
+    readonly interactive: boolean;
+    readonly a11yLabel: string;
+}
+export interface GameHudSnapshotOptions {
+    readonly bindings: readonly GameHudBinding[];
+    readonly combat?: GameCombatWorld | GameCombatWorldSnapshot;
+    readonly events?: readonly GameCombatEvent[];
+    readonly round?: Record<string, unknown>;
+    readonly rules?: Record<string, unknown>;
+    readonly input?: GameInputController | GameInputSnapshot;
+    readonly runtime?: Record<string, unknown>;
+    readonly debug?: Record<string, unknown>;
+    readonly appState?: Record<string, unknown>;
+}
+export interface GameHudSnapshot {
+    readonly kind: "aura-game-hud-snapshot";
+    readonly frame: number;
+    readonly time: number;
+    readonly values: readonly GameHudSnapshotItem[];
+    readonly changedIds: readonly string[];
+    readonly events: readonly GameCombatEvent[];
+}
+export interface GameHudActorBindingOptions {
+    readonly id?: string;
+    readonly actorId: string;
+    readonly label?: string;
+    readonly valuePath?: string;
+    readonly maxPath?: string;
+    readonly a11yLabel?: string;
+    readonly visibleWhen?: string;
+}
+export interface GameHudTimerBindingOptions {
+    readonly id?: string;
+    readonly label?: string;
+    readonly valuePath?: string;
+    readonly a11yLabel?: string;
+    readonly visibleWhen?: string;
+}
+export interface GameHudComboBindingOptions {
+    readonly id?: string;
+    readonly actorId?: string;
+    readonly label?: string;
+    readonly valuePath?: string;
+    readonly a11yLabel?: string;
+    readonly visibleWhen?: string;
+}
+export interface GameHudRoundBindingOptions {
+    readonly id?: string;
+    readonly label?: string;
+    readonly valuePath?: string;
+    readonly a11yLabel?: string;
+    readonly visibleWhen?: string;
+}
+export interface GameHudDebugToggleBindingOptions {
+    readonly id?: string;
+    readonly label?: string;
+    readonly statePath?: string;
+    readonly action?: string;
+    readonly a11yLabel?: string;
+    readonly visibleWhen?: string;
+}
+export type GameAccessibilitySourceKind = "label" | "focus" | "reduced-motion" | "reduced-flash" | "high-contrast" | "pause-controls";
+export interface GameAccessibilitySource {
+    readonly kind: "aura-game-accessibility-source";
+    readonly feature: GameAccessibilitySourceKind;
+    readonly id: string;
+    readonly owner: GameSubsystemOwner;
+    readonly label: string;
+    readonly targetId?: string;
+    readonly role?: string;
+    readonly actions: readonly string[];
+    readonly enabled?: boolean;
+    readonly source: "dom" | "media-query" | "input" | "app-state";
+    readonly evidence: string;
+}
+export interface GameAccessibilityLabelOptions {
+    readonly id?: string;
+    readonly targetId: string;
+    readonly label: string;
+    readonly role?: string;
+    readonly live?: boolean;
+}
+export interface GameAccessibilityFocusOptions {
+    readonly id?: string;
+    readonly scopeId: string;
+    readonly label?: string;
+    readonly targets?: readonly string[];
+}
+export interface GameAccessibilityPreferenceOptions {
+    readonly id?: string;
+    readonly enabled?: boolean;
+    readonly label?: string;
+}
+export interface GameAccessibilityPauseControlsOptions {
+    readonly id?: string;
+    readonly label?: string;
+    readonly actions?: readonly string[];
+    readonly resumeActions?: readonly string[];
+    readonly menuId?: string;
+}
+export interface GameAccessibilityRuntimeSettings {
+    readonly kind: "aura-game-accessibility-runtime-settings";
+    readonly reducedMotion: boolean;
+    readonly reducedFlash: boolean;
+    readonly highContrast: boolean;
+    readonly camera: Pick<GameCameraDirectorOptions, "reducedMotion">;
+    readonly effects: Pick<GameEffectsOptions, "reducedMotion" | "reducedFlash">;
+    readonly evidence: readonly string[];
+}
+export interface GameAccessibilityRuntimeSettingsOptions {
+    readonly reducedMotion?: boolean;
+    readonly reducedFlash?: boolean;
+    readonly highContrast?: boolean;
+}
+export type GameVec2 = readonly [number, number];
+export type GameInputDeadzoneMode = "axial" | "scaled";
+export interface GameInputAxisSettings {
+    readonly deadzone?: number;
+    readonly deadzoneMode?: GameInputDeadzoneMode;
+    readonly smoothing?: number;
+    readonly snap?: boolean;
+    readonly scale?: number;
+    readonly invert?: boolean;
+}
+export interface GameLoopPlan {
+    readonly kind: "aura-game-loop-plan";
+    readonly fixedDt: number;
+    readonly maxSubSteps: number;
+    readonly timeScale: number;
+}
+export interface GameInputAxisBinding extends GameInputAxisSettings {
+    readonly negative?: string;
+    readonly positive?: string;
+    readonly gamepadAxis?: number;
+    readonly gamepadIndex?: number;
+    readonly pointerDelta?: "x" | "y";
+}
+export interface GameInputOptions {
+    readonly actions: Record<string, readonly string[]>;
+    readonly axes?: Record<string, GameInputAxisBinding>;
+    readonly axisDefaults?: GameInputAxisSettings;
+    readonly bufferMs?: number;
+    readonly target?: EventTarget;
+    readonly autoListen?: boolean;
+    readonly pointer?: boolean;
+    readonly touch?: boolean;
+    readonly gamepad?: boolean | {
+        readonly index?: number;
+    };
+}
+export interface GameInputActionState {
+    readonly pressed: boolean;
+    readonly held: boolean;
+    readonly released: boolean;
+    readonly buffered: boolean;
+    readonly value: number;
+}
+export interface GameInputReplayEvent {
+    readonly frame: number;
+    readonly time: number;
+    readonly type: "press" | "release";
+    readonly binding: string;
+}
+export interface GamePointerSnapshot {
+    readonly active: boolean;
+    readonly x: number;
+    readonly y: number;
+    readonly dx: number;
+    readonly dy: number;
+    readonly buttons: readonly number[];
+}
+export interface GamepadSnapshot {
+    readonly connected: boolean;
+    readonly index?: number;
+    readonly axes: readonly number[];
+    readonly buttons: readonly string[];
+}
+export interface GameInputSnapshot {
+    readonly kind: "aura-game-input-snapshot";
+    readonly frame: number;
+    readonly time: number;
+    readonly activeBindings: readonly string[];
+    readonly actions: Record<string, GameInputActionState>;
+    readonly axes?: Record<string, number>;
+    readonly pointer: GamePointerSnapshot;
+    readonly gamepads: readonly GamepadSnapshot[];
+}
+export interface GameInputController {
+    readonly kind: "aura-game-input-plan";
+    readonly actions: Record<string, readonly string[]>;
+    readonly axes: Record<string, GameInputAxisBinding>;
+    readonly bufferMs: number;
+    update(dt?: number): GameInputSnapshot;
+    snapshot(): GameInputSnapshot;
+    pressed(action: string): boolean;
+    held(action: string): boolean;
+    released(action: string): boolean;
+    buffered(action: string, windowMs?: number): boolean;
+    combo(actions: readonly string[], windowMs?: number): boolean;
+    axis(name: string, negativeAction?: string, positiveAction?: string): number;
+    press(binding: string): void;
+    release(binding: string): void;
+    setAction(action: string, held: boolean): void;
+    recorded(): readonly GameInputReplayEvent[];
+    replay(events: readonly GameInputReplayEvent[], dt?: number): GameInputSnapshot;
+    clearReplay(): void;
+    dispose(): void;
+}
+export interface GameInputReplayOptions {
+    readonly fps?: number;
+    readonly seed?: number;
+    readonly label?: string;
+}
+export interface GameInputReplayPlan {
+    readonly kind: "aura-game-input-replay";
+    readonly label?: string;
+    readonly fps: number;
+    readonly seed: number;
+    readonly frameCount: number;
+    readonly duration: number;
+    readonly checksum: string;
+    readonly events: readonly GameInputReplayEvent[];
+}
+export interface GameInputReplayDriverSnapshot {
+    readonly kind: "aura-game-input-replay-driver";
+    readonly frame: number;
+    readonly time: number;
+    readonly checksum: string;
+    readonly complete: boolean;
+}
+export interface GameInputReplayDriver {
+    readonly kind: "aura-game-input-replay-driver";
+    readonly replay: GameInputReplayPlan;
+    step(dt?: number): GameInputSnapshot;
+    seek(frame: number, dt?: number): GameInputSnapshot;
+    reset(): void;
+    snapshot(): GameInputReplayDriverSnapshot;
+}
+export type GameTouchControlKind = "stick" | "dpad" | "button";
+export type GameTouchControlAnchor = "bottom-left" | "bottom-right" | "top-left" | "top-right";
+export interface GameTouchSafeArea {
+    readonly top?: number;
+    readonly right?: number;
+    readonly bottom?: number;
+    readonly left?: number;
+}
+export interface GameTouchControlRequest {
+    readonly id?: string;
+    readonly kind?: GameTouchControlKind;
+    readonly action?: string;
+    readonly label?: string;
+    readonly side?: "left" | "right";
+    readonly size?: number;
+    readonly radius?: number;
+    readonly binding?: string;
+}
+export interface GameTouchControlLayoutOptions {
+    readonly width: number;
+    readonly height: number;
+    readonly safeArea?: GameTouchSafeArea;
+    readonly scale?: number;
+    readonly gap?: number;
+    readonly stick?: false | GameTouchControlRequest;
+    readonly buttons?: readonly GameTouchControlRequest[];
+}
+export interface GameTouchControlRegion {
+    readonly id: string;
+    readonly kind: GameTouchControlKind;
+    readonly action?: string;
+    readonly label: string;
+    readonly binding: string;
+    readonly anchor: GameTouchControlAnchor;
+    readonly center: GameVec2;
+    readonly radius: number;
+    readonly rect: readonly [number, number, number, number];
+    readonly zIndex: number;
+}
+export interface GameTouchControlLayout {
+    readonly kind: "aura-game-touch-layout";
+    readonly width: number;
+    readonly height: number;
+    readonly safeArea: Required<GameTouchSafeArea>;
+    readonly controls: readonly GameTouchControlRegion[];
+    readonly bindings: Record<string, string>;
+}
+export interface GameBounds3 {
+    readonly minX?: number;
+    readonly maxX?: number;
+    readonly minY?: number;
+    readonly maxY?: number;
+    readonly minZ?: number;
+    readonly maxZ?: number;
+}
+export interface GameKinematicMoveCommand {
+    readonly x?: number;
+    readonly y?: number;
+    readonly z?: number;
+    readonly axis?: number;
+    readonly speed?: number;
+    readonly jump?: boolean;
+    readonly jumpVelocity?: number;
+    readonly dash?: boolean | GameVec3;
+    readonly dashSpeed?: number;
+    readonly knockback?: GameVec2 | GameVec3;
+}
+export type GameCombatMoveDefinition = Omit<GameCombatMove, "id"> & {
+    readonly id?: string;
+};
+export interface GameKinematicBodyOptions {
+    readonly id?: string;
+    readonly position?: GameVec3;
+    readonly velocity?: GameVec3;
+    readonly size?: GameVec3;
+    readonly collider?: GameCollider;
+    readonly gravity?: number | boolean;
+    readonly groundY?: number;
+    readonly friction?: number;
+    readonly maxSpeed?: number;
+    readonly jumpVelocity?: number;
+    readonly coyoteMs?: number;
+    readonly jumpBufferMs?: number;
+    readonly bounds?: GameBounds3;
+}
+export interface GameKinematicBodySnapshot {
+    readonly kind: "aura-game-kinematic-body";
+    readonly id?: string;
+    readonly position: GameVec3;
+    readonly velocity: GameVec3;
+    readonly size: GameVec3;
+    readonly collider?: GameCollider;
+    readonly grounded: boolean;
+    readonly facing: 1 | -1;
+    readonly coyoteAvailable?: boolean;
+    readonly jumpBuffered?: boolean;
+}
+export interface GameKinematicBody {
+    readonly id?: string;
+    position: GameVec3;
+    velocity: GameVec3;
+    readonly size: GameVec3;
+    readonly collider?: GameCollider;
+    readonly grounded: boolean;
+    readonly facing: 1 | -1;
+    move(axis: number | GameKinematicMoveCommand, speedOrDt?: number): void | GameKinematicBodySnapshot;
+    jump(velocity?: number): boolean;
+    requestJump(): void;
+    canJump(): boolean;
+    consumeJump(velocity?: number): boolean;
+    dash(direction: GameVec3, speed?: number): void;
+    applyKnockback(velocity: GameVec3): void;
+    defineMove(id: string, move: GameCombatMoveDefinition): GameCombatMove;
+    attack(moveId: string): GameCombatMove | undefined;
+    moves(): readonly GameCombatMove[];
+    update(dt: number): GameKinematicBodySnapshot;
+    snapToGround(groundY?: number): void;
+    bounds(): GameAabb;
+    snapshot(): GameKinematicBodySnapshot;
+}
+export interface GameAabb {
+    readonly center: GameVec3;
+    readonly size: GameVec3;
+    readonly min: GameVec3;
+    readonly max: GameVec3;
+}
+export interface GameJumpAssistOptions {
+    readonly coyoteMs?: number;
+    readonly bufferMs?: number;
+}
+export interface GameJumpAssistUpdate {
+    readonly grounded: boolean;
+    readonly jumpPressed?: boolean;
+    readonly jumpRequested?: boolean;
+}
+export interface GameJumpAssistSnapshot {
+    readonly kind: "aura-game-jump-assist";
+    readonly time: number;
+    readonly grounded: boolean;
+    readonly coyoteMs: number;
+    readonly bufferMs: number;
+    readonly lastGroundedAt: number;
+    readonly lastJumpRequestedAt: number;
+    readonly coyoteAvailable: boolean;
+    readonly jumpBuffered: boolean;
+    readonly consumed: boolean;
+    readonly canJump: boolean;
+}
+export interface GameJumpAssistController {
+    readonly kind: "aura-game-jump-assist";
+    update(dt: number, state: GameJumpAssistUpdate): GameJumpAssistSnapshot;
+    requestJump(): void;
+    canJump(): boolean;
+    consume(): boolean;
+    reset(state?: Partial<GameJumpAssistUpdate>): GameJumpAssistSnapshot;
+    snapshot(): GameJumpAssistSnapshot;
+}
+export type GameColliderKind = "box" | "sphere" | "capsule" | "rect";
+export type GameColliderDimension = 2 | 3;
+export type GameColliderAxis = "x" | "y" | "z";
+export type GameColliderPlane = "xy" | "xz" | "yz";
+export interface GameColliderFactoryOptions {
+    readonly id?: string;
+    readonly center?: GameVec3;
+    readonly offset?: GameVec3;
+    readonly tags?: readonly string[];
+    readonly dimension?: GameColliderDimension;
+    readonly sensor?: boolean;
+}
+export interface GameBoxColliderOptions extends GameColliderFactoryOptions {
+    readonly size?: GameVec3 | GameVec2;
+    readonly width?: number;
+    readonly height?: number;
+    readonly depth?: number;
+}
+export interface GameSphereColliderOptions extends GameColliderFactoryOptions {
+    readonly radius?: number;
+}
+export interface GameCapsuleColliderOptions extends GameColliderFactoryOptions {
+    readonly radius?: number;
+    readonly height?: number;
+    readonly axis?: GameColliderAxis;
+}
+export interface GameRectColliderOptions extends GameColliderFactoryOptions {
+    readonly size?: GameVec2;
+    readonly width?: number;
+    readonly height?: number;
+    readonly plane?: GameColliderPlane;
+}
+export interface GameColliderBase {
+    readonly id?: string;
+    readonly kind: GameColliderKind;
+    readonly center: GameVec3;
+    readonly offset?: GameVec3;
+    readonly tags: readonly string[];
+    readonly dimension: GameColliderDimension;
+    readonly sensor: boolean;
+}
+export interface GameBoxCollider extends GameColliderBase {
+    readonly kind: "box";
+    readonly size: GameVec3;
+}
+export interface GameSphereCollider extends GameColliderBase {
+    readonly kind: "sphere";
+    readonly radius: number;
+}
+export interface GameCapsuleCollider extends GameColliderBase {
+    readonly kind: "capsule";
+    readonly radius: number;
+    readonly height: number;
+    readonly axis: GameColliderAxis;
+}
+export interface GameRectCollider extends GameColliderBase {
+    readonly kind: "rect";
+    readonly size: GameVec2;
+    readonly plane: GameColliderPlane;
+}
+export type GameCollider = GameBoxCollider | GameSphereCollider | GameCapsuleCollider | GameRectCollider;
+export interface GameCollisionBox {
+    readonly id?: string;
+    readonly offset?: GameVec3;
+    readonly center?: GameVec3;
+    readonly size: GameVec3;
+    readonly tags?: readonly string[];
+}
+export interface GameCollisionBoxFactoryOptions {
+    readonly id?: string;
+    readonly offset?: GameVec2 | GameVec3;
+    readonly center?: GameVec2 | GameVec3;
+    readonly size?: GameVec2 | GameVec3;
+    readonly width?: number;
+    readonly height?: number;
+    readonly depth?: number;
+    readonly tags?: readonly string[];
+}
+export type GameDebugGeometryPrimitive = "box" | "sphere" | "capsule" | "rect";
+export interface GameDebugGeometryOptions {
+    readonly color?: string;
+    readonly opacity?: number;
+    readonly wireframe?: boolean;
+    readonly source?: string;
+    readonly origin?: GameVec3;
+    readonly facing?: 1 | -1;
+    readonly mirrorX?: boolean;
+}
+export interface GameDebugGeometryNode {
+    readonly kind: "aura-game-debug-geometry";
+    readonly id: string;
+    readonly primitive: GameDebugGeometryPrimitive;
+    readonly position: GameVec3;
+    readonly scale: GameVec3;
+    readonly radius?: number;
+    readonly height?: number;
+    readonly axis?: GameColliderAxis;
+    readonly plane?: GameColliderPlane;
+    readonly color: string;
+    readonly opacity: number;
+    readonly wireframe: boolean;
+    readonly source: string;
+    readonly tags: readonly string[];
+    readonly aabb: GameAabb;
+}
+export interface GameCombatActorOptions {
+    readonly id: string;
+    readonly team?: string;
+    readonly position?: GameVec3;
+    readonly facing?: 1 | -1;
+    readonly health?: number;
+    readonly guard?: number;
+    readonly meter?: number;
+    readonly hurtboxes?: readonly GameCollisionBox[];
+    readonly guardboxes?: readonly GameCollisionBox[];
+    readonly pushboxes?: readonly GameCollisionBox[];
+    readonly guarding?: boolean;
+}
+export interface GameCombatActorSnapshot extends Required<Omit<GameCombatActorOptions, "position" | "hurtboxes" | "guardboxes" | "pushboxes" | "facing">> {
+    readonly position: GameVec3;
+    readonly facing: 1 | -1;
+    readonly hurtboxes: readonly GameCollisionBox[];
+    readonly guardboxes: readonly GameCollisionBox[];
+    readonly pushboxes: readonly GameCollisionBox[];
+    readonly stun: number;
+    readonly recovery: number;
+}
+export interface GameCombatMove {
+    readonly id: string;
+    readonly name?: string;
+    readonly startup?: number;
+    readonly active?: number;
+    readonly damage?: number;
+    readonly guardDamage?: number;
+    readonly meterGain?: number;
+    readonly hitStop?: number;
+    readonly hitStun?: number;
+    readonly blockStun?: number;
+    readonly recovery?: number;
+    readonly knockback?: GameVec3;
+    readonly activeFrames?: readonly [number, number];
+    readonly durationFrames?: number;
+    readonly hitbox?: GameCollisionBox;
+    readonly hitboxes?: readonly GameCollisionBox[];
+    readonly blockable?: boolean;
+}
+export type GameCombatEventType = "hit" | "blocked" | "whiff" | "push";
+export interface GameCombatEvent {
+    readonly type: GameCombatEventType;
+    readonly frame: number;
+    readonly time: number;
+    readonly attackerId: string;
+    readonly targetId?: string;
+    readonly moveId?: string;
+    readonly damage?: number;
+    readonly guardDamage?: number;
+    readonly hitStop?: number;
+    readonly stun?: number;
+    readonly knockback?: GameVec3;
+    readonly position: GameVec3;
+}
+export interface GameCombatActiveAttackSnapshot {
+    readonly attackerId: string;
+    readonly moveId: string;
+    readonly frame: number;
+    readonly activeFrames: readonly [number, number];
+    readonly durationFrames: number;
+    readonly active: boolean;
+    readonly hitboxes: readonly GameCollisionBox[];
+    readonly hitTargets: readonly string[];
+}
+export interface GameCombatWorldSnapshot {
+    readonly kind: "aura-game-combat-world";
+    readonly frame: number;
+    readonly time: number;
+    readonly actors: readonly GameCombatActorSnapshot[];
+    readonly activeAttacks: readonly GameCombatActiveAttackSnapshot[];
+    readonly events: readonly GameCombatEvent[];
+}
+export interface GameCombatWorld {
+    addActor(actor: GameCombatActorOptions): void;
+    setActor(id: string, patch: Partial<GameCombatActorOptions>): void;
+    removeActor(id: string): void;
+    defineMove(actorId: string, move: GameCombatMove): void;
+    attack(attackerId: string, move: string | GameCombatMove): void;
+    beginAttack(attackerId: string, move: GameCombatMove): void;
+    update(dt: number): GameCombatWorldSnapshot;
+    step(dt: number): readonly GameCombatEvent[];
+    events(): readonly GameCombatEvent[];
+    consumeEvents(): readonly GameCombatEvent[];
+    snapshot(): GameCombatWorldSnapshot;
+    clear(): void;
+}
+export interface GameFighting2DRulesOptions {
+    readonly gravity?: number;
+    readonly roundSeconds?: number;
+    readonly maxHealth?: number;
+    readonly maxGuard?: number;
+    readonly maxMeter?: number;
+    readonly stageBounds?: GameBounds3;
+    readonly fps?: number;
+    readonly pushboxSeparation?: boolean;
+}
+export interface GameFighting2DRules {
+    readonly kind: "aura-game-fighting-2d-rules";
+    readonly gravity: number;
+    readonly roundSeconds: number;
+    readonly maxHealth: number;
+    readonly maxGuard: number;
+    readonly maxMeter: number;
+    readonly stageBounds: GameBounds3;
+    readonly fps: number;
+    readonly pushboxSeparation: boolean;
+}
+export interface GameCombatWorldOptions {
+    readonly fighters?: readonly (GameKinematicBody | GameCombatActorOptions)[];
+    readonly rules?: GameFighting2DRules;
+    readonly stageBounds?: GameBounds3;
+}
+export type GameCameraDirectorMode = "side-fighter" | "follow" | "fixed";
+export interface GameCameraDirectorOptions {
+    readonly targetIds?: readonly string[];
+    readonly mode?: GameCameraDirectorMode;
+    readonly targetY?: number;
+    readonly distance?: number;
+    readonly baseFov?: number;
+    readonly minZoom?: number;
+    readonly maxZoom?: number;
+    readonly bounds?: GameBounds3;
+    readonly stageBounds?: GameBounds3;
+    readonly impactShake?: boolean;
+    readonly smoothing?: number;
+    readonly deadZone?: number;
+    readonly reducedMotion?: boolean;
+}
+export interface GameCameraTarget {
+    readonly id?: string;
+    readonly position: GameVec3;
+}
+export interface GameCameraSnapshot {
+    readonly kind: "aura-game-camera-director";
+    readonly position: GameVec3;
+    readonly target: GameVec3;
+    readonly fov: number;
+    readonly zoom: number;
+    readonly shake: number;
+    readonly reducedMotion: boolean;
+    readonly mode?: GameCameraDirectorMode;
+    readonly targetIds?: readonly string[];
+}
+export interface GameCameraDirector {
+    update(dt: number, targets: readonly GameCameraTarget[]): GameCameraSnapshot;
+    impact(intensity?: number, duration?: number): void;
+    special(target?: GameVec3, duration?: number): void;
+    snapshot(): GameCameraSnapshot;
+}
+export type GameEffectKind = "hit-spark" | "block-spark" | "impact-decal" | "ground-dust" | "dash-trail" | "slash-trail" | "impact-flash" | "aura-burst" | "shockwave" | "ring-shockwave" | "super-flash";
+export interface GameEffectsOptions {
+    readonly poolSize?: number;
+    readonly reducedMotion?: boolean;
+    readonly reducedFlash?: boolean;
+    readonly sparks?: GameEffectPreset;
+    readonly trails?: GameEffectPreset;
+    readonly superBurst?: GameEffectPreset;
+    readonly presets?: Record<string, GameEffectPreset>;
+}
+export interface GameEffectOptions {
+    readonly color?: string;
+    readonly intensity?: number;
+    readonly duration?: number;
+    readonly radius?: number;
+    readonly ownerId?: string;
+    readonly attachment?: GameEffectAttachment;
+}
+export interface GameEffectPreset {
+    readonly kind: GameEffectKind;
+    readonly options?: GameEffectOptions;
+}
+export interface GameEffectAttachment {
+    readonly id?: string;
+    readonly targetId?: string;
+    readonly offset?: GameVec3;
+    readonly getPosition?: () => GameVec3;
+}
+export interface GameEffectInstance extends Required<Omit<GameEffectOptions, "ownerId" | "attachment">> {
+    readonly id: string;
+    readonly kind: GameEffectKind;
+    readonly position: GameVec3;
+    readonly ownerId?: string;
+    readonly attachmentId?: string;
+    readonly attachmentOffset?: GameVec3;
+    readonly age: number;
+}
+export interface GameEffectsSnapshot {
+    readonly kind: "aura-game-effects";
+    readonly active: number;
+    readonly spawned: number;
+    readonly pooled: number;
+    readonly reducedMotion: boolean;
+    readonly reducedFlash: boolean;
+    readonly effects: readonly GameEffectInstance[];
+}
+export interface GameEffectsController {
+    spawn(kind: GameEffectKind, position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    emit(events: readonly GameCombatEvent[], options?: GameEffectOptions): readonly GameEffectInstance[];
+    hitSpark(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    blockSpark(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    impactDecal(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    groundDust(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    dashTrail(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    slashTrail(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    impactFlash(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    auraBurst(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    shockwave(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    ringShockwave(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    superFlash(position: GameVec3, options?: GameEffectOptions): GameEffectInstance;
+    update(dt: number): GameEffectsSnapshot;
+    snapshot(): GameEffectsSnapshot;
+    nodes(): readonly any[];
+    clear(): void;
+}
+export interface GameDebugOverlayMetric {
+    readonly id: string;
+    readonly label: string;
+    readonly value: string | number | boolean;
+    readonly severity?: "info" | "warn" | "error";
+}
+export interface GameDebugOverlaySection {
+    readonly id: string;
+    readonly title: string;
+    readonly metrics: readonly GameDebugOverlayMetric[];
+}
+export interface GameDebugOverlayOptions {
+    readonly runtime?: {
+        readonly frame: number;
+        readonly time: number;
+        readonly paused?: boolean;
+    };
+    readonly input?: GameInputController | GameInputSnapshot;
+    readonly bodies?: readonly GameKinematicBody[];
+    readonly bodySnapshots?: readonly GameKinematicBodySnapshot[];
+    readonly combat?: GameCombatWorld | GameCombatWorldSnapshot;
+    readonly effects?: GameEffectsController | GameEffectsSnapshot;
+    readonly camera?: GameCameraDirector | GameCameraSnapshot;
+    readonly colliders?: readonly GameCollider[];
+    readonly hitboxes?: readonly GameCollisionBox[];
+    readonly labels?: Record<string, string | number | boolean>;
+    readonly warnings?: readonly string[];
+}
+export interface GameDebugOverlayData {
+    readonly kind: "aura-game-debug-overlay";
+    readonly frame: number;
+    readonly time: number;
+    readonly paused: boolean;
+    readonly sections: readonly GameDebugOverlaySection[];
+    readonly geometry: readonly GameDebugGeometryNode[];
+    readonly labels: Record<string, string | number | boolean>;
+    readonly warnings: readonly string[];
+}
+export type GameDebugScenePrimitive = "box" | "sphere" | "capsule" | "plane";
+export interface GameDebugSceneNode {
+    readonly kind: "primitive" | "label";
+    readonly primitive?: GameDebugScenePrimitive;
+    readonly name: string;
+    readonly position: GameVec3;
+    readonly scale?: number | GameVec3;
+    readonly material?: {
+        readonly color: string;
+        readonly emissive?: string;
+        readonly emissiveIntensity?: number;
+        readonly opacity?: number;
+        readonly transparent?: boolean;
+        readonly wireframe?: boolean;
+    };
+    readonly text?: string;
+    readonly color?: string;
+    readonly background?: string;
+    readonly size?: number;
+    readonly runtime?: {
+        readonly id: string;
+        readonly mutable: boolean;
+        readonly tags: readonly string[];
+    };
+    readonly debug?: {
+        readonly source: string;
+        readonly tags: readonly string[];
+        readonly aabb: GameAabb;
+    };
+}
+export interface GameDebugSceneNodeOptions {
+    readonly runtimePrefix?: string;
+    readonly includeLabels?: boolean;
+}
+export interface GameCombatEventRuntimeBridgeOptions {
+    readonly combat?: GameCombatWorld | GameCombatWorldSnapshot;
+    readonly effects?: GameEffectsController;
+    readonly camera?: GameCameraDirector;
+    readonly hudBindings?: readonly GameHudBinding[];
+    readonly round?: Record<string, unknown>;
+    readonly rules?: Record<string, unknown>;
+    readonly input?: GameInputController | GameInputSnapshot;
+    readonly runtime?: Record<string, unknown>;
+    readonly debug?: Record<string, unknown>;
+    readonly appState?: Record<string, unknown>;
+}
+export interface GameCombatEventRuntimeBridgeResult {
+    readonly kind: "aura-game-combat-event-runtime-bridge";
+    readonly events: readonly GameCombatEvent[];
+    readonly effectIds: readonly string[];
+    readonly cameraImpacts: number;
+    readonly hud?: GameHudSnapshot;
+}
+export declare function createGameLoopPlan(options?: Partial<Omit<GameLoopPlan, "kind">>): GameLoopPlan;
+export declare function createGameJumpAssist(options?: GameJumpAssistOptions): GameJumpAssistController;
+export declare function createGameInputReplay(events: readonly GameInputReplayEvent[], options?: GameInputReplayOptions): GameInputReplayPlan;
+export declare function gameInputReplayEventsAt(replay: GameInputReplayPlan, frame: number): readonly GameInputReplayEvent[];
+export declare function createGameInputReplayDriver(input: GameInputController, replay: GameInputReplayPlan): GameInputReplayDriver;
+export declare function createGameTouchControlLayout(options: GameTouchControlLayoutOptions): GameTouchControlLayout;
+export declare function createGameInput(options: GameInputOptions): GameInputController;
+export declare function createGameKinematicBody(options?: GameKinematicBodyOptions): GameKinematicBody;
+export declare function createGameFighting2DRules(options?: GameFighting2DRulesOptions): GameFighting2DRules;
+export declare function createCombatWorld(options?: GameCombatWorldOptions): GameCombatWorld;
+export declare function createGameCameraDirector(options?: GameCameraDirectorOptions): GameCameraDirector;
+export declare function createGameEffects(options?: GameEffectsOptions): GameEffectsController;
+export declare function applyGameCombatEventsToRuntime(events: readonly GameCombatEvent[], options?: GameCombatEventRuntimeBridgeOptions): GameCombatEventRuntimeBridgeResult;
+export declare function createGameBoxCollider(options?: GameBoxColliderOptions): GameBoxCollider;
+export declare function createGameSphereCollider(options?: GameSphereColliderOptions): GameSphereCollider;
+export declare function createGameCapsuleCollider(options?: GameCapsuleColliderOptions): GameCapsuleCollider;
+export declare function createGameRectCollider(options?: GameRectColliderOptions): GameRectCollider;
+export declare const gameColliders: {
+    readonly box: typeof createGameBoxCollider;
+    readonly sphere: typeof createGameSphereCollider;
+    readonly capsule: typeof createGameCapsuleCollider;
+    readonly rect: typeof createGameRectCollider;
+};
+export declare function createGameCollisionBox(options?: GameCollisionBoxFactoryOptions, tag?: string): GameCollisionBox;
+export declare function createGameHitboxRect(options?: GameCollisionBoxFactoryOptions): GameCollisionBox;
+export declare function createGameHurtboxRect(options?: GameCollisionBoxFactoryOptions): GameCollisionBox;
+export declare function createGameGuardboxRect(options?: GameCollisionBoxFactoryOptions): GameCollisionBox;
+export declare function createGamePushboxRect(options?: GameCollisionBoxFactoryOptions): GameCollisionBox;
+export declare const gameHitboxes: {
+    readonly rect: typeof createGameHitboxRect;
+    readonly box: typeof createGameHitboxRect;
+};
+export declare const gameHurtboxes: {
+    readonly rect: typeof createGameHurtboxRect;
+    readonly box: typeof createGameHurtboxRect;
+};
+export declare const gameGuardboxes: {
+    readonly rect: typeof createGameGuardboxRect;
+    readonly box: typeof createGameGuardboxRect;
+};
+export declare const gamePushboxes: {
+    readonly rect: typeof createGamePushboxRect;
+    readonly box: typeof createGamePushboxRect;
+};
+export declare const gameTriggerVolumes: {
+    readonly box: (options?: GameBoxColliderOptions) => GameBoxCollider;
+    readonly sphere: (options?: GameSphereColliderOptions) => GameSphereCollider;
+    readonly capsule: (options?: GameCapsuleColliderOptions) => GameCapsuleCollider;
+    readonly rect: (options?: GameRectColliderOptions) => GameRectCollider;
+};
+export declare const gameEffectPresets: {
+    readonly hitSpark: (options?: GameEffectOptions) => GameEffectPreset;
+    readonly blockSpark: (options?: GameEffectOptions) => GameEffectPreset;
+    readonly groundDust: (options?: GameEffectOptions) => GameEffectPreset;
+    readonly dashTrail: (options?: GameEffectOptions) => GameEffectPreset;
+    readonly slashTrail: (options?: GameEffectOptions) => GameEffectPreset;
+    readonly shockwave: (options?: GameEffectOptions) => GameEffectPreset;
+    readonly auraBurst: (options?: GameEffectOptions) => GameEffectPreset;
+    readonly superBurst: (options?: GameEffectOptions) => GameEffectPreset;
+};
+export declare function gameColliderAabb(collider: GameCollider): GameAabb;
+export declare function createGameColliderDebugGeometry(colliders: readonly GameCollider[], options?: GameDebugGeometryOptions): readonly GameDebugGeometryNode[];
+export declare function createGameHitboxDebugGeometry(hitboxes: readonly GameCollisionBox[], options?: GameDebugGeometryOptions): readonly GameDebugGeometryNode[];
+export declare function createGameCombatDebugGeometry(snapshot: GameCombatWorldSnapshot, options?: GameDebugGeometryOptions): readonly GameDebugGeometryNode[];
+export declare function createGameDebugOverlayData(options?: GameDebugOverlayOptions): GameDebugOverlayData;
+export declare function createGameDebugSceneNodes(debug: GameDebugOverlayData | readonly GameDebugGeometryNode[], options?: GameDebugSceneNodeOptions): readonly GameDebugSceneNode[];
+export declare function createGameHudHealthBinding(options: GameHudActorBindingOptions): GameHudBinding;
+export declare function createGameHudMeterBinding(options: GameHudActorBindingOptions): GameHudBinding;
+export declare function createGameHudTimerBinding(options?: GameHudTimerBindingOptions): GameHudBinding;
+export declare function createGameHudComboBinding(options?: GameHudComboBindingOptions): GameHudBinding;
+export declare function createGameHudRoundBinding(options?: GameHudRoundBindingOptions): GameHudBinding;
+export declare function createGameHudDebugToggleBinding(options?: GameHudDebugToggleBindingOptions): GameHudBinding;
+export declare function createGameHudBindings(bindings: readonly GameHudBinding[]): readonly GameHudBinding[];
+export declare function createGameHudSnapshot(options: GameHudSnapshotOptions): GameHudSnapshot;
+export declare function createGameAccessibilityLabel(options: GameAccessibilityLabelOptions): GameAccessibilitySource;
+export declare function createGameAccessibilityFocus(options: GameAccessibilityFocusOptions): GameAccessibilitySource;
+export declare function createGameReducedMotionSource(options?: GameAccessibilityPreferenceOptions): GameAccessibilitySource;
+export declare function createGameReducedFlashSource(options?: GameAccessibilityPreferenceOptions): GameAccessibilitySource;
+export declare function createGameHighContrastSource(options?: GameAccessibilityPreferenceOptions): GameAccessibilitySource;
+export declare function createGamePauseControlsSource(options?: GameAccessibilityPauseControlsOptions): GameAccessibilitySource;
+export declare function createGameAccessibilityRuntimeSettings(sources?: readonly GameAccessibilitySource[], options?: GameAccessibilityRuntimeSettingsOptions): GameAccessibilityRuntimeSettings;
+//# sourceMappingURL=GameRuntime.d.ts.map