@aura3d/engine 1.0.3 → 1.0.5

package/dist/engine/agent-api/game-kits/index.js

@@ -0,0 +1,6 @@
+import { fighting } from "./fighting.js";
+export * from "./fighting.js";
+export const gameKits = {
+    fighting
+};
+//# sourceMappingURL=index.js.map

package/dist/engine/agent-api/game-kits/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../packages/engine/src/agent-api/game-kits/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,cAAc,YAAY,CAAC;AAE3B,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,QAAQ;CACA,CAAC"}

package/dist/engine/agent-api/humanoid-walk-runtime.d.ts

@@ -14,6 +14,7 @@ export declare const character: {
     readonly lowPolyHumanoid: (options?: import("./index.js").AuraPrimitiveHumanoidPrefabOptions) => readonly import("./index.js").AuraSceneNode[];
     readonly authoredHumanoid: (options?: import("./index.js").AuraPrimitiveHumanoidPrefabOptions) => readonly import("./index.js").AuraSceneNode[];
     readonly primitiveHumanoid: (options?: import("./index.js").AuraPrimitiveHumanoidPrefabOptions) => readonly import("./index.js").AuraSceneNode[];
+    readonly performance: typeof import("./CartoonPerformance.js").createCartoonPerformance;
     readonly importedRigRuntime: (options: import("@aura3d/assets").GLTFSceneAnimationRuntimeOptions) => Promise<import("@aura3d/assets").GLTFSceneAnimationRuntime>;
     readonly visualQA: (nodes: readonly import("./index.js").AuraSceneNode[]) => import("./index.js").AuraCharacterVisualQAResult;
     readonly validatePrimitiveHumanoid: (nodes: readonly import("./index.js").AuraSceneNode[]) => import("./index.js").AuraCharacterVisualQAResult;

package/dist/engine/agent-api/humanoid-walk-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"humanoid-walk-runtime.d.ts","sourceRoot":"","sources":["../../../../../packages/engine/src/agent-api/humanoid-walk-runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,OAAO,EACP,aAAa,EACb,oBAAoB,EACrB,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,gBAAgB,GAAG,MAAM,CAAC;CAC1G;AAED,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,CAAC;AACjD,MAAM,MAAM,oBAAoB,GAAG,YAAY,CAAC;AAEhD,eAAO,MAAM,SAAS;;;;;;;;;;;CAAgB,CAAC;AAEvC,eAAO,MAAM,SAAS;sCACE,mBAAmB,KAAQ,oBAAoB;CAG7D,CAAC;AAEX,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,oBAAoB,CAEpF"}
+{"version":3,"file":"humanoid-walk-runtime.d.ts","sourceRoot":"","sources":["../../../../../packages/engine/src/agent-api/humanoid-walk-runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,OAAO,EACP,aAAa,EACb,oBAAoB,EACrB,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,gBAAgB,GAAG,MAAM,CAAC;CAC1G;AAED,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,CAAC;AACjD,MAAM,MAAM,oBAAoB,GAAG,YAAY,CAAC;AAEhD,eAAO,MAAM,SAAS;;;;;;;;;;;;CAAgB,CAAC;AAEvC,eAAO,MAAM,SAAS;sCACE,mBAAmB,KAAQ,oBAAoB;CAG7D,CAAC;AAEX,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,oBAAoB,CAEpF"}

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

@@ -1,6 +1,46 @@
 import { type Collider, type ColliderDescriptor, type CollisionEvent, type Constraint, type ConstraintDescriptor, type Contact, type DebugLine, type PhysicsBackendSelection, type PhysicsShape, type PhysicsSnapshot, type PhysicsWorldDescriptor, type RaycastHit, type RaycastOptions, type RigidBody, type RigidBodyDescriptor, type RigidBodyType, type ScenePhysicsNode, type SphereCastHit } from "@aura3d/physics";
 import type { GLTFSceneAnimationRuntime, GLTFSceneAnimationRuntimeOptions } from "@aura3d/assets/browser";
+import type { AnimationPose } from "@aura3d/animation";
+import type { GameHudBindingKind, GameRuntimeSubsystemOwnership } from "./GameRuntime";
+import { createFrameLoop } from "./FrameLoop";
+import { createCombatWorld, createGameCameraDirector, createGameEffects, applyGameCombatEventsToRuntime, createGameAccessibilityFocus, createGameAccessibilityLabel, createGameAccessibilityRuntimeSettings, createGameHighContrastSource, createGameHudBindings, createGameHudComboBinding, createGameHudDebugToggleBinding, createGameHudHealthBinding, createGameHudMeterBinding, createGameHudRoundBinding, createGameHudSnapshot, createGameHudTimerBinding, createGameBoxCollider, createGameCapsuleCollider, createGameColliderDebugGeometry, createGameCombatDebugGeometry, createGameDebugOverlayData, createGameDebugSceneNodes, createGameHitboxDebugGeometry, createGameFighting2DRules, createGameInput, createGameInputReplay, createGameInputReplayDriver, createGameJumpAssist, createGameKinematicBody, createGamePauseControlsSource, createGameRectCollider, createGameReducedFlashSource, createGameReducedMotionSource, createGameSphereCollider, createGameTouchControlLayout, gameColliderAabb, gameInputReplayEventsAt, type GameInputOptions } from "./GameRuntime";
+import { collectGameRuntimeEvidence as collectGameRuntimeEvidenceV105, type GameRuntimeEvidence, type GameRuntimeEvidenceOptions, type GameRuntimeSourceEvidence } from "./GameEvidence";
+import { type AuraRuntimeNodeAnimationPoseBindingMetadata, type AuraRuntimeNodeAnimationBindingMetadata, type AuraRuntimeNodeBounds, type AuraRuntimeNodeEffectAttachment, type RuntimeNodeMorphTargetWeights } from "./RuntimeNodeHandle";
+import { createRuntimeNodeSpec } from "./GameSceneBridge";
+import { createFightingGameKit } from "./game-kits/fighting";
+import { createPromptAnimationEpisodePlan, createPromptAnimationStoryBible, definePromptAnimationStoryboard } from "./PromptAnimationContract";
+import { applyShotPlaybackFrame, createShotPlaybackPlan, createShotTimeline, installShotPlayback, sampleShotPlaybackPlan } from "./ShotTimeline";
+import { captionCueAtTime, createCaptionTimingProof, deriveCaptionTrackFromDialogue } from "./DialoguePerformance";
+import { createAuraVoiceVisemeTrack, createGlbBlendshapeVisemeCue, createPrimitiveMouthVisemeCues, sampleVisemeTrack } from "./VisemeController";
+import { createAuraVoiceBridgePackage, createAuraVoiceDubRerenderProof, createAuraVoiceRerenderPlan, sampleAuraVoiceBridgeAtTime } from "./AuraVoiceBridge";
+import { createCartoonDirectorPlan } from "./CartoonDirector";
+import { createCartoonPerformance } from "./CartoonPerformance";
+import { createCartoonRenderOutputPackageMetadata, createCartoonRenderQueue } from "./CartoonRenderQueue";
+import { collectPromptAnimationEvidence } from "./PromptAnimationEvidence";
 export { Engine } from "@aura3d/core";
+export { asAuraAppHandle, isAuraAppHandle, type AuraAppFrame, type AuraAppFrameCallback, type AuraAppHandle, type AuraAppNodeRegistryLike, type AuraAppRuntimeState, type AuraAppScreenshot } from "./AuraAppHandle";
+export { FrameLoop, createFrameLoop, type FrameLoopCallback, type FrameLoopFrame, type FrameLoopOptions, type FrameLoopSnapshot, type FrameLoopSource } from "./FrameLoop";
+export { createCombatWorld, createGameCameraDirector, createGameEffects, applyGameCombatEventsToRuntime, createGameAccessibilityFocus, createGameAccessibilityLabel, createGameAccessibilityRuntimeSettings, createGameHighContrastSource, createGameHudBindings, createGameHudComboBinding, createGameHudDebugToggleBinding, createGameHudHealthBinding, createGameHudMeterBinding, createGameHudRoundBinding, createGameHudSnapshot, createGameHudTimerBinding, createGameBoxCollider, createGameCapsuleCollider, createGameColliderDebugGeometry, createGameCombatDebugGeometry, createGameDebugOverlayData, createGameDebugSceneNodes, createGameHitboxDebugGeometry, createGameInput, createGameInputReplay, createGameInputReplayDriver, createGameJumpAssist, createGameKinematicBody, createGamePauseControlsSource, createGameRectCollider, createGameReducedFlashSource, createGameReducedMotionSource, createGameSphereCollider, createGameTouchControlLayout, gameColliderAabb, gameColliders, gameInputReplayEventsAt, createGameLoopPlan, type GameAccessibilityFocusOptions, type GameAccessibilityLabelOptions, type GameAccessibilityPauseControlsOptions, type GameAccessibilityPreferenceOptions, type GameAccessibilityRuntimeSettings, type GameAccessibilityRuntimeSettingsOptions, type GameAccessibilitySource, type GameAccessibilitySourceKind, type GameAabb, type GameBounds3, type GameCameraDirector, type GameCameraDirectorOptions, type GameCameraSnapshot, type GameCameraTarget, type GameCollisionBox, type GameCombatActorOptions, type GameCombatActorSnapshot, type GameCombatActiveAttackSnapshot, type GameCombatEvent, type GameCombatEventRuntimeBridgeOptions, type GameCombatEventRuntimeBridgeResult, type GameCombatEventType, type GameCombatMove, type GameCombatWorld, type GameCombatWorldSnapshot, type GameBoxCollider, type GameBoxColliderOptions, type GameCapsuleCollider, type GameCapsuleColliderOptions, type GameCollider, type GameColliderAxis, type GameColliderBase, type GameColliderDimension, type GameColliderFactoryOptions, type GameColliderKind, type GameColliderPlane, type GameDebugGeometryNode, type GameDebugGeometryOptions, type GameDebugGeometryPrimitive, type GameDebugOverlayData, type GameDebugOverlayMetric, type GameDebugOverlayOptions, type GameDebugOverlaySection, type GameDebugSceneNode, type GameDebugSceneNodeOptions, type GameDebugScenePrimitive, type GameEffectInstance, type GameEffectAttachment, type GameEffectKind, type GameEffectOptions, type GameEffectsController, type GameEffectsSnapshot, type GameHudActorBindingOptions, type GameHudBinding, type GameHudBindingKind, type GameHudComboBindingOptions, type GameHudDebugToggleBindingOptions, type GameHudResolvedValue, type GameHudRoundBindingOptions, type GameHudSourceKind, type GameHudSnapshot, type GameHudSnapshotItem, type GameHudSnapshotOptions, type GameHudTimerBindingOptions, type GameHudValueFormat, type GameInputActionState, type GameInputAxisSettings, type GameInputAxisBinding, type GameInputController, type GameInputOptions, type GameInputReplayDriver, type GameInputReplayDriverSnapshot, type GameInputReplayEvent, type GameInputReplayOptions, type GameInputReplayPlan, type GameInputSnapshot, type GameJumpAssistController, type GameJumpAssistOptions, type GameJumpAssistSnapshot, type GameJumpAssistUpdate, type GameKinematicBody, type GameKinematicBodyOptions, type GameKinematicBodySnapshot, type GameLoopPlan, type GamePointerSnapshot, type GameRectCollider, type GameRectColliderOptions, type GameRuntimeSubsystemId, type GameRuntimeSubsystemOwnership, type GameSphereCollider, type GameSphereColliderOptions, type GameSubsystemOwner, type GameTouchControlAnchor, type GameTouchControlKind, type GameTouchControlLayout, type GameTouchControlLayoutOptions, type GameTouchControlRegion, type GameTouchControlRequest, type GameVec3, type GamepadSnapshot } from "./GameRuntime";
+export { collectGameSceneRuntimeNodes, createGameSceneBridge, createRuntimeNodeSpec, type GameSceneBridge, type GameSceneBridgeApp, type GameSceneBridgeBodyLike, type GameSceneBridgeEvidence, type GameSceneBridgeNodeHandle, type GameSceneRuntimeNode } from "./GameSceneBridge";
+export { calculateRuntimeNodeBounds, createRuntimeNodeEffectAttachment, runtimeNodeHasTag, type AuraRuntimeNodeAnimationPoseBindingMetadata, type AuraRuntimeNodeAnimationBindingMetadata, type AuraRuntimeNodeBounds, type AuraRuntimeNodeEffectAttachment, type AuraRuntimeNodeEffectKind, type RuntimeNodeAnimationSpecLike, type RuntimeNodeBoundsInput, type RuntimeNodeHandleLike, type RuntimeNodeMorphTargetWeights, type RuntimeNodeVec3 } from "./RuntimeNodeHandle";
+export { createFightingGameKit, fighting, fighterRuntimeNode, type FightingActorState, type FightingControls, type FightingGameKit, type FightingGameKitOptions, type FightingGameSnapshot, type FightingStageOptions } from "./game-kits/fighting";
+export { gameKits } from "./game-kits";
+export type { GameRuntimeEvidence, GameRuntimeEvidenceApp, GameRuntimeEvidenceOptions, GameRuntimeSourceEvidence } from "./GameEvidence";
+export * from "./GameAssetValidation.js";
+export * from "./CharacterAssembly.js";
+export * from "./AssetEvidence.js";
+export * from "./AnimationController.js";
+export { gameAssetValidation, quaterniusGameReadyFighterValidationContract, validateQuaterniusGameReadyFighterAsset } from "./GameAssetValidation.js";
+export { createAnimationController } from "./AnimationController.js";
+export * from "./PromptAnimationContract.js";
+export * from "./AuraVoiceBridge.js";
+export * from "./ShotTimeline.js";
+export * from "./DialoguePerformance.js";
+export * from "./VisemeController.js";
+export * from "./PromptAnimationEvidence.js";
+export * from "./CartoonDirector.js";
+export * from "./CartoonPerformance.js";
+export * from "./CartoonRenderQueue.js";
 export type AuraVec3 = readonly [number, number, number];
 export type AuraColor = `#${string}` | string;
 export type AuraAssetType = "model" | "texture" | "environment" | "audio";
@@ -160,6 +200,7 @@ export interface AuraPrimitiveOptions extends AuraTransformSpec {
 export interface AuraAnimationSpec {
     readonly clip?: string;
     readonly loop?: boolean;
+    readonly restart?: boolean;
     readonly speed?: number;
     readonly startTime?: number;
     readonly duration?: number;
@@ -173,6 +214,11 @@ export interface AuraAnimationSpec {
     readonly rootBob?: boolean;
     readonly jointHierarchy?: boolean;
 }
+export interface AuraRuntimeNodeSpec {
+    readonly id: string;
+    readonly tags?: readonly string[];
+    readonly mutable?: boolean;
+}
 export interface AuraInteractionSpec {
     readonly cursor?: string;
     readonly onClick?: string;
@@ -283,6 +329,7 @@ export interface AuraModelNode extends AuraTransformSpec {
     readonly animation?: AuraAnimationSpec;
     readonly interaction?: AuraInteractionSpec;
     readonly physics?: AuraNodePhysicsSpec;
+    readonly runtime?: AuraRuntimeNodeSpec;
 }
 export interface AuraPrimitiveNode extends AuraTransformSpec {
     readonly kind: "primitive";
@@ -295,6 +342,7 @@ export interface AuraPrimitiveNode extends AuraTransformSpec {
     readonly animation?: AuraAnimationSpec;
     readonly interaction?: AuraInteractionSpec;
     readonly physics?: AuraNodePhysicsSpec;
+    readonly runtime?: AuraRuntimeNodeSpec;
 }
 export interface AuraGroupNode extends AuraTransformSpec {
     readonly kind: "group";
@@ -302,6 +350,7 @@ export interface AuraGroupNode extends AuraTransformSpec {
     readonly children: readonly AuraSceneNode[];
     readonly animation?: AuraAnimationSpec;
     readonly character?: AuraCharacterRigSpec;
+    readonly runtime?: AuraRuntimeNodeSpec;
 }
 export type AuraLightType = "ambient" | "directional" | "point" | "studio" | "rect" | "softbox";
 export interface AuraLightNode extends AuraTransformSpec {
@@ -369,6 +418,7 @@ export interface AuraLabelNode extends AuraTransformSpec {
     readonly occlusionAware?: boolean;
     readonly collisionAvoidance?: boolean;
     readonly animation?: AuraAnimationSpec;
+    readonly runtime?: AuraRuntimeNodeSpec;
 }
 export interface AuraEnvironmentNode {
     readonly kind: "environment";
@@ -570,6 +620,9 @@ export declare class AuraNodeBuilder<TNode extends AuraSceneNode> {
     physics(spec: AuraNodePhysicsSpec): AuraNodeBuilder<TNode & {
         readonly physics: AuraNodePhysicsSpec;
     }>;
+    runtime(spec: AuraRuntimeNodeSpec): AuraNodeBuilder<TNode & {
+        readonly runtime: AuraRuntimeNodeSpec;
+    }>;
     toJSON(): TNode;
     private with;
 }
@@ -1164,8 +1217,339 @@ export declare const games: {
     readonly miniGolfCourse: () => readonly AuraSceneNode[];
     readonly createMiniGolfState: () => AuraMiniGolfStateController;
     readonly miniGolfPointerShot: typeof miniGolfPointerShotFromDrag;
+    readonly fighting: {
+        readonly controls: typeof import("./game-kits").defaultFightingControls;
+        readonly moves: typeof import("./game-kits").defaultFightingMoves;
+        readonly runtimeNode: typeof import("./game-kits").fighterRuntimeNode;
+        readonly stagePreset: typeof import("./game-kits").fightingStagePreset;
+        readonly stagePresets: Record<import("./game-kits").FightingStagePresetName, import("./game-kits").FightingStageOptions>;
+        readonly stage: typeof import("./game-kits").createFightingStage;
+        readonly validateStage: typeof import("./game-kits").validateFightingStage;
+        readonly stageNodes: typeof import("./game-kits").fightingStageNodes;
+        readonly createKit: typeof createFightingGameKit;
+    };
+    readonly createFightingGameKit: typeof createFightingGameKit;
     readonly miniGolfScene: () => AuraSceneBuilder;
 };
+export interface AuraGameLoopPlan {
+    readonly kind: "aura-game-loop-plan";
+    readonly fixedDt: number;
+    readonly maxSubSteps: number;
+    readonly timeScale: number;
+}
+export interface AuraGameInputPlan {
+    readonly kind: "aura-game-input-plan";
+    readonly actions: Record<string, readonly string[]>;
+    readonly axes: Record<string, AuraGameInputAxisBinding>;
+    readonly bufferMs: number;
+}
+export interface AuraGameInputAxisBinding {
+    readonly negative?: string;
+    readonly positive?: string;
+}
+export interface AuraGameInputActionState {
+    readonly pressed: boolean;
+    readonly held: boolean;
+    readonly released: boolean;
+    readonly buffered: boolean;
+    readonly value: number;
+}
+export interface AuraGameInputReplayEvent {
+    readonly frame: number;
+    readonly time: number;
+    readonly type: "press" | "release";
+    readonly binding: string;
+}
+export interface AuraGameInputSnapshot {
+    readonly kind: "aura-game-input-snapshot";
+    readonly frame: number;
+    readonly time: number;
+    readonly activeBindings: readonly string[];
+    readonly actions: Record<string, AuraGameInputActionState>;
+}
+export interface AuraGameInputController extends AuraGameInputPlan {
+    update(dt?: number): AuraGameInputSnapshot;
+    snapshot(): AuraGameInputSnapshot;
+    pressed(action: string): boolean;
+    held(action: string): boolean;
+    released(action: string): boolean;
+    buffered(action: 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 AuraGameInputReplayEvent[];
+    replay(events: readonly AuraGameInputReplayEvent[]): AuraGameInputSnapshot;
+    clearReplay(): void;
+    dispose(): void;
+}
+export interface AuraGameRuntimeEvidence {
+    readonly kind: "aura-game-runtime-evidence";
+    readonly source?: GameRuntimeSourceEvidence;
+    readonly ownership?: readonly GameRuntimeSubsystemOwnership[];
+    readonly loop: {
+        readonly frame: number;
+        readonly time: number;
+        readonly paused: boolean;
+    };
+    readonly runtimeNodes: {
+        readonly count: number;
+        readonly ids: readonly string[];
+    };
+    readonly systems: {
+        readonly mutableNodes: boolean;
+        readonly frameLoop: boolean;
+        readonly inputPlan: boolean;
+        readonly physicsPlan: boolean;
+        readonly animationPlan: boolean;
+        readonly effectsPlan: boolean;
+        readonly cameraPlan: boolean;
+        readonly collisionPlan?: boolean;
+        readonly stagePlan?: boolean;
+    };
+    readonly input?: {
+        readonly configured: boolean;
+        readonly actions: readonly string[];
+        readonly axes: readonly string[];
+        readonly activeBindings: readonly string[];
+        readonly frame: number;
+    };
+    readonly physics?: {
+        readonly kinematicBodies: number;
+        readonly groundedBodies: number;
+    };
+    readonly collision?: {
+        readonly combatWorld: boolean;
+        readonly actors: number;
+        readonly activeAttacks: number;
+        readonly events: number;
+    };
+    readonly animation?: {
+        readonly controllers: number;
+        readonly activeClips: readonly string[];
+        readonly eventCount: number;
+    };
+    readonly effects?: {
+        readonly active: number;
+        readonly spawned: number;
+        readonly pooled: number;
+    };
+    readonly camera?: {
+        readonly active: boolean;
+        readonly fov?: number;
+        readonly zoom?: number;
+        readonly shake?: number;
+        readonly reducedMotion?: boolean;
+    };
+    readonly assets?: {
+        readonly typedAssets: number;
+        readonly missingAssets: readonly string[];
+    };
+    readonly stage?: {
+        readonly id?: string;
+        readonly safeZones: boolean;
+        readonly bounds?: unknown;
+        readonly warnings: readonly string[];
+    };
+    readonly hud?: {
+        readonly bindings: number;
+        readonly kinds: readonly GameHudBindingKind[];
+        readonly targetIds: readonly string[];
+        readonly debugToggles: number;
+        readonly interactive: number;
+        readonly warnings: readonly string[];
+    };
+    readonly accessibility?: {
+        readonly sources: number;
+        readonly labels: number;
+        readonly focusScopes: number;
+        readonly reducedMotion: boolean;
+        readonly reducedFlash: boolean;
+        readonly highContrast: boolean;
+        readonly pauseControls: boolean;
+        readonly warnings: readonly string[];
+    };
+    readonly warnings?: readonly string[];
+}
+export declare function collectGameRuntimeEvidence(app: Pick<AuraApp, "runtime" | "nodes">, options?: GameRuntimeEvidenceOptions): AuraGameRuntimeEvidence;
+export interface AuraGameRules {
+    readonly kind: "aura-game-rules";
+    readonly gravity: number;
+    readonly roundSeconds: number;
+    readonly maxHealth: number;
+    readonly maxGuard: number;
+    readonly maxMeter: number;
+    readonly stageBounds: {
+        readonly minX: number;
+        readonly maxX: number;
+    };
+}
+export interface AuraGameRuntimeOptions {
+    readonly loop?: Partial<Omit<AuraGameLoopPlan, "kind">> | undefined;
+    readonly input?: GameInputOptions | undefined;
+    readonly rules?: Partial<Omit<AuraGameRules, "kind">> | undefined;
+    readonly effectPoolSize?: number | undefined;
+}
+export interface AuraGameRuntime {
+    readonly kind: "aura-game-runtime";
+    readonly loop: AuraGameLoopPlan;
+    readonly rules: AuraGameRules;
+    readonly input?: ReturnType<typeof createGameInput> | undefined;
+    readonly combat: ReturnType<typeof createCombatWorld>;
+    readonly camera: ReturnType<typeof createGameCameraDirector>;
+    readonly effects: ReturnType<typeof createGameEffects>;
+    readonly bodies: readonly ReturnType<typeof createGameKinematicBody>[];
+}
+export declare function createAuraGameRules(options?: Partial<Omit<AuraGameRules, "kind">>): AuraGameRules;
+export declare const gameRules: typeof createAuraGameRules & {
+    fighting2D: typeof createGameFighting2DRules;
+};
+export declare function createAuraGameRuntime(options?: AuraGameRuntimeOptions): AuraGameRuntime;
+export declare const game: {
+    readonly createRuntime: typeof createAuraGameRuntime;
+    readonly rules: typeof createAuraGameRules & {
+        fighting2D: typeof createGameFighting2DRules;
+    };
+    readonly loop: (options?: Partial<Omit<AuraGameLoopPlan, "kind">>) => AuraGameLoopPlan;
+    readonly frameLoop: typeof createFrameLoop;
+    readonly runtimeNode: typeof createRuntimeNodeSpec;
+    readonly input: typeof createGameInput;
+    readonly inputReplay: typeof createGameInputReplay;
+    readonly inputReplayDriver: typeof createGameInputReplayDriver;
+    readonly inputReplayEventsAt: typeof gameInputReplayEventsAt;
+    readonly touchControls: typeof createGameTouchControlLayout;
+    readonly kinematicBody: typeof createGameKinematicBody;
+    readonly jumpAssist: typeof createGameJumpAssist;
+    readonly collider: {
+        readonly box: typeof createGameBoxCollider;
+        readonly sphere: typeof createGameSphereCollider;
+        readonly capsule: typeof createGameCapsuleCollider;
+        readonly rect: typeof createGameRectCollider;
+        readonly aabb: typeof gameColliderAabb;
+        readonly factories: {
+            readonly box: typeof createGameBoxCollider;
+            readonly sphere: typeof createGameSphereCollider;
+            readonly capsule: typeof createGameCapsuleCollider;
+            readonly rect: typeof createGameRectCollider;
+        };
+    };
+    readonly hitbox: {
+        readonly rect: typeof import("./GameRuntime").createGameHitboxRect;
+        readonly box: typeof import("./GameRuntime").createGameHitboxRect;
+    };
+    readonly hurtbox: {
+        readonly rect: typeof import("./GameRuntime").createGameHurtboxRect;
+        readonly box: typeof import("./GameRuntime").createGameHurtboxRect;
+    };
+    readonly guardbox: {
+        readonly rect: typeof import("./GameRuntime").createGameGuardboxRect;
+        readonly box: typeof import("./GameRuntime").createGameGuardboxRect;
+    };
+    readonly pushbox: {
+        readonly rect: typeof import("./GameRuntime").createGamePushboxRect;
+        readonly box: typeof import("./GameRuntime").createGamePushboxRect;
+    };
+    readonly trigger: {
+        readonly box: (options?: import("./GameRuntime").GameBoxColliderOptions) => import("./GameRuntime").GameBoxCollider;
+        readonly sphere: (options?: import("./GameRuntime").GameSphereColliderOptions) => import("./GameRuntime").GameSphereCollider;
+        readonly capsule: (options?: import("./GameRuntime").GameCapsuleColliderOptions) => import("./GameRuntime").GameCapsuleCollider;
+        readonly rect: (options?: import("./GameRuntime").GameRectColliderOptions) => import("./GameRuntime").GameRectCollider;
+    };
+    readonly combatWorld: typeof createCombatWorld;
+    readonly combatEvents: typeof applyGameCombatEventsToRuntime;
+    readonly cameraDirector: typeof createGameCameraDirector;
+    readonly effects: typeof createGameEffects;
+    readonly effectPresets: {
+        readonly hitSpark: (options?: import("./GameRuntime").GameEffectOptions) => import("./GameRuntime").GameEffectPreset;
+        readonly blockSpark: (options?: import("./GameRuntime").GameEffectOptions) => import("./GameRuntime").GameEffectPreset;
+        readonly groundDust: (options?: import("./GameRuntime").GameEffectOptions) => import("./GameRuntime").GameEffectPreset;
+        readonly dashTrail: (options?: import("./GameRuntime").GameEffectOptions) => import("./GameRuntime").GameEffectPreset;
+        readonly slashTrail: (options?: import("./GameRuntime").GameEffectOptions) => import("./GameRuntime").GameEffectPreset;
+        readonly shockwave: (options?: import("./GameRuntime").GameEffectOptions) => import("./GameRuntime").GameEffectPreset;
+        readonly auraBurst: (options?: import("./GameRuntime").GameEffectOptions) => import("./GameRuntime").GameEffectPreset;
+        readonly superBurst: (options?: import("./GameRuntime").GameEffectOptions) => import("./GameRuntime").GameEffectPreset;
+    };
+    readonly debug: {
+        readonly colliders: typeof createGameColliderDebugGeometry;
+        readonly hitboxes: typeof createGameHitboxDebugGeometry;
+        readonly combat: typeof createGameCombatDebugGeometry;
+        readonly overlay: typeof createGameDebugOverlayData;
+        readonly sceneNodes: typeof createGameDebugSceneNodes;
+    };
+    readonly hud: {
+        readonly health: typeof createGameHudHealthBinding;
+        readonly meter: typeof createGameHudMeterBinding;
+        readonly timer: typeof createGameHudTimerBinding;
+        readonly combo: typeof createGameHudComboBinding;
+        readonly round: typeof createGameHudRoundBinding;
+        readonly debugToggle: typeof createGameHudDebugToggleBinding;
+        readonly bindings: typeof createGameHudBindings;
+        readonly snapshot: typeof createGameHudSnapshot;
+    };
+    readonly accessibility: {
+        readonly label: typeof createGameAccessibilityLabel;
+        readonly focus: typeof createGameAccessibilityFocus;
+        readonly reducedMotion: typeof createGameReducedMotionSource;
+        readonly reducedFlash: typeof createGameReducedFlashSource;
+        readonly highContrast: typeof createGameHighContrastSource;
+        readonly pauseControls: typeof createGamePauseControlsSource;
+        readonly settings: typeof createGameAccessibilityRuntimeSettings;
+    };
+    readonly fighting: typeof createFightingGameKit;
+    readonly evidence: typeof collectGameRuntimeEvidence;
+};
+export declare const cartoon: {
+    readonly episodePlan: typeof createPromptAnimationEpisodePlan;
+    readonly storyBible: typeof createPromptAnimationStoryBible;
+    readonly storyboard: typeof definePromptAnimationStoryboard;
+    readonly shotTimeline: typeof createShotTimeline;
+    readonly shotPlaybackPlan: typeof createShotPlaybackPlan;
+    readonly sampleShotPlaybackPlan: typeof sampleShotPlaybackPlan;
+    readonly applyShotPlaybackFrame: typeof applyShotPlaybackFrame;
+    readonly installShotPlayback: typeof installShotPlayback;
+    readonly captionsFromDialogue: typeof deriveCaptionTrackFromDialogue;
+    readonly captionCueAtTime: typeof captionCueAtTime;
+    readonly captionTimingProof: typeof createCaptionTimingProof;
+    readonly visemeTrack: typeof createAuraVoiceVisemeTrack;
+    readonly primitiveMouthVisemes: typeof createPrimitiveMouthVisemeCues;
+    readonly glbBlendshapeViseme: typeof createGlbBlendshapeVisemeCue;
+    readonly sampleVisemeTrack: typeof sampleVisemeTrack;
+    readonly auraVoiceBridgePackage: typeof createAuraVoiceBridgePackage;
+    readonly sampleAuraVoiceBridgeAtTime: typeof sampleAuraVoiceBridgeAtTime;
+    readonly auraVoiceRerenderPlan: typeof createAuraVoiceRerenderPlan;
+    readonly auraVoiceDubRerenderProof: typeof createAuraVoiceDubRerenderProof;
+    readonly director: typeof createCartoonDirectorPlan;
+    readonly performance: typeof createCartoonPerformance;
+    readonly renderQueue: typeof createCartoonRenderQueue;
+    readonly renderOutputPackage: typeof createCartoonRenderOutputPackageMetadata;
+    readonly evidence: typeof collectPromptAnimationEvidence;
+};
+export declare const animationStudio: {
+    readonly episodePlan: typeof createPromptAnimationEpisodePlan;
+    readonly storyBible: typeof createPromptAnimationStoryBible;
+    readonly storyboard: typeof definePromptAnimationStoryboard;
+    readonly shotTimeline: typeof createShotTimeline;
+    readonly shotPlaybackPlan: typeof createShotPlaybackPlan;
+    readonly sampleShotPlaybackPlan: typeof sampleShotPlaybackPlan;
+    readonly applyShotPlaybackFrame: typeof applyShotPlaybackFrame;
+    readonly installShotPlayback: typeof installShotPlayback;
+    readonly captionsFromDialogue: typeof deriveCaptionTrackFromDialogue;
+    readonly captionCueAtTime: typeof captionCueAtTime;
+    readonly captionTimingProof: typeof createCaptionTimingProof;
+    readonly visemeTrack: typeof createAuraVoiceVisemeTrack;
+    readonly primitiveMouthVisemes: typeof createPrimitiveMouthVisemeCues;
+    readonly glbBlendshapeViseme: typeof createGlbBlendshapeVisemeCue;
+    readonly sampleVisemeTrack: typeof sampleVisemeTrack;
+    readonly auraVoiceBridgePackage: typeof createAuraVoiceBridgePackage;
+    readonly sampleAuraVoiceBridgeAtTime: typeof sampleAuraVoiceBridgeAtTime;
+    readonly auraVoiceRerenderPlan: typeof createAuraVoiceRerenderPlan;
+    readonly auraVoiceDubRerenderProof: typeof createAuraVoiceDubRerenderProof;
+    readonly director: typeof createCartoonDirectorPlan;
+    readonly performance: typeof createCartoonPerformance;
+    readonly renderQueue: typeof createCartoonRenderQueue;
+    readonly renderOutputPackage: typeof createCartoonRenderOutputPackageMetadata;
+    readonly evidence: typeof collectPromptAnimationEvidence;
+};
 declare function collectParticleBudgetDiagnostics(nodes: readonly AuraSceneNode[]): AuraParticleBudgetDiagnostics;
 export declare const particles: {
     readonly materialModes: () => readonly AuraParticleMaterialMode[];
@@ -1207,6 +1591,7 @@ export declare const character: {
     readonly lowPolyHumanoid: (options?: AuraPrimitiveHumanoidPrefabOptions) => readonly AuraSceneNode[];
     readonly authoredHumanoid: (options?: AuraPrimitiveHumanoidPrefabOptions) => readonly AuraSceneNode[];
     readonly primitiveHumanoid: (options?: AuraPrimitiveHumanoidPrefabOptions) => readonly AuraSceneNode[];
+    readonly performance: typeof createCartoonPerformance;
     readonly importedRigRuntime: (options: GLTFSceneAnimationRuntimeOptions) => Promise<GLTFSceneAnimationRuntime>;
     readonly visualQA: typeof validatePrimitiveHumanoidVisualQA;
     readonly validatePrimitiveHumanoid: typeof validatePrimitiveHumanoidVisualQA;
@@ -1420,10 +1805,30 @@ export type AuraPromptEffectId = "rain" | "fog" | "bloom" | "particles" | "wet-r
 export type AuraPromptCameraPreset = "product-orbit" | "cinematic-dolly" | "game-board" | "material-inspection";
 export type AuraPromptLightingPreset = "studio-softbox" | "neon-practicals" | "game-readable" | "material-studio";
 export type AuraPromptInteractionMode = "orbit" | "keyboard" | "pointer";
-export interface AuraPromptPlanSubject {
+export interface AuraPromptResolvedSubject {
     readonly asset: AuraAssetRef<"model">;
     readonly label?: string;
 }
+export interface AuraPromptIntentSubject {
+    readonly intent: string;
+    readonly constraints?: {
+        readonly maxTriangles?: number;
+        readonly license?: readonly ("CC0" | "CC-BY")[];
+        readonly animated?: boolean;
+    };
+    readonly label?: string;
+}
+export type AuraPromptPlanSubject = AuraPromptResolvedSubject | AuraPromptIntentSubject;
+export declare function promptSubjectIsResolved(s: AuraPromptPlanSubject): s is AuraPromptResolvedSubject;
+export interface AuraPromptSubjectResolver {
+    resolve(query: {
+        text: string;
+        constraints?: AuraPromptIntentSubject["constraints"];
+    }): Promise<{
+        asset: AuraAssetRef<"model">;
+    } | null>;
+}
+export declare function resolvePromptPlanSubject(plan: AuraPromptPlan, resolver: AuraPromptSubjectResolver): Promise<AuraPromptPlan>;
 export interface AuraPromptPlan {
     readonly sceneType: AuraPromptSceneType;
     readonly subject: AuraPromptPlanSubject;
@@ -1538,15 +1943,96 @@ export interface AuraSceneEvidence {
         readonly helperCount: number;
         readonly nodeBudgetExceeded: readonly AuraHelperBudgetId[];
     };
+    readonly gameRuntime: GameRuntimeEvidence;
     readonly rendering: AuraRendererDiagnosticReport;
     readonly assets: readonly AuraAssetProvenance[];
 }
+export interface AuraFrameInfo {
+    readonly dt: number;
+    readonly fixedDt: number;
+    readonly time: number;
+    readonly frame: number;
+    readonly alpha: number;
+    readonly paused: boolean;
+    readonly source: "raf" | "manual" | "fixed";
+    readonly substep: number;
+    readonly substeps: number;
+}
+export type AuraFrameCallback = (frame: AuraFrameInfo) => void;
+export interface AuraRuntimeNodeSnapshot {
+    readonly id: string;
+    readonly kind: AuraSceneNode["kind"];
+    readonly name?: string;
+    readonly tags: readonly string[];
+    readonly position: AuraVec3;
+    readonly rotation: AuraVec3;
+    readonly scale: number | AuraVec3;
+    readonly visible: boolean;
+    readonly animation?: AuraAnimationSpec;
+    readonly animationBinding?: AuraRuntimeNodeAnimationBindingMetadata;
+    readonly animationPose?: AnimationPose;
+    readonly animationPoseBinding?: AuraRuntimeNodeAnimationPoseBindingMetadata;
+    readonly morphTargets?: RuntimeNodeMorphTargetWeights;
+    readonly bounds?: AuraRuntimeNodeBounds;
+    readonly effects?: readonly AuraRuntimeNodeEffectAttachment[];
+}
+export interface AuraRuntimeNodeHandle {
+    readonly id: string;
+    readonly kind: AuraSceneNode["kind"];
+    readonly name?: string;
+    readonly tags: readonly string[];
+    position: AuraVec3;
+    rotation: AuraVec3;
+    scale: number | AuraVec3;
+    visible: boolean;
+    setPosition(x: number, y: number, z: number): this;
+    translate(x: number, y: number, z: number): this;
+    setRotation(x: number, y: number, z: number): this;
+    setScale(scale: number | AuraVec3): this;
+    setVisible(visible: boolean): this;
+    setMaterial(material: AuraMaterialSpec): this;
+    play(clip: string, options?: Omit<AuraAnimationSpec, "clip">): this;
+    setAnimation(animation: AuraAnimationSpec | undefined): this;
+    setAnimationBinding(binding: AuraRuntimeNodeAnimationBindingMetadata | undefined): this;
+    setAnimationPose(pose: AnimationPose | undefined, metadata?: AuraRuntimeNodeAnimationPoseBindingMetadata): this;
+    animationPose(): AnimationPose | undefined;
+    setMorphTarget(name: string, weight: number): this;
+    setMorphTargets(weights: RuntimeNodeMorphTargetWeights): this;
+    morphTargets(): RuntimeNodeMorphTargetWeights;
+    bounds(): AuraRuntimeNodeBounds;
+    attachEffect(effect: AuraRuntimeNodeEffectAttachment): this;
+    effects(): readonly AuraRuntimeNodeEffectAttachment[];
+    snapshot(): AuraRuntimeNodeSnapshot;
+}
+export interface AuraRuntimeNodeRegistry {
+    get(id: string): AuraRuntimeNodeHandle | undefined;
+    require(id: string): AuraRuntimeNodeHandle;
+    has(id: string): boolean;
+    ids(): readonly string[];
+    all(): readonly AuraRuntimeNodeHandle[];
+}
+export interface AuraRuntimeState {
+    readonly paused: boolean;
+    readonly frame: number;
+    readonly time: number;
+    readonly fixedDt: number;
+    readonly alpha: number;
+}
 export interface AuraApp {
     readonly canvas?: HTMLCanvasElement;
     readonly scene: AuraSceneSnapshot;
     readonly backend: AuraBackend;
+    readonly nodes: AuraRuntimeNodeRegistry;
+    readonly runtime: AuraRuntimeState;
     setScene(scene: AuraSceneBuilder | AuraSceneSnapshot): void;
+    onFrame(callback: AuraFrameCallback): () => void;
+    offFrame(callback: AuraFrameCallback): void;
+    input(options: GameInputOptions): ReturnType<typeof createGameInput>;
+    pause(): void;
+    resume(): void;
+    step(dt?: number): void;
     diagnostics(): AuraDiagnostics;
+    evidence(options?: GameRuntimeEvidenceOptions): ReturnType<typeof collectGameRuntimeEvidenceV105>;
     screenshot(): AuraScreenshot;
     dispose(): void;
 }