@zylem/game-lib 0.8.9 → 0.9.1

package/dist/api/game-lib.api.md

@@ -28,6 +28,7 @@ import { BoundaryRicochet3DEntity } from '@zylem/behaviors';
 import { BoundaryRicochetCoordinator } from '@zylem/behaviors';
 import { BoundaryRicochetEntity } from '@zylem/behaviors';
 import { BoundaryRicochetUpdate } from '@zylem/behaviors';
+import { Box3 } from 'three';
 import { BRIDGE_READY_EVENT } from '@zylem/bridge';
 import { BridgeChannel } from '@zylem/bridge';
 import { BridgeDebugTool } from '@zylem/bridge';
@@ -41,6 +42,7 @@ import { BridgeVec3 } from '@zylem/bridge';
 import { BufferGeometry } from 'three';
 import { BurstParticlePresetOptions } from '@zylem/behaviors';
 import { Camera } from 'three';
+import { CameraPosePayload } from '@zylem/bridge';
 import { clamp } from 'three/tsl';
 import { Color } from 'three';
 import { ColorRepresentation } from 'three';
@@ -78,6 +80,10 @@ import { createTopDownMovementInputComponent } from '@zylem/behaviors';
 import { createTopDownMovementStateComponent } from '@zylem/behaviors';
 import { createTransformComponent } from '@zylem/behaviors';
 import { createTransformStore } from '@zylem/behaviors/core';
+import { CutsceneLoadPayload } from '@zylem/bridge';
+import { CutscenePlaybackState } from '@zylem/bridge';
+import { CutsceneStatusPayload } from '@zylem/bridge';
+import { CutsceneViewPayload } from '@zylem/bridge';
 import { defineBehavior } from '@zylem/behaviors';
 import { DefineBehaviorConfig } from '@zylem/behaviors';
 import { Destructible3DBehavior } from '@zylem/behaviors';
@@ -366,6 +372,7 @@ import { ThrusterState } from '@zylem/behaviors';
 import { ThrusterStateComponent } from '@zylem/behaviors';
 import { tickCooldowns } from '@zylem/behaviors';
 import { time } from 'three/tsl';
+import * as ToneNs from 'tone';
 import { TopDownMovementBehavior } from '@zylem/behaviors';
 import { TopDownMovementBehaviorOptions } from '@zylem/behaviors';
 import { TopDownMovementComponent } from '@zylem/behaviors';
@@ -427,6 +434,9 @@ export interface Action {
     tick(entity: GameEntity<any>, delta: number): void;
 }
 
+// @public
+export function activeShot(definition: CutsceneDefinition, time: number): CameraShot | undefined;
+
 // @public (undocumented)
 export const ACTOR_TYPE: unique symbol;
 
@@ -471,6 +481,49 @@ export type AspectRatioValue = (typeof AspectRatio)[keyof typeof AspectRatio] |
 
 export { atan }
 
+// @public
+export function audibleTrackIds(tracks: readonly SongTrack[]): Set<string>;
+
+// @public (undocumented)
+export type AudioClip = Static<typeof AudioClipSchema>;
+
+// @public (undocumented)
+export const AudioClipSchema: _sinclair_typebox.TObject<{
+    kind: _sinclair_typebox.TLiteral<"audio">;
+    id: _sinclair_typebox.TString;
+    trackId: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    url: _sinclair_typebox.TString;
+    start: _sinclair_typebox.TNumber;
+    offset: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    length: _sinclair_typebox.TNumber;
+    gain: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+}>;
+
+// @public (undocumented)
+export type AudioItem = Static<typeof AudioItemSchema>;
+
+// @public (undocumented)
+export const AudioItemSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    time: _sinclair_typebox.TNumber;
+    kind: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"song">, _sinclair_typebox.TLiteral<"sfx">]>;
+    ref: _sinclair_typebox.TString;
+    loop: _sinclair_typebox.TBoolean;
+    volume: _sinclair_typebox.TNumber;
+}>;
+
+// Warning: (ae-forgotten-export) The symbol "AudioTrackSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type AudioTrack = Static<typeof AudioTrackSchema>;
+
+// @public
+export function beatsPerBar(signature: TimeSignature): number;
+
+// @public (undocumented)
+export function beatsToSeconds(beats: number, bpm: number): number;
+
 export { BehaviorDescriptor }
 
 export { BehaviorHandle }
@@ -605,6 +658,27 @@ export interface CameraFeedOptions {
     width?: number;
 }
 
+// @public (undocumented)
+export type CameraKeyframe = Static<typeof CameraKeyframeSchema>;
+
+// @public (undocumented)
+export const CameraKeyframeSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    time: _sinclair_typebox.TNumber;
+    position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        x: _sinclair_typebox.TNumber;
+        y: _sinclair_typebox.TNumber;
+        z: _sinclair_typebox.TNumber;
+    }>>;
+    lookAt: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        x: _sinclair_typebox.TNumber;
+        y: _sinclair_typebox.TNumber;
+        z: _sinclair_typebox.TNumber;
+    }>>;
+    fov: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    easing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+}>;
+
 // @public
 export class CameraManager {
     constructor();
@@ -662,6 +736,7 @@ export interface CameraPerspective {
     getBasePose(ctx: CameraContext): CameraPose;
     // (undocumented)
     id: string;
+    projection?: CameraProjection;
 }
 
 // @public
@@ -709,6 +784,39 @@ export interface CameraPose {
     zoom?: number;
 }
 
+// Warning: (ae-forgotten-export) The symbol "CameraPoseDefSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type CameraPoseDef = Static<typeof CameraPoseDefSchema>;
+
+export { CameraPosePayload }
+
+// @public
+export type CameraProjection = 'perspective' | 'orthographic';
+
+// @public (undocumented)
+export type CameraShot = Static<typeof CameraShotSchema>;
+
+// @public (undocumented)
+export const CameraShotSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    cameraId: _sinclair_typebox.TString;
+    start: _sinclair_typebox.TNumber;
+    end: _sinclair_typebox.TNumber;
+    blend: _sinclair_typebox.TObject<{
+        duration: _sinclair_typebox.TNumber;
+        easing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+    }>;
+}>;
+
+// Warning: (ae-forgotten-export) The symbol "CameraTrackSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type CameraTrack = Static<typeof CameraTrackSchema>;
+
+// @public
+export function cameraTracks(definition: CutsceneDefinition): CameraTrack[];
+
 // @public
 export class CameraWrapper {
     constructor(camera: ZylemCamera);
@@ -734,6 +842,9 @@ export { clamp }
 // @public
 export function clearGlobalSubscriptions(): void;
 
+// @public
+export function clipsAt(song: SongDefinition, trackId: string, beat: number): Array<NoteClip | AudioClip>;
+
 // @public
 export function closestAxisValue(ray: GizmoRay, origin: Vector3, axis: Vector3): number | null;
 
@@ -828,6 +939,9 @@ export function createCone(...args: Array<ConeOptions>): ZylemCone;
 // @public
 export function createCooldownIcon(...args: Array<CooldownIconOptions>): ZylemCooldownIcon;
 
+// @public
+export function createCutscenePlayer(initial: CutsceneDefinition, options: CutscenePlayerOptions): CutscenePlayer;
+
 // Warning: (ae-forgotten-export) The symbol "CylinderOptions" needs to be exported by the entry point public.d.ts
 //
 // @public
@@ -867,6 +981,9 @@ export function createGame<TGlobals extends BaseGlobals>(...options: GameOptions
 // @public
 export function createGlobal<T>(path: string, defaultValue: T): T;
 
+// @public
+export function createInstrument(Tone: ToneModule, def: InstrumentDefinition): Instrument;
+
 export { createJumpConfig2D }
 
 export { createJumpConfig3D }
@@ -920,6 +1037,9 @@ export { createPlatformer3DMovementComponent }
 
 export { createPlatformer3DStateComponent }
 
+// @public
+export function createPlatformFollow(options?: PlatformFollowOptions): CameraBehavior;
+
 // Warning: (ae-forgotten-export) The symbol "PyramidOptions" needs to be exported by the entry point public.d.ts
 //
 // @public
@@ -934,6 +1054,9 @@ export { createShooter2DStateComponent }
 
 export { createSimulation }
 
+// @public
+export function createSongPlayer(definition: SongDefinition, options?: SongPlayerOptions): SongPlayer;
+
 // Warning: (ae-forgotten-export) The symbol "SphereOptions" needs to be exported by the entry point public.d.ts
 //
 // @public (undocumented)
@@ -949,6 +1072,12 @@ export function createSprite(...args: Array<SpriteOptions>): ZylemSprite;
 // @public
 export function createStage(...options: StageOptions): Stage;
 
+// @public (undocumented)
+export function createStageCutsceneHost(stageLike: CutsceneStageLike, options?: StageCutsceneHostOptions): CutsceneHost;
+
+// @public
+export function createStrategyPan(options?: StrategyPanOptions): StrategyPanBehavior;
+
 // Warning: (ae-forgotten-export) The symbol "TextOptions" needs to be exported by the entry point public.d.ts
 //
 // @public (undocumented)
@@ -981,6 +1110,449 @@ export function createZone(...args: Array<ZoneOptions>): ZylemZone;
 // @public
 export const crossfadeTransitionShader: ZylemTransitionShader;
 
+// @public
+export const CUTSCENE_BEHAVIOR_KEY = "cutscene";
+
+// @public (undocumented)
+export type CutsceneCamera = Static<typeof CutsceneCameraSchema>;
+
+// @public
+export class CutsceneCameraBehavior implements CameraBehavior {
+    // (undocumented)
+    enabled: boolean;
+    // (undocumented)
+    onDetach(): void;
+    // (undocumented)
+    priority: number;
+    setPose(pose: EvaluatedPose | null, damping?: number): void;
+    snap(): void;
+    // (undocumented)
+    update(ctx: CameraContext, pose: CameraPose): CameraPose;
+}
+
+// Warning: (ae-forgotten-export) The symbol "CutsceneCameraKindSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type CutsceneCameraKind = Static<typeof CutsceneCameraKindSchema>;
+
+// @public (undocumented)
+export const CutsceneCameraSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TString;
+    kind: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"static">, _sinclair_typebox.TLiteral<"dolly">, _sinclair_typebox.TLiteral<"follow">]>;
+    fov: _sinclair_typebox.TNumber;
+    pose: _sinclair_typebox.TObject<{
+        position: _sinclair_typebox.TObject<{
+            x: _sinclair_typebox.TNumber;
+            y: _sinclair_typebox.TNumber;
+            z: _sinclair_typebox.TNumber;
+        }>;
+        lookAt: _sinclair_typebox.TObject<{
+            x: _sinclair_typebox.TNumber;
+            y: _sinclair_typebox.TNumber;
+            z: _sinclair_typebox.TNumber;
+        }>;
+    }>;
+    dollyId: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    dollyEasing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+    target: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    offset: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        x: _sinclair_typebox.TNumber;
+        y: _sinclair_typebox.TNumber;
+        z: _sinclair_typebox.TNumber;
+    }>>;
+    damping: _sinclair_typebox.TNumber;
+    keyframes: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        time: _sinclair_typebox.TNumber;
+        position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            x: _sinclair_typebox.TNumber;
+            y: _sinclair_typebox.TNumber;
+            z: _sinclair_typebox.TNumber;
+        }>>;
+        lookAt: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            x: _sinclair_typebox.TNumber;
+            y: _sinclair_typebox.TNumber;
+            z: _sinclair_typebox.TNumber;
+        }>>;
+        fov: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        easing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+    }>>;
+}>;
+
+// @public (undocumented)
+export type CutsceneDefinition = Static<typeof CutsceneDefinitionSchema>;
+
+// @public (undocumented)
+export const CutsceneDefinitionSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TString;
+    duration: _sinclair_typebox.TNumber;
+    stage: _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>;
+    skippable: _sinclair_typebox.TBoolean;
+    scenes: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        name: _sinclair_typebox.TString;
+        start: _sinclair_typebox.TNumber;
+        end: _sinclair_typebox.TNumber;
+        transitionIn: _sinclair_typebox.TObject<{
+            type: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"cut">, _sinclair_typebox.TLiteral<"fade">, _sinclair_typebox.TLiteral<"wipe">, _sinclair_typebox.TLiteral<"radial">, _sinclair_typebox.TLiteral<"noise">, _sinclair_typebox.TLiteral<"cells">]>;
+            duration: _sinclair_typebox.TNumber;
+            easing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+        }>;
+    }>>;
+    cameras: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        name: _sinclair_typebox.TString;
+        kind: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"static">, _sinclair_typebox.TLiteral<"dolly">, _sinclair_typebox.TLiteral<"follow">]>;
+        fov: _sinclair_typebox.TNumber;
+        pose: _sinclair_typebox.TObject<{
+            position: _sinclair_typebox.TObject<{
+                x: _sinclair_typebox.TNumber;
+                y: _sinclair_typebox.TNumber;
+                z: _sinclair_typebox.TNumber;
+            }>;
+            lookAt: _sinclair_typebox.TObject<{
+                x: _sinclair_typebox.TNumber;
+                y: _sinclair_typebox.TNumber;
+                z: _sinclair_typebox.TNumber;
+            }>;
+        }>;
+        dollyId: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        dollyEasing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+        target: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        offset: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            x: _sinclair_typebox.TNumber;
+            y: _sinclair_typebox.TNumber;
+            z: _sinclair_typebox.TNumber;
+        }>>;
+        damping: _sinclair_typebox.TNumber;
+        keyframes: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+            id: _sinclair_typebox.TString;
+            time: _sinclair_typebox.TNumber;
+            position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                x: _sinclair_typebox.TNumber;
+                y: _sinclair_typebox.TNumber;
+                z: _sinclair_typebox.TNumber;
+            }>>;
+            lookAt: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                x: _sinclair_typebox.TNumber;
+                y: _sinclair_typebox.TNumber;
+                z: _sinclair_typebox.TNumber;
+            }>>;
+            fov: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            easing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+        }>>;
+    }>>;
+    dollies: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        name: _sinclair_typebox.TString;
+        points: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+            x: _sinclair_typebox.TNumber;
+            y: _sinclair_typebox.TNumber;
+            z: _sinclair_typebox.TNumber;
+        }>>;
+        closed: _sinclair_typebox.TBoolean;
+        tension: _sinclair_typebox.TNumber;
+    }>>;
+    tracks: _sinclair_typebox.TArray<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+        kind: _sinclair_typebox.TLiteral<"camera">;
+        id: _sinclair_typebox.TString;
+        name: _sinclair_typebox.TString;
+        items: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+            id: _sinclair_typebox.TString;
+            cameraId: _sinclair_typebox.TString;
+            start: _sinclair_typebox.TNumber;
+            end: _sinclair_typebox.TNumber;
+            blend: _sinclair_typebox.TObject<{
+                duration: _sinclair_typebox.TNumber;
+                easing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+            }>;
+        }>>;
+    }>, _sinclair_typebox.TObject<{
+        kind: _sinclair_typebox.TLiteral<"event">;
+        id: _sinclair_typebox.TString;
+        name: _sinclair_typebox.TString;
+        items: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+            id: _sinclair_typebox.TString;
+            time: _sinclair_typebox.TNumber;
+            event: _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+                type: _sinclair_typebox.TLiteral<"emit">;
+                name: _sinclair_typebox.TString;
+                payload: _sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber, _sinclair_typebox.TBoolean]>>;
+            }>, _sinclair_typebox.TObject<{
+                type: _sinclair_typebox.TLiteral<"playAnimation">;
+                entity: _sinclair_typebox.TString;
+                key: _sinclair_typebox.TString;
+            }>, _sinclair_typebox.TObject<{
+                type: _sinclair_typebox.TLiteral<"playSong">;
+                song: _sinclair_typebox.TString;
+                loop: _sinclair_typebox.TBoolean;
+            }>, _sinclair_typebox.TObject<{
+                type: _sinclair_typebox.TLiteral<"stopSong">;
+                song: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            }>, _sinclair_typebox.TObject<{
+                type: _sinclair_typebox.TLiteral<"setVariable">;
+                name: _sinclair_typebox.TString;
+                value: _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber, _sinclair_typebox.TBoolean]>;
+            }>]>;
+        }>>;
+    }>, _sinclair_typebox.TObject<{
+        kind: _sinclair_typebox.TLiteral<"audio">;
+        id: _sinclair_typebox.TString;
+        name: _sinclair_typebox.TString;
+        items: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+            id: _sinclair_typebox.TString;
+            time: _sinclair_typebox.TNumber;
+            kind: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"song">, _sinclair_typebox.TLiteral<"sfx">]>;
+            ref: _sinclair_typebox.TString;
+            loop: _sinclair_typebox.TBoolean;
+            volume: _sinclair_typebox.TNumber;
+        }>>;
+    }>]>>;
+}>;
+
+// Warning: (ae-forgotten-export) The symbol "CutsceneEasingSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type CutsceneEasing = Static<typeof CutsceneEasingSchema>;
+
+// @public (undocumented)
+export type CutsceneEvent = Static<typeof CutsceneEventSchema>;
+
+// @public (undocumented)
+export const CutsceneEventSchema: _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+    type: _sinclair_typebox.TLiteral<"emit">;
+    name: _sinclair_typebox.TString;
+    payload: _sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber, _sinclair_typebox.TBoolean]>>;
+}>, _sinclair_typebox.TObject<{
+    type: _sinclair_typebox.TLiteral<"playAnimation">;
+    entity: _sinclair_typebox.TString;
+    key: _sinclair_typebox.TString;
+}>, _sinclair_typebox.TObject<{
+    type: _sinclair_typebox.TLiteral<"playSong">;
+    song: _sinclair_typebox.TString;
+    loop: _sinclair_typebox.TBoolean;
+}>, _sinclair_typebox.TObject<{
+    type: _sinclair_typebox.TLiteral<"stopSong">;
+    song: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+}>, _sinclair_typebox.TObject<{
+    type: _sinclair_typebox.TLiteral<"setVariable">;
+    name: _sinclair_typebox.TString;
+    value: _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber, _sinclair_typebox.TBoolean]>;
+}>]>;
+
+// @public (undocumented)
+export interface CutsceneFrame {
+    blend: number;
+    // (undocumented)
+    camera: CutsceneCamera | undefined;
+    // (undocumented)
+    pose: EvaluatedPose | undefined;
+    // (undocumented)
+    scene: CutsceneScene | undefined;
+    // (undocumented)
+    shot: CameraShot | undefined;
+}
+
+// @public
+export interface CutsceneHost {
+    beginTransition?: (transition: SceneTransition, shader: ZylemTransitionShader | undefined) => void;
+    camera: () => ZylemCamera | null;
+    dispatch?: (name: string, payload: Record<string, unknown>) => void;
+    entityPosition?: (name: string) => Vec3Def | undefined;
+    // (undocumented)
+    playAnimation?: (entity: string, key: string) => void;
+    // (undocumented)
+    playSfx?: (url: string, options: {
+        volume: number;
+        loop: boolean;
+    }) => void;
+    // (undocumented)
+    playSong?: (ref: string, options: {
+        loop: boolean;
+        volume: number;
+    }) => void;
+    // (undocumented)
+    setVariable?: (name: string, value: unknown) => void;
+    // (undocumented)
+    stopSong?: (ref?: string) => void;
+}
+
+// @public
+export function cutsceneLength(definition: Pick<CutsceneDefinition, 'duration' | 'scenes'>): number;
+
+export { CutsceneLoadPayload }
+
+export { CutscenePlaybackState }
+
+// @public (undocumented)
+export interface CutscenePlayer {
+    // (undocumented)
+    readonly definition: CutsceneDefinition;
+    // (undocumented)
+    dispose(): void;
+    // (undocumented)
+    readonly length: number;
+    // (undocumented)
+    on<K extends keyof CutscenePlayerEvents>(event: K, handler: CutscenePlayerEvents[K]): () => void;
+    // (undocumented)
+    pause(): void;
+    // (undocumented)
+    play(from?: number): void;
+    readonly pose: EvaluatedPose | undefined;
+    // (undocumented)
+    seek(time: number): void;
+    setDefinition(definition: CutsceneDefinition): void;
+    skip(): boolean;
+    // (undocumented)
+    readonly state: CutscenePlayerState;
+    stop(): void;
+    readonly time: number;
+    update(dt: number): void;
+}
+
+// @public (undocumented)
+export interface CutscenePlayerEvents {
+    // (undocumented)
+    audio: (item: AudioItem) => void;
+    // (undocumented)
+    complete: () => void;
+    // (undocumented)
+    event: (item: EventItem) => void;
+    // (undocumented)
+    scene: (scene: CutsceneScene | undefined) => void;
+    // (undocumented)
+    shot: (shot: CameraShot | undefined) => void;
+    // (undocumented)
+    skip: () => void;
+    // (undocumented)
+    state: (state: CutscenePlayerState) => void;
+    // (undocumented)
+    time: (time: number) => void;
+}
+
+// @public (undocumented)
+export interface CutscenePlayerOptions {
+    fireEventsOnSeek?: boolean;
+    // (undocumented)
+    host: CutsceneHost;
+    tick?: 'auto' | 'manual';
+    // (undocumented)
+    timeScale?: number;
+    transitionShader?: (type: SceneTransitionType) => ZylemTransitionShader | undefined;
+}
+
+// @public (undocumented)
+export type CutscenePlayerState = 'idle' | 'playing' | 'paused' | 'finished';
+
+// @public
+export class CutscenePreviewController {
+    // Warning: (ae-forgotten-export) The symbol "ZylemStage" needs to be exported by the entry point public.d.ts
+    constructor(getStage: () => ZylemStage | null, publish: (status: CutsceneStatusPayload) => void, hostOptions?: StageCutsceneHostOptions, publishView?: ((view: CutsceneViewPayload) => void) | undefined);
+    // (undocumented)
+    get active(): boolean;
+    cameraPose(): Omit<CameraPosePayload, 'requestId'> | null;
+    frame(): void;
+    // (undocumented)
+    load(payload: CutsceneLoadPayload): void;
+    // (undocumented)
+    pause(): void;
+    // (undocumented)
+    play(from?: number): void;
+    releaseStage(): void;
+    // (undocumented)
+    seek(time: number): void;
+    stageReady(): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    unload(): void;
+}
+
+// @public (undocumented)
+export type CutsceneScene = Static<typeof CutsceneSceneSchema>;
+
+// @public (undocumented)
+export const CutsceneSceneSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TString;
+    start: _sinclair_typebox.TNumber;
+    end: _sinclair_typebox.TNumber;
+    transitionIn: _sinclair_typebox.TObject<{
+        type: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"cut">, _sinclair_typebox.TLiteral<"fade">, _sinclair_typebox.TLiteral<"wipe">, _sinclair_typebox.TLiteral<"radial">, _sinclair_typebox.TLiteral<"noise">, _sinclair_typebox.TLiteral<"cells">]>;
+        duration: _sinclair_typebox.TNumber;
+        easing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+    }>;
+}>;
+
+// @public
+export type CutsceneStageLike = ZylemStage | Stage;
+
+export { CutsceneStatusPayload }
+
+// @public (undocumented)
+export type CutsceneTrack = Static<typeof CutsceneTrackSchema>;
+
+// @public (undocumented)
+export const CutsceneTrackSchema: _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+    kind: _sinclair_typebox.TLiteral<"camera">;
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TString;
+    items: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        cameraId: _sinclair_typebox.TString;
+        start: _sinclair_typebox.TNumber;
+        end: _sinclair_typebox.TNumber;
+        blend: _sinclair_typebox.TObject<{
+            duration: _sinclair_typebox.TNumber;
+            easing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+        }>;
+    }>>;
+}>, _sinclair_typebox.TObject<{
+    kind: _sinclair_typebox.TLiteral<"event">;
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TString;
+    items: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        time: _sinclair_typebox.TNumber;
+        event: _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+            type: _sinclair_typebox.TLiteral<"emit">;
+            name: _sinclair_typebox.TString;
+            payload: _sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber, _sinclair_typebox.TBoolean]>>;
+        }>, _sinclair_typebox.TObject<{
+            type: _sinclair_typebox.TLiteral<"playAnimation">;
+            entity: _sinclair_typebox.TString;
+            key: _sinclair_typebox.TString;
+        }>, _sinclair_typebox.TObject<{
+            type: _sinclair_typebox.TLiteral<"playSong">;
+            song: _sinclair_typebox.TString;
+            loop: _sinclair_typebox.TBoolean;
+        }>, _sinclair_typebox.TObject<{
+            type: _sinclair_typebox.TLiteral<"stopSong">;
+            song: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        }>, _sinclair_typebox.TObject<{
+            type: _sinclair_typebox.TLiteral<"setVariable">;
+            name: _sinclair_typebox.TString;
+            value: _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber, _sinclair_typebox.TBoolean]>;
+        }>]>;
+    }>>;
+}>, _sinclair_typebox.TObject<{
+    kind: _sinclair_typebox.TLiteral<"audio">;
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TString;
+    items: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        time: _sinclair_typebox.TNumber;
+        kind: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"song">, _sinclair_typebox.TLiteral<"sfx">]>;
+        ref: _sinclair_typebox.TString;
+        loop: _sinclair_typebox.TBoolean;
+        volume: _sinclair_typebox.TNumber;
+    }>>;
+}>]>;
+
+export { CutsceneViewPayload }
+
 // @public (undocumented)
 export const CYLINDER_TYPE: unique symbol;
 
@@ -994,6 +1566,9 @@ export function cylinderCollision(opts?: CylinderCollisionOptions): CollisionCom
 // @public
 export function cylinderMesh(opts?: CylinderMeshOptions): Mesh;
 
+// @public (undocumented)
+export function dbToGain(db: number): number;
+
 // @public
 export type DebugEntityResolver = (uuid: string) => GameEntity<any> | null;
 
@@ -1070,16 +1645,52 @@ export const DISK_TYPE: unique symbol;
 // @public
 export function dispatchStageState(): void;
 
+// @public (undocumented)
+export type DollyPath = Static<typeof DollyPathSchema>;
+
+// @public (undocumented)
+export const DollyPathSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TString;
+    points: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        x: _sinclair_typebox.TNumber;
+        y: _sinclair_typebox.TNumber;
+        z: _sinclair_typebox.TNumber;
+    }>>;
+    closed: _sinclair_typebox.TBoolean;
+    tension: _sinclair_typebox.TNumber;
+}>;
+
+// @public
+export function dollyPointAt(path: DollyPath, u: number): Vec3Def;
+
 export { dot }
 
+// @public
+export function easeValue(easing: CutsceneEasing, t: number): number;
+
 export { EditorToGameMessages }
 
+// Warning: (ae-forgotten-export) The symbol "EffectTypeSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type EffectType = Static<typeof EffectTypeSchema>;
+
 export { emitRuntimeGoal }
 
 export { emitRuntimeRicochet }
 
 export { emitRuntimeTriggerRegionEnter }
 
+// @public (undocumented)
+export function encodeWav(buffer: PcmSource): ArrayBuffer;
+
+// @public
+export function encodeWavBlob(buffer: PcmSource): Blob;
+
+// @public
+export function ensureAudio(): Promise<ToneModule>;
+
 export { EntityApplySwatchPayload }
 
 // @public (undocumented)
@@ -1273,9 +1884,30 @@ export interface EntityTypeMap {
     [ZONE_TYPE]: ZylemZone;
 }
 
+// Warning: (ae-forgotten-export) The symbol "EnvelopeSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type Envelope = Static<typeof EnvelopeSchema>;
+
 // @public
 export function eulerToQuaternion(rotation: Vec3): Quat;
 
+// @public
+export function evaluateCameraPose(camera: CutsceneCamera, definition: Pick<CutsceneDefinition, 'dollies'>, shot: Pick<CameraShot, 'start' | 'end'>, time: number, lookup?: TargetLookup): EvaluatedPose;
+
+// @public
+export function evaluateCutscene(definition: CutsceneDefinition, time: number, lookup?: TargetLookup): CutsceneFrame;
+
+// @public (undocumented)
+export interface EvaluatedPose {
+    // (undocumented)
+    fov: number;
+    // (undocumented)
+    lookAt: Vec3Def;
+    // (undocumented)
+    position: Vec3Def;
+}
+
 // @public
 export class EventEmitterDelegate<TEvents extends Record<string, unknown>> {
     constructor();
@@ -1285,6 +1917,40 @@ export class EventEmitterDelegate<TEvents extends Record<string, unknown>> {
     listenAll(handler: (type: keyof TEvents, payload: TEvents[keyof TEvents]) => void): () => void;
 }
 
+// @public (undocumented)
+export type EventItem = Static<typeof EventItemSchema>;
+
+// @public (undocumented)
+export const EventItemSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    time: _sinclair_typebox.TNumber;
+    event: _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+        type: _sinclair_typebox.TLiteral<"emit">;
+        name: _sinclair_typebox.TString;
+        payload: _sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber, _sinclair_typebox.TBoolean]>>;
+    }>, _sinclair_typebox.TObject<{
+        type: _sinclair_typebox.TLiteral<"playAnimation">;
+        entity: _sinclair_typebox.TString;
+        key: _sinclair_typebox.TString;
+    }>, _sinclair_typebox.TObject<{
+        type: _sinclair_typebox.TLiteral<"playSong">;
+        song: _sinclair_typebox.TString;
+        loop: _sinclair_typebox.TBoolean;
+    }>, _sinclair_typebox.TObject<{
+        type: _sinclair_typebox.TLiteral<"stopSong">;
+        song: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    }>, _sinclair_typebox.TObject<{
+        type: _sinclair_typebox.TLiteral<"setVariable">;
+        name: _sinclair_typebox.TString;
+        value: _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber, _sinclair_typebox.TBoolean]>;
+    }>]>;
+}>;
+
+// Warning: (ae-forgotten-export) The symbol "EventTrackSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type EventTrack = Static<typeof EventTrackSchema>;
+
 export { exp }
 
 export { FacingAngle2DEntity }
@@ -1351,6 +2017,8 @@ export class FirstPersonPerspective implements CameraPerspective {
     look(deltaYaw: number, deltaPitch: number): void;
     lookAt(target: Vector3, lerpSpeed?: number): void;
     get pitch(): number;
+    // (undocumented)
+    readonly projection: "perspective";
     resetZoom(): void;
     setEyeHeight(height: number): void;
     setLook(yaw: number, pitch: number): void;
@@ -1387,6 +2055,8 @@ export class Fixed2DPerspective implements CameraPerspective {
     getBasePose(_ctx: CameraContext): CameraPose;
     // (undocumented)
     readonly id = "fixed-2d";
+    // (undocumented)
+    readonly projection: "orthographic";
 }
 
 export { float }
@@ -1414,6 +2084,9 @@ export { FractureOptions }
 
 export { FractureOptionsInput }
 
+// @public (undocumented)
+export function gainToDb(gain: number): number;
+
 // Warning: (ae-forgotten-export) The symbol "IGame" needs to be exported by the entry point public.d.ts
 //
 // @public (undocumented)
@@ -1482,6 +2155,8 @@ export class GameBridge {
     publishCatalog(entities: EntityTypeDescriptor[]): void;
     // (undocumented)
     publishConfig(config: GameConfigPayload): void;
+    publishCutsceneStatus(status: CutsceneStatusPayload): void;
+    publishCutsceneView(view: CutsceneViewPayload): void;
     // (undocumented)
     publishLoading(payload: BridgeLoadingPayload): void;
     publishNotice(level: GameNoticePayload['level'], message: string): void;
@@ -1508,7 +2183,16 @@ export interface GameBridgeHost {
     applySwatches?(payload: EntityApplySwatchPayload & {
         opId: string;
     }): SwatchApplyOutcome;
+    cameraPose?(): Omit<CameraPosePayload, 'requestId'> | null;
     createEntity?(typeId: string, props: Record<string, unknown> | undefined, pose: BridgePose | undefined): void;
+    cutscene?: {
+        load(payload: CutsceneLoadPayload): void;
+        play(from?: number): void;
+        pause(): void;
+        stop(): void;
+        seek(time: number): void;
+        unload(): void;
+    };
     pickEntity?(ndc: BridgeNdc): EntitySummaryPayload | null;
     resolveEntity(uuid: string): GameEntity<any> | null;
     setStageVariable?(key: string, value: unknown): void;
@@ -2141,6 +2825,9 @@ export { GameToEditorMessages }
 
 export { GameVariablePayload }
 
+// @public
+export function getActiveSongPlayer(): SongPlayer | null;
+
 export { getCooldown }
 
 export { getCooldownStore }
@@ -2315,9 +3002,64 @@ export interface InputProvider {
 // @public (undocumented)
 export type Inputs = Record<InputPlayer, InputGamepad>;
 
+// @public
+export interface Instrument {
+    // (undocumented)
+    readonly definition: InstrumentDefinition;
+    // (undocumented)
+    dispose(): void;
+    readonly output: ToneNs.ToneAudioNode;
+    releaseAll(time?: number): void;
+    trigger(pitch: number, duration: number, time?: number, velocity?: number): void;
+}
+
+// @public (undocumented)
+export type InstrumentDefinition = Static<typeof InstrumentDefinitionSchema>;
+
+// @public (undocumented)
+export const InstrumentDefinitionSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TString;
+    preset: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"synth">, _sinclair_typebox.TLiteral<"polySynth">, _sinclair_typebox.TLiteral<"fmSynth">, _sinclair_typebox.TLiteral<"amSynth">, _sinclair_typebox.TLiteral<"membraneSynth">, _sinclair_typebox.TLiteral<"metalSynth">, _sinclair_typebox.TLiteral<"noiseSynth">, _sinclair_typebox.TLiteral<"pluckSynth">]>;
+    oscillator: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"sine">, _sinclair_typebox.TLiteral<"square">, _sinclair_typebox.TLiteral<"sawtooth">, _sinclair_typebox.TLiteral<"triangle">]>>;
+    envelope: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        attack: _sinclair_typebox.TNumber;
+        decay: _sinclair_typebox.TNumber;
+        sustain: _sinclair_typebox.TNumber;
+        release: _sinclair_typebox.TNumber;
+    }>>;
+    volume: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    effects: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        type: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"reverb">, _sinclair_typebox.TLiteral<"delay">, _sinclair_typebox.TLiteral<"distortion">, _sinclair_typebox.TLiteral<"filter">]>;
+        wet: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        options: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean]>>>;
+    }>>>;
+}>;
+
+// @public (undocumented)
+export type InstrumentEffect = Static<typeof InstrumentEffectSchema>;
+
+// @public (undocumented)
+export const InstrumentEffectSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    type: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"reverb">, _sinclair_typebox.TLiteral<"delay">, _sinclair_typebox.TLiteral<"distortion">, _sinclair_typebox.TLiteral<"filter">]>;
+    wet: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    options: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean]>>>;
+}>;
+
+// @public (undocumented)
+export type InstrumentPreset = Static<typeof InstrumentPresetSchema>;
+
+// @public
+export const InstrumentPresetSchema: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"synth">, _sinclair_typebox.TLiteral<"polySynth">, _sinclair_typebox.TLiteral<"fmSynth">, _sinclair_typebox.TLiteral<"amSynth">, _sinclair_typebox.TLiteral<"membraneSynth">, _sinclair_typebox.TLiteral<"metalSynth">, _sinclair_typebox.TLiteral<"noiseSynth">, _sinclair_typebox.TLiteral<"pluckSynth">]>;
+
 // @public
 export function intersectPlane(ray: GizmoRay, origin: Vector3, normal: Vector3, target: Vector3): Vector3 | null;
 
+// @public
+export function isAudioReady(): boolean;
+
 // @public
 export function isGLSLShader(shader: ZylemShader): shader is ZylemShaderObject;
 
@@ -2327,6 +3069,30 @@ export function isManagedRenderEntity(entity: {
     isBundled?: boolean;
 }): boolean;
 
+// @public
+export interface IsometricOptions {
+    distance?: number;
+    initialLookAt?: Vec3Input;
+    initialPosition?: Vec3Input;
+    targetKey?: string;
+    zoom?: number;
+}
+
+// @public
+export class IsometricPerspective implements CameraPerspective {
+    constructor(options?: IsometricOptions);
+    // (undocumented)
+    readonly defaults: {
+        damping: number;
+    };
+    // (undocumented)
+    getBasePose(ctx: CameraContext): CameraPose;
+    // (undocumented)
+    readonly id = "isometric";
+    // (undocumented)
+    readonly projection: "orthographic";
+}
+
 // @public (undocumented)
 export function isPickMode(): boolean;
 
@@ -2339,6 +3105,11 @@ export function isTSLShader(shader: ZylemShader): shader is ZylemTSLShader;
 // @public
 export function isWebGPUSupported(): Promise<boolean>;
 
+// @public
+export function itemsBetween<T extends {
+    time: number;
+}>(items: readonly T[], from: number, to: number): T[];
+
 // @public
 export function joystickBaseSvg(theme?: TouchThemeInput): string;
 
@@ -2396,6 +3167,12 @@ export const KeyboardMappingSchema: _sinclair_typebox.TRecord<_sinclair_typebox.
 
 export { length_2 as length }
 
+// @public (undocumented)
+export function lerpPose(a: EvaluatedPose, b: EvaluatedPose, t: number): EvaluatedPose;
+
+// @public (undocumented)
+export function lerpVec3(a: Vec3Def, b: Vec3Def, t: number): Vec3Def;
+
 // @public (undocumented)
 export const LIGHT_TYPE: unique symbol;
 
@@ -2455,11 +3232,23 @@ export type LoadingEvent = {
     current?: number;
 };
 
+// @public
+export function loadTone(): Promise<ToneModule>;
+
 export { max }
 
+// @public
+export function measureObjectSelectionBounds(object: Object3D, target: Box3): Box3;
+
 // @public
 export function mergeInputConfigs(...configs: GameInputConfig[]): GameInputConfig;
 
+// @public
+export function midiToFrequency(pitch: number): number;
+
+// @public
+export function midiToNoteName(pitch: number): string;
+
 export { min }
 
 export { mix }
@@ -2539,10 +3328,30 @@ export { MultidirectionalSpaceShooterInput }
 export { normalize }
 
 // @public (undocumented)
-export function normalizeVec2(input?: Vec2Input | null, defaults?: Vec2Input | Partial<Vec2Components>): Vec2Components;
+export function normalizeVec2(input?: Vec2Input | null, defaults?: Vec2Input | Partial<Vec2Components>): Vec2Components;
+
+// @public (undocumented)
+export function normalizeVec3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vec3Components;
+
+// @public (undocumented)
+export type NoteClip = Static<typeof NoteClipSchema>;
 
 // @public (undocumented)
-export function normalizeVec3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vec3Components;
+export const NoteClipSchema: _sinclair_typebox.TObject<{
+    kind: _sinclair_typebox.TLiteral<"notes">;
+    id: _sinclair_typebox.TString;
+    trackId: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    start: _sinclair_typebox.TNumber;
+    length: _sinclair_typebox.TNumber;
+    notes: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        pitch: _sinclair_typebox.TInteger;
+        start: _sinclair_typebox.TNumber;
+        duration: _sinclair_typebox.TNumber;
+        velocity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    }>>;
+}>;
 
 // @public (undocumented)
 export const objectVertexShader = "\nuniform vec2 uvScale;\nvarying vec2 vUv;\n\nvoid main() {\n\tvUv = uv;\n\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n\tgl_Position = projectionMatrix * mvPosition;\n}\n";
@@ -2590,9 +3399,18 @@ export type OpacityEntity = {
     mesh?: Object3D | null;
 };
 
+// Warning: (ae-forgotten-export) The symbol "OscillatorTypeSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+type OscillatorType_2 = Static<typeof OscillatorTypeSchema>;
+export { OscillatorType_2 as OscillatorType }
+
 // @public
 export function packCollisionGroups(collisionType?: string, collisionFilter?: string[]): number;
 
+// @public
+export function padSelectionBounds(box: Box3): Box3;
+
 // @public
 export function parallel(...actions: Action[]): Action;
 
@@ -2634,12 +3452,25 @@ export { ParticlePresetMaterialOptions }
 export { particlePresets }
 
 // @public
-export type PerspectiveOptions = ThirdPersonOptions | Fixed2DOptions | FirstPersonOptions;
+export interface PcmSource {
+    // (undocumented)
+    getChannelData(channel: number): Float32Array;
+    // (undocumented)
+    length: number;
+    // (undocumented)
+    numberOfChannels: number;
+    // (undocumented)
+    sampleRate: number;
+}
+
+// @public
+export type PerspectiveOptions = ThirdPersonOptions | Fixed2DOptions | FirstPersonOptions | IsometricOptions | TopDownOptions | SecondPersonOptions;
 
 // @public (undocumented)
 export const Perspectives: {
     readonly FirstPerson: "first-person";
     readonly ThirdPerson: "third-person";
+    readonly SecondPerson: "second-person";
     readonly Isometric: "isometric";
     readonly Flat2D: "flat-2d";
     readonly Fixed2D: "fixed-2d";
@@ -2684,6 +3515,19 @@ export const PLANE_TYPE: unique symbol;
 // @public
 export function planeCollision(opts?: PlaneCollisionOptions): CollisionComponent;
 
+// @public
+export type PlatformAxisMode = 'delay' | 'settle' | 'off';
+
+// @public (undocumented)
+export interface PlatformAxisModes {
+    // (undocumented)
+    x?: PlatformAxisMode;
+    // (undocumented)
+    y?: PlatformAxisMode;
+    // (undocumented)
+    z?: PlatformAxisMode;
+}
+
 export { Platformer2DBehavior }
 
 export { Platformer2DBehaviorOptions }
@@ -2728,6 +3572,18 @@ export { Platformer3DStateComponent }
 
 export { PlatformerCollisionContext }
 
+// @public
+export interface PlatformFollowOptions {
+    axes?: PlatformAxisModes;
+    lerpFactor?: number;
+    lookahead?: number;
+    settleLerp?: number;
+    settleSpeed?: number;
+    settleTime?: number;
+    targetKey?: string;
+    window?: number;
+}
+
 export { PlayerInput }
 
 // @public (undocumented)
@@ -2763,6 +3619,9 @@ export { PrebakeWorkerRequest }
 
 export { PrebakeWorkerResponse }
 
+// @public
+export function previousShot(definition: CutsceneDefinition, shot: CameraShot): CameraShot | undefined;
+
 // @public (undocumented)
 export const PYRAMID_TYPE: unique symbol;
 
@@ -2824,6 +3683,19 @@ export class RenderBundleManager {
 // @public
 export type RenderCategory = 'none' | 'environment' | 'pack';
 
+// @public
+export function renderSong(song: SongDefinition, options?: RenderSongOptions): Promise<AudioBuffer>;
+
+// @public (undocumented)
+export interface RenderSongOptions {
+    // (undocumented)
+    resolveUrl?: (url: string) => string;
+    // (undocumented)
+    sampleRate?: number;
+    tail?: number;
+    trackIds?: Iterable<string>;
+}
+
 // @public
 export class RenderStrategyManager {
     // (undocumented)
@@ -2893,6 +3765,9 @@ export interface ResolveGameConfigRuntime {
 // @public
 export function resolveRenderCategory(options?: RenderCategoryOptions | null): RenderCategory;
 
+// @public
+export function resolveSelectionBounds(entity: unknown, target: Box3): Box3 | null;
+
 // @public
 export function resolveTouchTheme(input?: TouchTheme | TouchThemeName): TouchTheme;
 
@@ -3081,6 +3956,66 @@ export { RuntimeTriggerRegion2DHandle }
 
 export { RuntimeTriggerRegion2DOptions }
 
+// @public
+export function sampleDollyPath(path: DollyPath, segments?: number): Vec3Def[];
+
+// @public
+export function sceneAt(scenes: readonly CutsceneScene[], time: number): CutsceneScene | undefined;
+
+// @public (undocumented)
+export type SceneTransition = Static<typeof SceneTransitionSchema>;
+
+// @public (undocumented)
+export const SceneTransitionSchema: _sinclair_typebox.TObject<{
+    type: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"cut">, _sinclair_typebox.TLiteral<"fade">, _sinclair_typebox.TLiteral<"wipe">, _sinclair_typebox.TLiteral<"radial">, _sinclair_typebox.TLiteral<"noise">, _sinclair_typebox.TLiteral<"cells">]>;
+    duration: _sinclair_typebox.TNumber;
+    easing: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"linear">, _sinclair_typebox.TLiteral<"easeIn">, _sinclair_typebox.TLiteral<"easeOut">, _sinclair_typebox.TLiteral<"easeInOut">]>;
+}>;
+
+// Warning: (ae-forgotten-export) The symbol "SceneTransitionTypeSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type SceneTransitionType = Static<typeof SceneTransitionTypeSchema>;
+
+// @public (undocumented)
+export interface ScheduledAudio {
+    // (undocumented)
+    clipId: string;
+    duration: number;
+    gain: number;
+    offset: number;
+    time: number;
+    // (undocumented)
+    trackId: string;
+    // (undocumented)
+    url: string;
+}
+
+// @public (undocumented)
+export interface ScheduledNote {
+    // (undocumented)
+    clipId: string;
+    duration: number;
+    // (undocumented)
+    instrumentId: string;
+    // (undocumented)
+    pitch: number;
+    time: number;
+    // (undocumented)
+    trackId: string;
+    // (undocumented)
+    velocity: number;
+}
+
+// @public (undocumented)
+export interface ScheduleOptions {
+    ignoreMix?: boolean;
+    trackIds?: Iterable<string>;
+}
+
+// @public
+export function scheduleSong(song: SongDefinition, options?: ScheduleOptions): SongSchedule;
+
 // @public
 export type ScreenAnchor = 'top-left' | 'top-center' | 'top-right' | 'center-left' | 'center' | 'center-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
 
@@ -3132,6 +4067,52 @@ export { ScreenWrapOptions }
 
 export { ScreenWrapState }
 
+// @public
+export interface SecondPersonOptions {
+    anchorKey?: string;
+    eyeHeight?: number;
+    fov?: number;
+    initialLookAt?: Vec3Input;
+    initialPosition?: Vec3Input;
+    subjectKey?: string;
+}
+
+// @public
+export class SecondPersonPerspective implements CameraPerspective {
+    constructor(options?: SecondPersonOptions);
+    // (undocumented)
+    readonly defaults: {
+        damping: number;
+    };
+    // (undocumented)
+    getBasePose(ctx: CameraContext): CameraPose;
+    // (undocumented)
+    readonly id = "second-person";
+    // (undocumented)
+    readonly projection: "perspective";
+}
+
+// @public (undocumented)
+export function secondsToBeats(seconds: number, bpm: number): number;
+
+// @public
+export const SELECTION_BOUNDS_MARGIN = 0.02;
+
+// @public
+export const SELECTION_THIN_AXIS_FRACTION = 0.05;
+
+// @public (undocumented)
+export const SELECTION_THIN_AXIS_MAX = 1;
+
+// @public
+export const SELECTION_THIN_AXIS_MIN = 0.1;
+
+// @public
+export interface SelectionBoundsProvider {
+    // (undocumented)
+    getSelectionBounds(target: Box3): Box3 | null;
+}
+
 export { SemanticParticlePresetOptions }
 
 // @public
@@ -3143,6 +4124,9 @@ export function setAddType(typeId: string | null, props?: Record<string, unknown
 // @public
 export function setCameraFeed(entity: StageEntity, camera: CameraWrapper, options?: CameraFeedOptions): void;
 
+// @public
+export function setCutsceneTransitionShaders(resolver: ((type: SceneTransitionType) => ZylemTransitionShader | undefined) | null): void;
+
 // @public (undocumented)
 export function setDebugTool(tool: DebugTools): void;
 
@@ -3256,6 +4240,14 @@ export { Shooter2DTarget }
 // @public
 export function shortestAngleDelta(from: number, to: number): number;
 
+// @public
+export function shotAt(shots: readonly CameraShot[], time: number): CameraShot | undefined;
+
+// Warning: (ae-forgotten-export) The symbol "ShotBlendSchema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type ShotBlend = Static<typeof ShotBlendSchema>;
+
 export { Simulation }
 
 // Warning: (ae-forgotten-export) The symbol "PhysicsRenderPoseProvider" needs to be exported by the entry point public.d.ts
@@ -3361,6 +4353,218 @@ export function snapToIncrement(value: number, increment: number): number;
 // @public
 export function snapVec3(value: Vec3, increment: number): Vec3;
 
+// @public (undocumented)
+export type SongClip = Static<typeof SongClipSchema>;
+
+// @public (undocumented)
+export const SongClipSchema: _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+    kind: _sinclair_typebox.TLiteral<"notes">;
+    id: _sinclair_typebox.TString;
+    trackId: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    start: _sinclair_typebox.TNumber;
+    length: _sinclair_typebox.TNumber;
+    notes: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        pitch: _sinclair_typebox.TInteger;
+        start: _sinclair_typebox.TNumber;
+        duration: _sinclair_typebox.TNumber;
+        velocity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    }>>;
+}>, _sinclair_typebox.TObject<{
+    kind: _sinclair_typebox.TLiteral<"audio">;
+    id: _sinclair_typebox.TString;
+    trackId: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    url: _sinclair_typebox.TString;
+    start: _sinclair_typebox.TNumber;
+    offset: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    length: _sinclair_typebox.TNumber;
+    gain: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+}>]>;
+
+// @public (undocumented)
+export type SongDefinition = Static<typeof SongDefinitionSchema>;
+
+// @public (undocumented)
+export const SongDefinitionSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TString;
+    bpm: _sinclair_typebox.TNumber;
+    timeSignature: _sinclair_typebox.TObject<{
+        numerator: _sinclair_typebox.TInteger;
+        denominator: _sinclair_typebox.TInteger;
+    }>;
+    lengthBars: _sinclair_typebox.TInteger;
+    loop: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        enabled: _sinclair_typebox.TBoolean;
+        start: _sinclair_typebox.TNumber;
+        end: _sinclair_typebox.TNumber;
+    }>>;
+    instruments: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        name: _sinclair_typebox.TString;
+        preset: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"synth">, _sinclair_typebox.TLiteral<"polySynth">, _sinclair_typebox.TLiteral<"fmSynth">, _sinclair_typebox.TLiteral<"amSynth">, _sinclair_typebox.TLiteral<"membraneSynth">, _sinclair_typebox.TLiteral<"metalSynth">, _sinclair_typebox.TLiteral<"noiseSynth">, _sinclair_typebox.TLiteral<"pluckSynth">]>;
+        oscillator: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"sine">, _sinclair_typebox.TLiteral<"square">, _sinclair_typebox.TLiteral<"sawtooth">, _sinclair_typebox.TLiteral<"triangle">]>>;
+        envelope: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            attack: _sinclair_typebox.TNumber;
+            decay: _sinclair_typebox.TNumber;
+            sustain: _sinclair_typebox.TNumber;
+            release: _sinclair_typebox.TNumber;
+        }>>;
+        volume: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        effects: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+            id: _sinclair_typebox.TString;
+            type: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"reverb">, _sinclair_typebox.TLiteral<"delay">, _sinclair_typebox.TLiteral<"distortion">, _sinclair_typebox.TLiteral<"filter">]>;
+            wet: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            options: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean]>>>;
+        }>>>;
+    }>>;
+    tracks: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        name: _sinclair_typebox.TString;
+        kind: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"instrument">, _sinclair_typebox.TLiteral<"audio">]>;
+        instrumentId: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        color: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        volume: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        pan: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        mute: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        solo: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    }>>;
+    clips: _sinclair_typebox.TArray<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+        kind: _sinclair_typebox.TLiteral<"notes">;
+        id: _sinclair_typebox.TString;
+        trackId: _sinclair_typebox.TString;
+        name: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        start: _sinclair_typebox.TNumber;
+        length: _sinclair_typebox.TNumber;
+        notes: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+            id: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            pitch: _sinclair_typebox.TInteger;
+            start: _sinclair_typebox.TNumber;
+            duration: _sinclair_typebox.TNumber;
+            velocity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        }>>;
+    }>, _sinclair_typebox.TObject<{
+        kind: _sinclair_typebox.TLiteral<"audio">;
+        id: _sinclair_typebox.TString;
+        trackId: _sinclair_typebox.TString;
+        name: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        url: _sinclair_typebox.TString;
+        start: _sinclair_typebox.TNumber;
+        offset: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        length: _sinclair_typebox.TNumber;
+        gain: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    }>]>>;
+    masterVolume: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+}>;
+
+// @public (undocumented)
+export function songLengthBeats(song: Pick<SongDefinition, 'lengthBars' | 'timeSignature'>): number;
+
+// @public (undocumented)
+export function songLengthSeconds(song: Pick<SongDefinition, 'lengthBars' | 'timeSignature' | 'bpm'>): number;
+
+// @public (undocumented)
+export type SongLoop = Static<typeof SongLoopSchema>;
+
+// @public (undocumented)
+export const SongLoopSchema: _sinclair_typebox.TObject<{
+    enabled: _sinclair_typebox.TBoolean;
+    start: _sinclair_typebox.TNumber;
+    end: _sinclair_typebox.TNumber;
+}>;
+
+// @public (undocumented)
+export type SongNote = Static<typeof SongNoteSchema>;
+
+// @public (undocumented)
+export const SongNoteSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    pitch: _sinclair_typebox.TInteger;
+    start: _sinclair_typebox.TNumber;
+    duration: _sinclair_typebox.TNumber;
+    velocity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+}>;
+
+// @public (undocumented)
+export interface SongPlayer {
+    // (undocumented)
+    readonly definition: SongDefinition;
+    // (undocumented)
+    dispose(): void;
+    // (undocumented)
+    on<K extends keyof SongPlayerEvents>(event: K, handler: SongPlayerEvents[K]): () => void;
+    // (undocumented)
+    pause(): void;
+    play(fromBeat?: number): Promise<void>;
+    position(): number;
+    preview(trackId: string, pitch: number, duration?: number, velocity?: number): Promise<void>;
+    readonly ready: Promise<void>;
+    seconds(): number;
+    // (undocumented)
+    seek(beat: number): void;
+    // (undocumented)
+    setBpm(bpm: number): void;
+    // (undocumented)
+    setLoop(loop: SongLoop | null): void;
+    setMasterVolume(volume: number): void;
+    // (undocumented)
+    setTrackMute(trackId: string, mute: boolean): void;
+    // (undocumented)
+    setTrackPan(trackId: string, pan: number): void;
+    // (undocumented)
+    setTrackSolo(trackId: string, solo: boolean): void;
+    setTrackVolume(trackId: string, volume: number): void;
+    // (undocumented)
+    readonly state: SongPlayerState;
+    stop(): void;
+    update(definition: SongDefinition): Promise<void>;
+}
+
+// @public (undocumented)
+export interface SongPlayerEvents {
+    bar: (bar: number) => void;
+    beat: (beat: number) => void;
+    complete: () => void;
+    // (undocumented)
+    state: (state: SongPlayerState) => void;
+}
+
+// @public (undocumented)
+export interface SongPlayerOptions {
+    destination?: ToneNs.InputNode;
+    resolveUrl?: (url: string) => string;
+}
+
+// @public (undocumented)
+export type SongPlayerState = 'stopped' | 'playing' | 'paused';
+
+// @public (undocumented)
+export interface SongSchedule {
+    // (undocumented)
+    audio: ScheduledAudio[];
+    length: number;
+    // (undocumented)
+    notes: ScheduledNote[];
+}
+
+// @public (undocumented)
+export type SongTrack = Static<typeof SongTrackSchema>;
+
+// @public (undocumented)
+export const SongTrackSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TString;
+    kind: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"instrument">, _sinclair_typebox.TLiteral<"audio">]>;
+    instrumentId: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    color: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    volume: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    pan: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    mute: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    solo: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+}>;
+
 // @public (undocumented)
 export const SPHERE_TYPE: unique symbol;
 
@@ -3491,6 +4695,13 @@ export type StageConfigLike = Partial<{
 
 export { StageConfigPayload }
 
+// @public (undocumented)
+export interface StageCutsceneHostOptions {
+    onEvent?: (name: string, payload: Record<string, unknown>) => void;
+    resolveSong?: (ref: string) => SongDefinition | Promise<SongDefinition | undefined> | undefined;
+    transitionShader?: (type: SceneTransitionType) => ZylemTransitionShader | undefined;
+}
+
 export { StageDebugRender }
 
 // Warning: (ae-forgotten-export) The symbol "Entity" needs to be exported by the entry point public.d.ts
@@ -3695,6 +4906,42 @@ export const standardShader: {
 
 export { step }
 
+// @public (undocumented)
+export interface StrategyPanBehavior extends CameraBehavior {
+    setFollowKey(key: string | null): void;
+}
+
+// @public
+export interface StrategyPanInput {
+    pan?: {
+        x: number;
+        y: number;
+    };
+    // (undocumented)
+    pointer?: StrategyPointer;
+}
+
+// @public (undocumented)
+export interface StrategyPanOptions {
+    breakFollowOnPan?: boolean;
+    edgeMargin?: number;
+    edgeSpeed?: number;
+    followKey?: string | null;
+    followLerp?: number;
+    panSpeed?: number;
+    sampleInput?: () => StrategyPanInput;
+}
+
+// @public
+export interface StrategyPointer {
+    // (undocumented)
+    centered?: boolean;
+    // (undocumented)
+    x: number;
+    // (undocumented)
+    y: number;
+}
+
 export { SwatchApplyFailureReason }
 
 // @public
@@ -3711,6 +4958,9 @@ export { SwatchKind }
 
 export { SwatchSpec }
 
+// @public
+export type TargetLookup = (name: string) => Vec3Def | undefined;
+
 // @public
 export interface TemplateFactory<E extends GameEntity<O>, O extends GameEntityOptions = GameEntityOptions> {
     generate(count: number): E[];
@@ -3756,6 +5006,8 @@ export class ThirdPersonPerspective implements CameraPerspective {
     getBasePose(ctx: CameraContext): CameraPose;
     // (undocumented)
     readonly id = "third-person";
+    // (undocumented)
+    readonly projection: "perspective";
 }
 
 // Warning: (ae-forgotten-export) The symbol "ThrottleAction" needs to be exported by the entry point public.d.ts
@@ -3792,6 +5044,18 @@ export { tickCooldowns }
 
 export { time }
 
+// @public (undocumented)
+export type TimeSignature = Static<typeof TimeSignatureSchema>;
+
+// @public (undocumented)
+export const TimeSignatureSchema: _sinclair_typebox.TObject<{
+    numerator: _sinclair_typebox.TInteger;
+    denominator: _sinclair_typebox.TInteger;
+}>;
+
+// @public
+export type ToneModule = typeof ToneNs;
+
 export { TopDownMovementBehavior }
 
 export { TopDownMovementBehaviorOptions }
@@ -3806,6 +5070,30 @@ export { TopDownMovementInputComponent }
 
 export { TopDownMovementStateComponent }
 
+// @public
+export interface TopDownOptions {
+    height?: number;
+    initialLookAt?: Vec3Input;
+    initialPosition?: Vec3Input;
+    targetKey?: string;
+    zoom?: number;
+}
+
+// @public
+export class TopDownPerspective implements CameraPerspective {
+    constructor(options?: TopDownOptions);
+    // (undocumented)
+    readonly defaults: {
+        damping: number;
+    };
+    // (undocumented)
+    getBasePose(ctx: CameraContext): CameraPose;
+    // (undocumented)
+    readonly id = "top-down";
+    // (undocumented)
+    readonly projection: "orthographic";
+}
+
 export { TopDownShooterCoordinator }
 
 export { TopDownShooterEntity }
@@ -4019,6 +5307,11 @@ export type Vec3Components = {
 // @public
 export const Vec3ComponentsSchema: _sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>;
 
+// Warning: (ae-forgotten-export) The symbol "Vec3Schema" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type Vec3Def = Static<typeof Vec3Schema>;
+
 // Warning: (ae-forgotten-export) The symbol "Vec3Tuple" needs to be exported by the entry point public.d.ts
 //
 // @public (undocumented)
@@ -4653,7 +5946,7 @@ export type ZylemLineOptions = GameEntityOptions & {
 };
 
 // @public (undocumented)
-export class ZylemParticleSystem extends GameEntity<ZylemParticleSystemOptions> {
+export class ZylemParticleSystem extends GameEntity<ZylemParticleSystemOptions> implements SelectionBoundsProvider {
     constructor(options?: Partial<ZylemParticleSystemOptions>, initializeBehavior?: boolean);
     // (undocumented)
     __zylemParticleSystemEntity: true;
@@ -4661,6 +5954,7 @@ export class ZylemParticleSystem extends GameEntity<ZylemParticleSystemOptions>
     buildInfo(): Record<string, string>;
     // (undocumented)
     burst(): void;
+    getSelectionBounds(target: Box3): Box3 | null;
     // (undocumented)
     getSystem(): ParticleEmitterHandle_2['getSystem'] extends () => infer T ? T : null;
     // (undocumented)
@@ -4847,12 +6141,13 @@ export type ZylemTSLShader = {
 // Warning: (ae-forgotten-export) The symbol "CollisionHandlerDelegate" needs to be exported by the entry point public.d.ts
 //
 // @public (undocumented)
-export class ZylemZone extends GameEntity<ZylemZoneOptions> implements CollisionHandlerDelegate {
+export class ZylemZone extends GameEntity<ZylemZoneOptions> implements CollisionHandlerDelegate, SelectionBoundsProvider {
     constructor(options?: ZylemZoneOptions);
     // (undocumented)
     entered(other: any): void;
     // (undocumented)
     exited(delta: number, key: string): void;
+    getSelectionBounds(target: Box3): Box3 | null;
     // (undocumented)
     handleIntersectionEvent(input: {
         other: any;
@@ -4883,8 +6178,8 @@ export class ZylemZone extends GameEntity<ZylemZoneOptions> implements Collision
 // dist/entity-XqvuWgPm.d.ts:343:9 - (ae-forgotten-export) The symbol "EntityMeshBuilder" needs to be exported by the entry point public.d.ts
 // dist/entity-XqvuWgPm.d.ts:344:9 - (ae-forgotten-export) The symbol "EntityCollisionBuilder" needs to be exported by the entry point public.d.ts
 // dist/entity-XqvuWgPm.d.ts:345:9 - (ae-forgotten-export) The symbol "MaterialBuilder" needs to be exported by the entry point public.d.ts
-// dist/game-DyKbOeck.d.ts:1097:5 - (ae-forgotten-export) The symbol "StageAssetLoaderConfig" needs to be exported by the entry point public.d.ts
-// dist/game-DyKbOeck.d.ts:1796:5 - (ae-forgotten-export) The symbol "StageInterface" needs to be exported by the entry point public.d.ts
+// dist/game-D8KTP3fD.d.ts:258:5 - (ae-forgotten-export) The symbol "StageInterface" needs to be exported by the entry point public.d.ts
+// dist/stage-CAPlk_cN.d.ts:1117:5 - (ae-forgotten-export) The symbol "StageAssetLoaderConfig" needs to be exported by the entry point public.d.ts
 
 // (No @packageDocumentation comment for this package)