@zylem/game-lib 0.8.8 → 0.9.0

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

@@ -6,6 +6,7 @@
 
 import { abs } from 'three/tsl';
 import { announceBridgeReady } from '@zylem/bridge';
+import { applySwatchesToSelection } from '@zylem/bridge';
 import { asin } from 'three/tsl';
 import { atan } from 'three/tsl';
 import { BehaviorDescriptor } from '@zylem/behaviors';
@@ -27,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';
@@ -34,11 +36,13 @@ import { BridgeHandler } from '@zylem/bridge';
 import { GameLoadingPayload as BridgeLoadingPayload } from '@zylem/bridge';
 import { BridgeMessages } from '@zylem/bridge';
 import { BridgeMessageType } from '@zylem/bridge';
+import { BridgeNdc } from '@zylem/bridge';
 import { BridgePose } from '@zylem/bridge';
 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';
@@ -76,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';
@@ -94,7 +102,10 @@ import { emitRuntimeTriggerRegionEnter } from '@zylem/behaviors/runtime-2d';
 import { EntityApplySwatchPayload } from '@zylem/bridge';
 import { EntityDefinition } from '@zylem/behaviors/core';
 import { EntityHandle } from '@zylem/behaviors/core';
+import { EntityPickPayload } from '@zylem/bridge';
+import { EntityPickResultPayload } from '@zylem/bridge';
 import { EntitySummaryPayload } from '@zylem/bridge';
+import { EntitySwatchAppliedPayload } from '@zylem/bridge';
 import { EntityThumbnailPayload } from '@zylem/bridge';
 import { EntityTypeDescriptor } from '@zylem/bridge';
 import { exp } from 'three/tsl';
@@ -282,6 +293,7 @@ import { RuntimeTriggerRegion2DEvent } from '@zylem/behaviors/runtime-2d';
 import { RuntimeTriggerRegion2DHandle } from '@zylem/behaviors/runtime-2d';
 import { RuntimeTriggerRegion2DOptions } from '@zylem/behaviors/runtime-2d';
 import { Scene } from 'three';
+import { SceneOperationEntry } from '@zylem/bridge';
 import { SceneOperationPayload } from '@zylem/bridge';
 import { ScreenVisibilityBehavior } from '@zylem/behaviors';
 import { ScreenVisibilityChangeContext } from '@zylem/behaviors';
@@ -342,6 +354,10 @@ import { StageSnapshotPayload } from '@zylem/bridge';
 import { StageTopDownPlane } from '@zylem/behaviors/core';
 import { Static } from '@sinclair/typebox';
 import { step } from 'three/tsl';
+import { SwatchApplyFailureReason } from '@zylem/bridge';
+import { SwatchApplyResult } from '@zylem/bridge';
+import { SwatchKind } from '@zylem/bridge';
+import { SwatchSpec } from '@zylem/bridge';
 import { Texture } from 'three';
 import * as three from 'three';
 import { ThrusterBehavior } from '@zylem/behaviors';
@@ -356,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';
@@ -417,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;
 
@@ -438,6 +458,8 @@ export interface AnalogState {
 
 export { announceBridgeReady }
 
+export { applySwatchesToSelection }
+
 // Warning: (ae-forgotten-export) The symbol "TransformableEntity" needs to be exported by the entry point public.d.ts
 //
 // @public
@@ -459,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 }
@@ -510,6 +575,8 @@ export { BridgeMessages }
 
 export { BridgeMessageType }
 
+export { BridgeNdc }
+
 export { BridgeVec3 }
 
 // @public
@@ -591,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();
@@ -695,6 +783,36 @@ 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 (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);
@@ -720,6 +838,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;
 
@@ -814,6 +935,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
@@ -853,6 +977,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 +1047,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)
@@ -935,6 +1065,9 @@ export function createSprite(...args: Array<SpriteOptions>): ZylemSprite;
 // @public
 export function createStage(...options: StageOptions): Stage;
 
+// @public (undocumented)
+export function createStageCutsceneHost(stageLike: CutsceneStageLike, options?: StageCutsceneHostOptions): CutsceneHost;
+
 // Warning: (ae-forgotten-export) The symbol "TextOptions" needs to be exported by the entry point public.d.ts
 //
 // @public (undocumented)
@@ -967,6 +1100,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;
 
@@ -980,6 +1556,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;
 
@@ -1056,16 +1635,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)
@@ -1164,6 +1779,10 @@ export const EntityJsonSchema: _sinclair_typebox.TUnion<[_sinclair_typebox.TObje
     data: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnknown>>;
 }>]>;
 
+export { EntityPickPayload }
+
+export { EntityPickResultPayload }
+
 // @public
 export const EntitySchema: _sinclair_typebox.TObject<{
     id: _sinclair_typebox.TString;
@@ -1179,6 +1798,8 @@ export function entitySpawner(factory: (x: number, y: number) => Promise<any> |
 
 export { EntitySummaryPayload }
 
+export { EntitySwatchAppliedPayload }
+
 // @public
 export class EntityThumbnailCache {
     constructor(size?: number, maxEntries?: number);
@@ -1253,9 +1874,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();
@@ -1265,6 +1907,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 }
@@ -1394,6 +2070,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)
@@ -1462,6 +2141,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;
@@ -1485,8 +2166,20 @@ export class GameBridge {
 // @public
 export interface GameBridgeHost {
     applySceneOperation?(op: SceneOperationPayload, direction: 'undo' | 'redo'): void;
-    applySwatch?(payload: EntityApplySwatchPayload): void;
+    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;
 }
@@ -1702,6 +2395,7 @@ export class GameEntity<O extends GameEntityOptions> extends BaseNode<O> impleme
     protected eventDelegate: EventEmitterDelegate<EntityEvents>;
     // (undocumented)
     finalizeCloneSupport(factory: (options?: Partial<O>) => GameEntity<O>): this;
+    getBehaviorRef<O extends Record<string, any>>(descriptor: BehaviorDescriptor_2<O, any>): BehaviorRef_2<O> | null;
     getBehaviorRefs(): BehaviorRef_2[];
     // (undocumented)
     getCollisionCallbacks(): Array<(params: CollisionContext<this, O>) => void>;
@@ -1709,6 +2403,7 @@ export class GameEntity<O extends GameEntityOptions> extends BaseNode<O> impleme
     //
     // (undocumented)
     getCollisionRegistrations(): Array<CollisionRegistration<this, O>>;
+    getMaterials(): Material[];
     getPose(): {
         position: Vec3;
         rotation: {
@@ -1727,6 +2422,9 @@ export class GameEntity<O extends GameEntityOptions> extends BaseNode<O> impleme
     getVelocity: () => Vector | null;
     // (undocumented)
     group: Group | undefined;
+    // (undocumented)
+    hasBehavior(descriptor: BehaviorDescriptor_2<any, any>): boolean;
+    hasMaterial(): boolean;
     instanceId: number;
     isBundled: boolean;
     isInstanced: boolean;
@@ -1762,8 +2460,13 @@ export class GameEntity<O extends GameEntityOptions> extends BaseNode<O> impleme
     // (undocumented)
     physicsAttached: boolean;
     physicsWorldRef: unknown;
+    removeBehavior(target: BehaviorDescriptor_2<any, any> | BehaviorRef_2<any>): BehaviorRef_2<any> | null;
+    replaceMaterials(materials: Material[], settings?: {
+        disposePrevious?: boolean;
+    }): Material[] | null;
     // (undocumented)
     resetVelocity: () => void;
+    restoreBehaviorRef(ref: BehaviorRef_2<any>): void;
     reveal(): void;
     // (undocumented)
     rotateEuler: (eulerRotation: Vector3) => void;
@@ -1780,6 +2483,10 @@ export class GameEntity<O extends GameEntityOptions> extends BaseNode<O> impleme
     runAction<A extends Action>(action: A): A;
     runtimeAttached: boolean;
     runtimeHandle: number;
+    // Warning: (ae-forgotten-export) The symbol "MaterialOptions" needs to be exported by the entry point public.d.ts
+    setMaterial(options: Partial<MaterialOptions>, settings?: {
+        disposePrevious?: boolean;
+    }): Material[] | null;
     setPose(input: {
         position?: Vec3Input;
         rotation?: {
@@ -2104,6 +2811,9 @@ export { GameToEditorMessages }
 
 export { GameVariablePayload }
 
+// @public
+export function getActiveSongPlayer(): SongPlayer | null;
+
 export { getCooldown }
 
 export { getCooldownStore }
@@ -2278,9 +2988,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;
 
@@ -2302,6 +3067,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;
 
@@ -2359,6 +3129,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;
 
@@ -2418,11 +3194,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 }
@@ -2507,6 +3295,26 @@ export function normalizeVec2(input?: Vec2Input | null, defaults?: Vec2Input | P
 // @public (undocumented)
 export function normalizeVec3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vec3Components;
 
+// @public (undocumented)
+export type NoteClip = Static<typeof NoteClipSchema>;
+
+// @public (undocumented)
+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";
 
@@ -2553,9 +3361,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;
 
@@ -2596,6 +3413,18 @@ export { ParticlePresetMaterialOptions }
 
 export { particlePresets }
 
+// @public
+export interface PcmSource {
+    // (undocumented)
+    getChannelData(channel: number): Float32Array;
+    // (undocumented)
+    length: number;
+    // (undocumented)
+    numberOfChannels: number;
+    // (undocumented)
+    sampleRate: number;
+}
+
 // @public
 export type PerspectiveOptions = ThirdPersonOptions | Fixed2DOptions | FirstPersonOptions;
 
@@ -2726,6 +3555,9 @@ export { PrebakeWorkerRequest }
 
 export { PrebakeWorkerResponse }
 
+// @public
+export function previousShot(definition: CutsceneDefinition, shot: CameraShot): CameraShot | undefined;
+
 // @public (undocumented)
 export const PYRAMID_TYPE: unique symbol;
 
@@ -2787,6 +3619,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)
@@ -2856,6 +3701,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;
 
@@ -3044,6 +3892,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';
 
@@ -3095,6 +4003,27 @@ export { ScreenWrapOptions }
 
 export { ScreenWrapState }
 
+// @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
@@ -3106,6 +4035,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;
 
@@ -3219,6 +4151,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
@@ -3324,6 +4264,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;
 
@@ -3454,6 +4606,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
@@ -3658,6 +4817,25 @@ export const standardShader: {
 
 export { step }
 
+export { SwatchApplyFailureReason }
+
+// @public
+export interface SwatchApplyOutcome {
+    // (undocumented)
+    entries: SceneOperationEntry[];
+    // (undocumented)
+    results: SwatchApplyResult[];
+}
+
+export { SwatchApplyResult }
+
+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[];
@@ -3739,6 +4917,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 }
@@ -3966,6 +5156,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)
@@ -4600,7 +5795,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;
@@ -4608,6 +5803,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)
@@ -4794,12 +5990,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;
@@ -4823,16 +6020,15 @@ export class ZylemZone extends GameEntity<ZylemZoneOptions> implements Collision
 
 // Warnings were encountered during analysis:
 //
-// dist/entity-XZNGBeca.d.ts:332:5 - (ae-forgotten-export) The symbol "RenderCategory_2" needs to be exported by the entry point public.d.ts
-// dist/entity-XZNGBeca.d.ts:333:5 - (ae-forgotten-export) The symbol "RuntimeEntityOptions" needs to be exported by the entry point public.d.ts
-// dist/entity-XZNGBeca.d.ts:334:5 - (ae-forgotten-export) The symbol "CollisionOptions" needs to be exported by the entry point public.d.ts
-// dist/entity-XZNGBeca.d.ts:335:5 - (ae-forgotten-export) The symbol "MaterialOptions" needs to be exported by the entry point public.d.ts
-// dist/entity-XZNGBeca.d.ts:343:9 - (ae-forgotten-export) The symbol "IBuilder" needs to be exported by the entry point public.d.ts
-// dist/entity-XZNGBeca.d.ts:343:9 - (ae-forgotten-export) The symbol "EntityMeshBuilder" needs to be exported by the entry point public.d.ts
-// dist/entity-XZNGBeca.d.ts:344:9 - (ae-forgotten-export) The symbol "EntityCollisionBuilder" needs to be exported by the entry point public.d.ts
-// dist/entity-XZNGBeca.d.ts:345:9 - (ae-forgotten-export) The symbol "MaterialBuilder" needs to be exported by the entry point public.d.ts
-// dist/game-BPOr7zTB.d.ts:1060:5 - (ae-forgotten-export) The symbol "StageAssetLoaderConfig" needs to be exported by the entry point public.d.ts
-// dist/game-BPOr7zTB.d.ts:1735:5 - (ae-forgotten-export) The symbol "StageInterface" needs to be exported by the entry point public.d.ts
+// dist/entity-XqvuWgPm.d.ts:332:5 - (ae-forgotten-export) The symbol "RenderCategory_2" needs to be exported by the entry point public.d.ts
+// dist/entity-XqvuWgPm.d.ts:333:5 - (ae-forgotten-export) The symbol "RuntimeEntityOptions" needs to be exported by the entry point public.d.ts
+// dist/entity-XqvuWgPm.d.ts:334:5 - (ae-forgotten-export) The symbol "CollisionOptions" needs to be exported by the entry point public.d.ts
+// dist/entity-XqvuWgPm.d.ts:343:9 - (ae-forgotten-export) The symbol "IBuilder" needs to be exported by the entry point public.d.ts
+// 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-9PjI5z2p.d.ts:258:5 - (ae-forgotten-export) The symbol "StageInterface" needs to be exported by the entry point public.d.ts
+// dist/stage-BuGkjZnr.d.ts:997:5 - (ae-forgotten-export) The symbol "StageAssetLoaderConfig" needs to be exported by the entry point public.d.ts
 
 // (No @packageDocumentation comment for this package)