@threenative/core 0.3.1 → 0.3.3

package/dist/index.d.ts

@@ -1,23 +1,221 @@
 import * as three from 'three';
-import { AnimationMixer, Object3D, AnimationClip, Camera, Vector3, Group, Matrix4, Mesh, BufferGeometry, Material, InstancedMesh, ColorRepresentation, Box3, Scene, DirectionalLight, Sprite, DataTexture, CatmullRomCurve3, Texture } from 'three';
-export { I as IAssetLoader, a as IAssetLoaderOptions, c as createAssetLoader, r as reconcileMirroredClips } from './assets-kyoF7JlJ.js';
-export { A as AudioBus, I as IAudioBusOptions, b as IAudioPlayOptions } from './audio-BFiGneTL.js';
-export { C as CanvasLayer } from './canvas-layer-BLVijiUJ.js';
-import { a as IGamePluginRuntime, b as IGamePluginHooks } from './game-XGrTzapq.js';
-export { A as AfterPhysicsCallback, C as ContextMenuPolicy, c as ICtx, I as IGame, d as IGameObservationContribution, e as IGameObservationSampleRequest, f as IGamePlatformSource, g as IInputAction, h as IInputGamepad, i as IPointerDragHandle, j as IPointerEvent3D, k as IPointerEvents3D, l as IPointerEvents3DOptions, m as IPointerEvents3DPicker, n as IPointerState, o as IRandom, p as IRawInputPointer, q as IRawInputPointerEdge, r as IRawInputState, s as IRaycastOptions, t as IScenePickerOptions, u as IThreeNativeAudioConfig, v as IThreeNativeAudioLoop, w as IThreeNativeAudioOverride, x as IThreeNativeAudioSpectrum, y as IThreeNativeBootSplash, z as IThreeNativeConfig, B as IThreeNativeIconVariants, D as IThreeNativeTexturesConfig, E as ITweenOptions, F as IWarmUpCacheOptions, G as IWarmUpObservation, H as IWarmUpOptions, J as IWarmUpProgress, K as IWarmUpRenderer, L as IWarmUpReport, M as InputBindings, N as InputPlatformSource, P as PointerEvent3DListener, O as PointerEvent3DType, Q as PointerEvents3D, S as Scene, R as SceneFrame, T as ScenePicker, U as ScheduleHandle, V as Scheduler, W as ThreeNativeBackgroundMode, X as ThreeNativeOrientation, Y as ThreeNativeUiRenderer, Z as WarmUpCacheStatus, _ as WarmUpObservationStatus, $ as afterPhysics, a0 as createRandom, a1 as defineGame, a2 as warmUpScene } from './game-XGrTzapq.js';
+import { Object3D, AnimationClip, AnimationMixer, Camera, Vector3, Group, Matrix4, Mesh, BufferGeometry, Material, InstancedMesh, ColorRepresentation, Box3, Scene, DirectionalLight, Sprite, DataTexture, CatmullRomCurve3, Texture } from 'three';
+export { I as IAssetLoader, a as IAssetLoaderOptions, c as createAssetLoader, r as reconcileMirroredClips } from './assets-CYKk2WTu.js';
+export { A as AudioBus, I as IAudioBusOptions, b as IAudioPlayOptions, r as resetAudioCueLedger } from './audio-7i3Xl0l3.js';
+export { C as CanvasLayer } from './canvas-layer-C1SnMoJ-.js';
+import { a as IGamePluginRuntime, b as IGamePluginHooks } from './game-D_6r-k4Y.js';
+export { A as AfterPhysicsCallback, C as ContextMenuPolicy, G as GEOMETRY_ASSET_KEY, c as GEOMETRY_CAPTURE_DEFAULT_LIMIT, d as GEOMETRY_CAPTURE_MAX_LIMIT, e as GEOMETRY_CAPTURE_SORTS, f as GEOMETRY_CAPTURE_TIMEOUT_MS, g as GEOMETRY_CAPTURE_WALK_CAP, h as GeometryCaptureSort, i as ICtx, I as IGame, j as IGameObservationContribution, k as IGameObservationSampleRequest, l as IGamePlatformSource, m as IGeometryCaptureAsset, n as IGeometryCaptureMesh, o as IGeometryCapturePass, p as IGeometryCaptureReport, q as IGeometryCaptureRequest, r as IGeometryCaptureRow, s as IInputAction, t as IInputGamepad, u as IPointerDragHandle, v as IPointerEvent3D, w as IPointerEvents3D, x as IPointerEvents3DOptions, y as IPointerEvents3DPicker, z as IPointerState, B as IRandom, D as IRawInputPointer, E as IRawInputPointerEdge, F as IRawInputState, H as IRaycastOptions, J as IScenePickerOptions, K as IThreeNativeAudioConfig, L as IThreeNativeAudioLoop, M as IThreeNativeAudioOverride, N as IThreeNativeAudioSpectrum, O as IThreeNativeBootSplash, P as IThreeNativeConfig, Q as IThreeNativeIconVariants, R as IThreeNativeLodConfig, S as IThreeNativeLodGenerationConfig, T as IThreeNativeLodOverride, U as IThreeNativeLodRuntimeConfig, V as IThreeNativeTexturesConfig, W as ITweenOptions, X as IWarmUpCacheOptions, Y as IWarmUpObservation, Z as IWarmUpOptions, _ as IWarmUpProgress, $ as IWarmUpRenderer, a0 as IWarmUpReport, a1 as InputBindings, a2 as InputPlatformSource, a3 as PointerEvent3DListener, a4 as PointerEvent3DType, a5 as PointerEvents3D, a6 as Scene, a7 as SceneFrame, a8 as ScenePicker, a9 as ScheduleHandle, aa as Scheduler, ab as ThreeNativeBackgroundMode, ac as ThreeNativeLodMinTrianglesScope, ad as ThreeNativeLodPreset, ae as ThreeNativeOrientation, af as ThreeNativeUiRenderer, ag as WarmUpCacheStatus, ah as WarmUpObservationStatus, ai as afterPhysics, aj as createRandom, ak as defineGame, al as warmUpScene } from './game-D_6r-k4Y.js';
 import * as three_webgpu from 'three/webgpu';
 import { StorageTexture, ComputeNode, UniformNode, Node, TextureNode, NodeMaterial, StorageBufferNode, StructTypeNode, Data3DTexture, ShadowBaseNode, NodeBuilder, NodeFrame, SpriteNodeMaterial, StorageTextureNode } from 'three/webgpu';
-import { I as IRendererLike } from './renderer-C6hqZpoG.js';
-export { D as DEFAULT_PIPELINE_CENSUS_LIMIT, F as FRAME_BUDGET_MARKER, a as FRAME_BUDGET_PHASES, b as FRAME_HITCH_MARKER, c as FrameBudget, d as FrameBudgetPhase, e as IFrameBudgetOptions, f as IFrameBudgetSummary, g as IFrameBudgetWindow, h as IFramePhaseSample, i as IPipelineCensus, j as IPipelineCensusCounts, k as IPipelineCensusEvent, l as IPipelineCensusOptions, m as IPipelineProvenance, n as IPipelineShaderObservation, o as IRenderChainApplied, p as IRenderChainBudgetWindow, q as IRenderChainDroppedStage, r as IRenderChainOptions, s as IRenderChainRenderer, t as IRenderChainRequest, u as IRenderChainStage, v as IRenderChainStageContext, w as IRenderChainVelocityMeasurement, x as IRenderChainVelocityReport, y as IRenderChainVelocityRequest, z as IRenderChainVelocityResult, A as IVelocityRenderPass, P as PIPELINE_CENSUS_CAPABILITY, B as PIPELINE_CENSUS_VERSION, C as PipelineCensus, E as PipelineCensusMode, G as PipelineCensusStatus, R as RENDER_CHAIN_MARKER, H as RENDER_CHAIN_STAGE_ORDER, J as RENDER_CHAIN_TIERS, K as RenderChain, L as RenderChainSource, M as RenderChainStageId, N as RenderChainStageName, O as RenderChainTier, Q as RenderChainTierRequest, S as RenderChainVelocitySource, V as VELOCITY_OUTPUT_NAME, T as VELOCITY_PREVIOUS_BONE_MATRICES, U as VELOCITY_PREVIOUS_INSTANCE_MATRICES, W as VELOCITY_PREVIOUS_WORLD_MATRIX, X as VelocityTracker, Y as createPipelineCensus, Z as ensureVelocityOutput, _ as prewarm, $ as readRenderChainObservation, a0 as readRenderChainReport, a1 as readVelocityPreviousBoneMatrices, a2 as readVelocityPreviousMatrices, a3 as readVelocityPreviousWorldMatrix, a4 as velocityTexture, a5 as withVelocityContext } from './renderer-C6hqZpoG.js';
-import { I as IComputeDriven$1, a as IGPUReadbackSample } from './gpu-readback-D2iRvoe9.js';
-export { C as ComputeDrivenRegistry, G as GPUReadback, b as IGPUReadbackOptions } from './gpu-readback-D2iRvoe9.js';
+import { I as IRendererLike, F as FramePassKind, a as IFrameBudgetWindow } from './renderer-Cy4qeBOA.js';
+export { D as DEFAULT_PIPELINE_CENSUS_LIMIT, b as FRAME_BUDGET_MARKER, c as FRAME_BUDGET_PHASES, d as FRAME_HITCH_MARKER, e as FrameBudget, f as FrameBudgetPhase, g as FrameCounters, h as ICounterDevice, i as IFrameBudgetOptions, j as IFrameBudgetPassSummary, k as IFrameBudgetSummary, l as IFrameCounters, m as IFramePhaseSample, n as IPipelineCensus, o as IPipelineCensusCounts, p as IPipelineCensusEvent, q as IPipelineCensusOptions, r as IPipelineProvenance, s as IPipelineShaderObservation, t as IRenderChainApplied, u as IRenderChainBudgetWindow, v as IRenderChainDroppedStage, w as IRenderChainOptions, x as IRenderChainRenderer, y as IRenderChainRequest, z as IRenderChainStage, A as IRenderChainStageContext, B as IRenderChainVelocityMeasurement, C as IRenderChainVelocityReport, E as IRenderChainVelocityRequest, G as IRenderChainVelocityResult, H as IRenderPassSample, J as IVelocityRenderPass, P as PIPELINE_CENSUS_CAPABILITY, K as PIPELINE_CENSUS_VERSION, L as PipelineCensus, M as PipelineCensusMode, N as PipelineCensusStatus, R as RENDER_CHAIN_MARKER, O as RENDER_CHAIN_STAGE_ORDER, Q as RENDER_CHAIN_TIERS, S as RenderChain, T as RenderChainSource, U as RenderChainStageId, V as RenderChainStageName, W as RenderChainTier, X as RenderChainTierRequest, Y as RenderChainVelocitySource, Z as VELOCITY_OUTPUT_NAME, _ as VELOCITY_PREVIOUS_BONE_MATRICES, $ as VELOCITY_PREVIOUS_INSTANCE_MATRICES, a0 as VELOCITY_PREVIOUS_WORLD_MATRIX, a1 as VelocityTracker, a2 as counterDeviceOf, a3 as createPipelineCensus, a4 as ensureVelocityOutput, a5 as prewarm, a6 as readRenderChainObservation, a7 as readRenderChainReport, a8 as readVelocityPreviousBoneMatrices, a9 as readVelocityPreviousMatrices, aa as readVelocityPreviousWorldMatrix, ab as velocityTexture, ac as withVelocityContext } from './renderer-Cy4qeBOA.js';
+import { I as IComputeDriven$1, a as IGPUReadbackSample } from './gpu-readback-CMklJs6r.js';
+export { C as ComputeDrivenRegistry, G as GPUReadback, b as IGPUReadbackOptions } from './gpu-readback-CMklJs6r.js';
 import { Node as Node$1 } from 'three/src/nodes/Nodes.js';
 import 'zustand/vanilla';
 
+/**
+ * Nested cost spans across the render phase, default-off.
+ *
+ * The frame budget names six phases and one of them — `render` — is 16.1 ms of a 20.2 ms frame
+ * while every engine-owned thing inside it sums to under 1.5 ms. A phase that big with nothing
+ * inside it is not a measurement, it is a question, and four ranked optimisation options were
+ * priced against four different answers to it. This is the instrument that answers it: a span tree
+ * whose leaves are the parts of the render phase, with the leftover computed rather than assumed.
+ *
+ * Three properties make it trustworthy enough to price work against:
+ *
+ *  - **The residual is arithmetic, not a category.** Every non-leaf reports its own duration minus
+ *    the durations of the spans it contains, so an unmeasured part shows up as a number instead of
+ *    being quietly filed under "other". A child that outlives its parent reports a negative
+ *    residual rather than being clamped to zero, because a negative residual means the nesting is
+ *    wrong and a clamped one means nothing at all.
+ *  - **It is default-off and costs one guarded return when off.** `TN_FRAME_SPANS=1` installs it;
+ *    unset, every call site is `if (recorder === undefined) return;` with no clock read.
+ *  - **Nothing here decides anything.** It measures the path that exists. It does not select a
+ *    renderer, a traversal strategy or a pass order, and no number it produces is evidence for
+ *    owning the renderer.
+ *
+ * The ids are integers on the hot path — a span call must not allocate a string to be cheap enough
+ * to put around a per-draw call — and the names exist only in the report.
+ */
+/** Marker printed once per report window when spans are installed. */
+declare const SPANS_MARKER = "TN_FRAME_SPANS";
+/**
+ * The launch flag that installs the spans. Off by default: this is a diagnostic that adds work to
+ * the frame it measures, so a game must ask for it.
+ */
+declare const SPANS_FLAG = "TN_FRAME_SPANS";
+/**
+ * Every span, in the order the report prints them. Integers, because `beginSpan` runs per draw.
+ *
+ * `pass` and its nested kinds are one id per render call three makes, not one per camera: three
+ * renders the main camera first and the shadow and reflection cameras from inside that call, so
+ * the nesting is the renderer's own and a flat list of passes would have to invent a relationship
+ * the measurement already has.
+ */
+declare const SPANS: {
+    /** Compute-driven render work dispatched by the engine before the world render. */
+    readonly compute: 0;
+    /** The engine's own `beforeRender` seam, where a game prepares the scene it is about to draw. */
+    readonly beforeRender: 1;
+    /** The scene-graph matrix walk. */
+    readonly sceneUpdate: 2;
+    /** The projection's reconcile, when one is installed. */
+    readonly reconcile: 3;
+    /** Virtual-geometry clustered mesh update. */
+    readonly clustered: 4;
+    /** Automatic discrete LOD selection. */
+    readonly lod: 5;
+    /** The projected-size cull, apply and restore together. */
+    readonly cull: 6;
+    /** The main camera's render call. */
+    readonly mainPass: 7;
+    /** A nested render call three names as a shadow map. */
+    readonly shadowPass: 8;
+    /** A nested render call three names as a reflector. */
+    readonly reflectionPass: 9;
+    /** Any other nested render call. */
+    readonly nestedPass: 10;
+    /** Render-list construction inside a render call. */
+    readonly projectObject: 11;
+    /** Render-list sort inside a render call. */
+    readonly sort: 12;
+    /** Per-draw submission inside a render call, accumulated across the draws of one pass. */
+    readonly draw: 13;
+};
+type SpanId = (typeof SPANS)[keyof typeof SPANS];
+/** Names, indexed by id. The only place a span name is a string. */
+declare const SPAN_NAMES: readonly string[];
+declare const SPAN_COUNT: number;
+/** One span's cost across a reported window. */
+interface ISpanSummary {
+    /** Frames in the window that entered this span at least once. */
+    readonly frames: number;
+    /** Entries per frame, mean over the frames that entered it. */
+    readonly perFrame: number;
+    readonly mean: number;
+    readonly p50: number;
+    readonly p95: number;
+    readonly max: number;
+    /**
+     * This span's own time minus the time of the spans inside it, at p50.
+     *
+     * Negative when a child outlived its parent, which means the nesting is wrong. Never clamped: a
+     * clamped residual reads as a complete attribution, and this is the number that says whether the
+     * attribution is complete.
+     */
+    readonly residualP50: number;
+}
+/**
+ * One reported window of the span tree.
+ *
+ * `residual` is the render phase's own cost with every top-level span subtracted — the number this
+ * instrument exists to shrink. `coverage` is its complement as a fraction of the phase, and a
+ * reader that sees 0.68 is being told that a third of the phase is still unmeasured.
+ */
+interface ISpanWindow {
+    readonly window: number;
+    readonly frames: number;
+    /** The render phase as the frame budget charged it, at p50. */
+    readonly renderMs: number;
+    readonly residualMs: number;
+    readonly coverage: number;
+    /** Frames whose span nesting exceeded `MAX_DEPTH`, whose residual is therefore incomplete. */
+    readonly overflowed: number;
+    readonly spans: Readonly<Record<string, ISpanSummary>>;
+}
+/**
+ * Accumulates a nested span tree, one frame at a time, and reports it windowed.
+ *
+ * The owner brackets a frame with `beginFrame` and `endFrame`; the render phase's own duration is
+ * handed in at the close rather than measured here, so the root residual is arithmetic against the
+ * number the frame budget already reports and cannot drift from it.
+ *
+ * Nesting is strict: `end(id)` must name the span `begin(id)` opened. A mismatch throws, because a
+ * tree whose parentage is wrong produces a residual that is confidently wrong, and that is worse
+ * than a loud failure in a mode a game opted into.
+ */
+declare class SpanRecorder {
+    #private;
+    readonly capacity: number;
+    constructor(capacity?: number);
+    /** Opens a span. Returns false when the tree is already at `MAX_DEPTH` and the span is dropped. */
+    begin(id: SpanId, now: number): boolean;
+    /** Closes the span `begin` opened. Throws when it names a different span. */
+    end(id: SpanId, now: number): void;
+    /**
+     * Adds `ms` to a span that is entered many times per frame — a per-draw call, or a call site that
+     * cannot be bracketed. Counts as one entry and attributes to the enclosing span exactly as a
+     * bracketed one would.
+     */
+    add(id: SpanId, ms: number): void;
+    /** How many spans are currently open. Zero outside a frame's own work. */
+    get depth(): number;
+    /**
+     * Throws a half-open frame away without recording it.
+     *
+     * A frame that failed mid-render has a span stack that cannot be closed honestly, and recording
+     * it would put a fabricated zero in the window. The loop abandons it instead, so the window only
+     * ever reports frames whose spans all closed.
+     */
+    abandonFrame(): void;
+    /** Records the frame's totals against the render phase the frame budget charged. */
+    endFrame(renderPhaseMs: number): void;
+    /** The window just closed, or `undefined` when no frame was recorded in it. */
+    window(): ISpanWindow | undefined;
+}
+/** Installs or removes the recorder every `beginSpan`/`endSpan` routes to. */
+declare function setSpanRecorder(next: SpanRecorder | undefined): void;
+declare function spanRecorder(): SpanRecorder | undefined;
+/** The one clock the spans and the frame budget share, so their numbers are comparable. */
+declare function spanNow(): number;
+/**
+ * Opens a span. One guarded return when spans are off — no clock read, no allocation, no branch on
+ * anything but the recorder's own presence.
+ */
+declare function beginSpan(id: SpanId): void;
+declare function endSpan(id: SpanId): void;
+/** Adds an already-measured duration to a span entered many times per frame. */
+declare function addSpan(id: SpanId, ms: number): void;
+/**
+ * Whether `TN_FRAME_SPANS` asks for spans on this launch.
+ *
+ * Three ways in, because the three launches have three different seams and none of them is
+ * `import.meta.env` (Vite replaces that at build time, and a measurement flag must be settable
+ * without rebuilding the game): a native host forwards `TN_FRAME_SPANS` through `process.env`, a
+ * browser page carries `?tnFrameSpans=1` in its URL, and any harness can set
+ * `globalThis.__tnFrameSpans` before the game boots.
+ */
+declare function spansRequested(): boolean;
+/** The window as the marker line prints it. */
+declare function formatSpansWindow(window: ISpanWindow): string;
+
+/** A stride measured at unit world scale, so uniformly scaled clones can share it. */
+interface ISharedStride {
+    /** Metres of ground per clip-second at rate 1, per unit of uniform world scale. */
+    readonly groundSpeed: number;
+    readonly inPlace: boolean;
+}
+declare class RigPreparation {
+    #private;
+    /** The cached binding count for an equivalent preparation, or `undefined` on a miss. */
+    boundCount(source: Object3D, clip: AnimationClip): number | undefined;
+    rememberBound(source: Object3D, clip: AnimationClip, bound: number): void;
+    /** The cached unit-scale stride for an equivalent, fully covered clip, or `undefined`. */
+    stride(source: Object3D, clip: AnimationClip): ISharedStride | undefined;
+    rememberStride(source: Object3D, clip: AnimationClip, stride: ISharedStride): void;
+}
+
 interface IAnimationPlayerOptions {
     readonly clips: readonly AnimationClip[];
     readonly root: Object3D;
     readonly requiredClips?: readonly string[] | Readonly<Record<string, string>>;
+    /**
+     * Shared preparation for clones of one source rig. Set by `SkeletalMesh3D`; a standalone
+     * player leaves it undefined and keeps the per-instance binding audit and stride sample.
+     */
+    readonly preparation?: RigPreparation;
     /**
      * Match a travelling clip's playback rate to the ground the body actually covers.
      *
@@ -192,6 +390,37 @@ declare class CameraShake {
     update(dt: number): ICameraShakeOffset;
 }
 
+/**
+ * Why a launch stopped, said where the player can read it.
+ *
+ * A launch has exactly two ways to go wrong quietly, and both were measured on a real game:
+ * progress stops moving (a decode that never returns, an asset that never settles) and the GPU
+ * device is lost (another process had taken 94% of VRAM). In both the loop keeps iterating, the
+ * loading layer keeps painting, and the only account of what happened is a line on stdout — which
+ * a player does not have, and which a bug report therefore never carries.
+ *
+ * So the failure is reported as text, once, through `onLaunchFailure` — and core stops there. Core
+ * cannot draw it: on the native host `document` is a Three.js compatibility stub whose
+ * `appendChild` is a no-op, so an overlay written here would be invisible on exactly the target
+ * that needs it. The page owns the presentation (and the copy-to-clipboard button players are
+ * asked for when they report a launch that hung); this owns the noticing and the wording.
+ */
+/** What failed. `stalled` is "no progress for a while"; `device-lost` is the GPU going away. */
+type LaunchFailureKind = "stalled" | "device-lost";
+interface ILaunchFailure {
+    readonly kind: LaunchFailureKind;
+    /** One human sentence, already naming the numbers — this is what the Copy button copies. */
+    readonly message: string;
+}
+/**
+ * Called for every launch failure the engine notices, with the message to show the player.
+ *
+ * @situation show the player why the game stopped loading instead of leaving the loading screen up
+ * @situation report a stalled launch or a lost GPU device in the game's own UI
+ * @example const off = onLaunchFailure((failure) => shell.loading({ failure: failure.message }));
+ */
+declare function onLaunchFailure(listener: (failure: ILaunchFailure) => void): () => void;
+
 type AtmosphereRgb = readonly [number, number, number];
 type AtmosphereVector = AtmosphereRgb | Readonly<{
     x: number;
@@ -593,9 +822,20 @@ interface IMergePart {
 interface IMergePartsOptions {
     /** Named in the error when the merge is refused. Say what was being built. */
     readonly label: string;
+    /**
+     * Channels to keep from each part besides `position`. Absent or empty keeps today's
+     * position-only merge, whose normals are recomputed from the merged result.
+     *
+     * `"normal"` keeps each part's authored normals, transformed by the part's placement matrix
+     * (the inverse-transpose normal matrix) and **never** recomputed. `"uv"` keeps each part's
+     * texture coordinates verbatim — the placement matrix moves position and normal, so UV values
+     * are retained unchanged. A part that does not carry a listed channel refuses the merge.
+     */
+    readonly preserve?: readonly ("uv" | "normal")[];
 }
 /**
- * Merge game-authored pieces into one buffer, keeping each piece's own colour.
+ * Merge game-authored pieces into one buffer, keeping each piece's own colour and, when asked,
+ * its uv and authored normals.
  *
  * Two things go wrong every time an agent bakes a building, a ship or a character out of
  * primitives, and neither is about how any of it looks. `mergeGeometries` returns `null` on
@@ -603,7 +843,9 @@ interface IMergePartsOptions {
  * a hundred indexed primitives — is invisible until the whole scene is missing; and a merged
  * buffer draws with one surface, so per-piece colour is gone unless every piece carries a flat
  * `color` attribute written before the merge. Writing that attribute is mechanical. The colours
- * are entirely the game's, one per part, and changing them changes nothing here.
+ * are entirely the game's, one per part, and changing them changes nothing here. By default the
+ * merged normals are recomputed from the merged buffer; `preserve` keeps the authored normals and
+ * texture coordinates instead so an imported model's shading survives the bake.
  */
 declare function mergeParts(parts: Iterable<IMergePart>, options: IMergePartsOptions): BufferGeometry;
 
@@ -686,8 +928,9 @@ declare class ClusteredMesh extends Mesh {
  * Takes every clustered mesh and every clustered batch under `root` through this frame's cut.
  *
  * The engine calls this itself, once a frame, before the render — virtual geometry ships on and a
- * game that has to remember to call something has not been given it. A scene holding neither costs
- * one traversal that finds nothing.
+ * game that has to remember to call something has not been given it. The first call censuses the
+ * root once and subscribes to its graph events; later calls walk only the clustered meshes and
+ * batch roots themselves, so a scene holding neither costs a map lookup.
  *
  * @returns triangles the clustered meshes and batches will submit.
  */
@@ -772,6 +1015,420 @@ declare class ClusteredBatch {
     update(camera: Camera, viewportHeight: number): number;
 }
 
+/** The LOD0 geometry of a mesh under a discrete chain, or the mesh's own geometry otherwise. */
+declare function baseGeometryOf(mesh: Mesh): BufferGeometry;
+/**
+ * Takes every discrete-LOD mesh under `root` through this frame's selection.
+ *
+ * The engine calls this itself, once a frame, after matrices are synced and before the render.
+ * Multi-view callers that need the finest level across passes use {@link selectLodLevel} directly;
+ * this entry point selects for the one camera it is handed — which is the main view, and is at
+ * least as fine as a shadow pass of lower resolution needs.
+ *
+ * @returns triangles the managed meshes will submit this frame.
+ */
+declare function updateModelLods(root: {
+    traverse(callback: (object: object) => void): void;
+}, camera: Camera, viewportHeight: number): number;
+
+/**
+ * What the gate did on the last frame, in the shape a frame-budget window reports.
+ *
+ * `enabled: false` means the game declined the gate, and the counts are still measured — turning
+ * the convention off must not turn its measurement off. Every exemption is named separately so an
+ * override is visible rather than silent.
+ */
+interface IRenderCameraCullReport {
+    readonly schemaVersion: 1;
+    readonly enabled: boolean;
+    /**
+     * False when the camera has no perspective distance term (orthographic) or no viewport to
+     * project into; the gate then leaves the whole scene drawn rather than guessing.
+     */
+    readonly cameraResolved: boolean;
+    readonly thresholdPixels: number;
+    /** Renderables walked this frame. */
+    readonly considered: number;
+    /** Renderables hidden by this gate this frame. */
+    readonly culled: number;
+    readonly exemptCameraAttached: number;
+    readonly exemptMarked: number;
+    readonly exemptShadowCasters: number;
+    readonly exemptWithoutBounds: number;
+    /**
+     * Objects whose position buffer is rewritten every frame, so the gate cannot trust a bound it
+     * cannot afford to rescan. Kept drawn, like `frustumCulled = false`.
+     */
+    readonly exemptDynamicBounds: number;
+    /** Objects that already set `frustumCulled = false`, and so never had trustworthy bounds. */
+    readonly exemptFrustumCulled: number;
+}
+/**
+ * Keep an object drawn regardless of how small the render camera resolves it.
+ *
+ * The named per-object override for the projected-size gate, which is on by default. Mark the
+ * player's own cockpit, a nameplate, a quest marker, or anything a game never wants to pop out.
+ * `alwaysRender(object, false)` removes the marker. The count of marked objects is reported beside
+ * the cull, so an override is stated rather than hidden.
+ *
+ * @situation keep a small object drawn when the engine would skip it as too far to resolve
+ * @situation stop my cockpit, marker or player model popping out at distance
+ * @situation a tiny object disappeared at range and I need it always visible
+ * @constraint the marker is per object and survives scene rebuilds only as long as the object does
+ * @constraint disabling the gate (`renderer.minimumProjectedPixels: false`) keeps its measurement on
+ * @example alwaysRender(ctx.camera.children[0]); // a camera-attached cockpit stays drawn
+ */
+declare function alwaysRender(object: Object3D, enabled?: boolean): void;
+
+/**
+ * The per-frame world-matrix walk, with a hidden subtree left where it stands.
+ *
+ * `three`'s `Object3D.updateMatrixWorld` recurses into every child of every node whatever its
+ * `visible` flag, multiplying a world matrix for each. That is the correct default for a library
+ * that cannot know what a game is doing, and it is the wrong one for a renderer that is about to
+ * skip exactly those subtrees: a full-detail body while its merged stand-in draws, a hidden LOD
+ * level, a parked or hangared model each pay the walk and none of them can draw.
+ *
+ * Native flight in `sandbox/midway-open-pacific` profiled `updateMatrixWorld` plus
+ * `multiplyMatrices` at **29 % of all JavaScript ticks**, and the same scene's hand-rolled
+ * visible-only pass walked **779 nodes per frame instead of 9,903**, 3.1 ms down to 0.3 ms. That
+ * pass was the game's; this is the engine's, so the next game does not write it again.
+ *
+ * The pass mirrors three exactly for a visible node: `matrixAutoUpdate` -> `updateMatrix()`, then
+ * the `matrixWorldNeedsUpdate || force` recompute honouring `matrixWorldAutoUpdate` and a null
+ * parent, then force the children. A node with `visible === false` still composes its **own**
+ * matrix — that is what makes the next part cheap — and is not recursed into; when it was forced
+ * (or carried a dirty flag) it is remembered, so the first frame it is visible again its whole
+ * subtree is recomputed with `force = true`.
+ *
+ * Two things are never dropped by the pruning, because both are read while nothing above them is
+ * visible:
+ *
+ * - a class that overrides `updateMatrixWorld` runs its own. `SkinnedMesh` refreshes
+ *   `bindMatrixInverse`, `Camera` its `matrixWorldInverse`; re-implementing only the base walk
+ *   left every deck-crew sailor that had moved since load drawing with a stale bind matrix and
+ *   vanishing from the frame. Their subtrees are small, so walking them whole costs nothing;
+ * - a hidden node that holds a `Bone` is walked, because a visible `SkinnedMesh` draws with its
+ *   skeleton's matrices wherever the armature happens to sit. Whether bones sit below a node is
+ *   decided once and remembered — a rig is built whole and does not grow.
+ *
+ * A game that reads a **hidden** object's `matrixWorld` directly must not rely on this pass
+ * having reached it: use `getWorldPosition`/`getWorldQuaternion`/`getWorldScale` (which update the
+ * chain they need) or call `object.updateWorldMatrix(true, false)` first. The convention's named
+ * override is `renderer.matrixWorld: "all"`, which visits every node exactly as three's own walk
+ * does; `"visible"` is the default.
+ */
+/** How much of the scene graph the engine walks for world matrices each frame. */
+type MatrixWorldMode = "visible" | "all";
+/** What the pass did on the last frame, for the frame telemetry a window reports. */
+interface IMatrixWorldReport {
+    readonly schemaVersion: 1;
+    readonly mode: MatrixWorldMode;
+    /**
+     * Nodes the engine walked this frame, summed over every application (authored scene and a
+     * projection mirror when one is in use). One number both ways, so `"all"` can be read as the
+     * cost of the walk the convention just removed.
+     */
+    readonly visited: number;
+}
+interface IMatrixWorldOptions {
+    /** `"visible"` (default) skips a hidden subtree; `"all"` reproduces three's own walk. */
+    readonly mode?: MatrixWorldMode;
+}
+/**
+ * One game's world-matrix walk, holding the state the pruning needs between frames.
+ *
+ * The stale set and the bone cache live on the instance rather than in module scope: two games,
+ * two playtest scenarios or two roots in one process must not share "this subtree was skipped
+ * while hidden", or one game's hidden node would be force-refreshed by the other's frame.
+ */
+declare class MatrixWorldPass {
+    #private;
+    constructor(options?: IMatrixWorldOptions);
+    get mode(): MatrixWorldMode;
+    /** What the current frame has walked so far, across every {@link apply} call. */
+    get report(): IMatrixWorldReport;
+    /** Starts a frame's count. The pass's state (stale set, bone cache) is untouched. */
+    beginFrame(): void;
+    /**
+     * Walks `root`, mirroring three for every node the mode visits.
+     *
+     * Returns the nodes this call visited, so a caller can report one application's cost without
+     * also reporting the frame's total.
+     */
+    apply(root: Object3D, force?: boolean): number;
+    /** Forgets what was skipped. A whole-scene swap has no hidden ancestors left to refresh. */
+    dispose(): void;
+}
+
+/**
+ * Where the spans attach to three's own render path.
+ *
+ * Kept apart from the recorder because they are two different kinds of risk. The recorder is
+ * arithmetic over a stack and is proven by unit tests; this file reaches into another library's
+ * private methods, and every line of it is a bet about how three 0.185 is shaped. Reading them
+ * separately is how the bet stays visible.
+ *
+ * Every wrapper is an own property on the instance, so it is the object the frame actually uses
+ * and uninstalling restores the prototype's method. Three's private methods are read defensively:
+ * a renderer whose internals have moved loses that span rather than throwing, and the span simply
+ * does not appear in the report — an absent measurement, never a fabricated zero.
+ */
+
+/** The slice of the raw three renderer the probes wrap. Structural, so a test can stand in a fake. */
+interface ISpanProbeTarget {
+    render(scene: unknown, camera: unknown): unknown;
+    _projectObject?(...args: unknown[]): void;
+    _renderObjectDirect?(...args: unknown[]): void;
+}
+/**
+ * Wraps the renderer's own render path so each part of a frame lands in its own span.
+ *
+ * Every wrapper is an own property on the instance, so it is the object the frame actually uses and
+ * uninstalling restores the prototype's method. Three's private methods are read defensively: a
+ * renderer whose internals have moved loses that span rather than throwing, and the span simply
+ * does not appear in the report — an absent measurement, never a fabricated zero.
+ *
+ * The recursion guards matter: `_projectObject` calls itself once per child, so only the outermost
+ * call opens a span, and `render` is deliberately not guarded because a nested render *is* the
+ * shadow and reflection passes.
+ */
+declare function installSpanProbes(target: ISpanProbeTarget, root: Object3D): () => void;
+
+/**
+ * The engine telling the agent that built the scene what a human would otherwise find by playing.
+ *
+ * A scene reached 1,815 triangles per draw with its GPU ten times under budget and nobody knew,
+ * because the census and the phase split are measured every frame and nothing reads them. The
+ * frame already carries the shape: how many objects the cull considered, how many draws each pass
+ * submitted, how many casters are exempt, and what share of the frame the GPU actually used. This
+ * turns those numbers into a verdict, once per reported window.
+ *
+ * **The rule is derived, never a constant an author is told to revisit.** It fires when
+ *
+ *  - the GPU used less than a third of the frame — the device is not the constraint, and
+ *  - the JS render phase alone is longer than the display's own period — so the scene cannot make
+ *    the display's rate even if everything else in the frame were free.
+ *
+ * Both numbers come from the frame meter. The display's period comes from the host's own
+ * presentation cap where there is one, and otherwise from the frame rate the game itself declared;
+ * no third source is invented, and a launch that can name neither gets no verdict rather than a
+ * guessed one.
+ *
+ * It is silent on an honestly GPU-bound scene with the same draw count, which is the property that
+ * makes it worth reading: a warning that fires on every heavy scene is a warning nobody reads.
+ */
+
+/** Marker printed at most once per reported window. */
+declare const SCENE_WARNING_MARKER = "TN_SCENE_WARNING";
+/**
+ * What the frame already knows about the scene's shape.
+ *
+ * Every field is a count the engine measures anyway — the projection's cull census and the render
+ * pass budget — so the warning adds a reading, never a measurement.
+ */
+interface ISceneShape {
+    /** Objects the projected-size cull looked at this window. */
+    readonly objectsConsidered: number;
+    /** Objects it hid. */
+    readonly culled: number;
+    /** Objects exempt from the gate because they cast shadows. */
+    readonly shadowExemptCasters: number;
+    /** Draws submitted per pass kind, from the render pass budget. */
+    readonly draws: Readonly<Partial<Record<FramePassKind, number>>>;
+    /** Triangles per draw across every pass; the number a merge or an atlas moves. */
+    readonly trianglesPerDraw: number;
+}
+/** The verdict, and the shape behind it. */
+interface ISceneWarning {
+    readonly window: number;
+    /** The GPU's share of the frame, as a fraction. */
+    readonly gpuShare: number;
+    /** The JS render phase's mean, in milliseconds. */
+    readonly renderMs: number;
+    /** The period the display works at, in milliseconds, and where that number came from. */
+    readonly displayPeriodMs: number;
+    readonly displaySource: "host-cap" | "declared-target";
+    /** The largest thing the CPU describes every frame, and its share of the terms compared. */
+    readonly dominantTerm: string;
+    readonly dominantShare: number;
+    readonly shape: ISceneShape;
+}
+/**
+ * The display's own period, in milliseconds, or `undefined` when nothing can say.
+ *
+ * The host's presentation cap first, because on a native launch that is literally the rate frames
+ * reach the display at. A browser has no refresh-rate API, so the rate the game declared is the
+ * only honest second source — and it is the same number the resolution scaler already judges
+ * against, not a new one.
+ */
+declare function displayPeriodMs(declaredTargetFps: number | undefined): {
+    ms: number;
+    source: ISceneWarning["displaySource"];
+} | undefined;
+/**
+ * The verdict for one reported window, or `undefined` when the frame does not earn one.
+ *
+ * Fails closed in both directions: a window whose GPU was never measured gets no verdict, because
+ * "the GPU is idle" is a claim and an absent reading is not evidence for it; and a window with no
+ * shape to report gets none either, because a warning that cannot say what to change is noise.
+ */
+declare function sceneWarning(window: IFrameBudgetWindow, shape: ISceneShape | undefined, declaredTargetFps: number | undefined): ISceneWarning | undefined;
+/**
+ * The scene's shape for one window, from the counts the frame already reported.
+ *
+ * `undefined` when the window carries no pass split: without draws there is nothing to name, and
+ * a verdict built on an absent census would be a sentence about a scene nobody measured.
+ */
+declare function describeSceneShape(window: IFrameBudgetWindow, cull: IRenderCameraCullReport | undefined): ISceneShape | undefined;
+/** The one-line summary a reader sees without opening a log viewer. */
+declare function describeSceneWarning(warning: ISceneWarning): string;
+/** The marker line. */
+declare function formatSceneWarning(warning: ISceneWarning): string;
+
+/**
+ * Authored static subtrees: stop recomposing transforms that nobody moves.
+ *
+ * The matrix walk is 2.22 ms of the reference game's 16.1 ms render phase, and almost none of what
+ * it recomputes changed since the previous frame — island geometry, deck fittings, static props and
+ * terrain are composed from the same position, quaternion and scale every frame, then multiplied
+ * into the same world matrix, for as long as the game runs.
+ *
+ * **What this deletes, exactly, so the claim can be checked.** Three's `updateMatrixWorld` does
+ * three things per object: `updateMatrix()` composes the local matrix when `matrixAutoUpdate`,
+ * the world matrix is multiplied out when `matrixWorldNeedsUpdate || force`, and the walk recurses
+ * into every child — the recursion is unconditional in three 0.185, so a frozen subtree still gets
+ * visited. Freezing removes the two composes and keeps the visit. That is the honest bound: this
+ * deletes arithmetic, not traversal, and the traversal is a separate lever with a separate PRD.
+ *
+ * **Staticness is authored, never guessed.** A heuristic that decides an object has "not moved in
+ * 60 frames" is a correctness bug with no reproduction, so nothing here watches gameplay. What the
+ * engine does do is check the promise where it is cheap to check it: the root's own local transform
+ * is compared against what was frozen, once per frame, and a root the author moved thaws and
+ * refreezes itself. That is O(static roots), not O(objects), and it turns the most common way to
+ * get this wrong into a non-event. Writes deeper inside a frozen subtree are the author's to
+ * announce with `invalidateStatic`, and `TN_RENDERLIST_VALIDATE=1` is what proves they did.
+ */
+
+/** Marker printed with the static census on each reported window. */
+declare const STATIC_TRANSFORM_MARKER = "TN_STATIC_TRANSFORMS";
+/**
+ * Marks a subtree static: its transforms are composed once here and never again until something
+ * changes them.
+ *
+ * Idempotent, and it answers the version the subtree is now at, so a caller can assert on the
+ * contract rather than on the flag. Marking a root twice re-arms it, which is the same thing
+ * `invalidateStatic` does and the reason a generator can emit the call unconditionally.
+ */
+declare function markStatic(root: Object3D): number;
+/**
+ * Thaws a subtree: every object composes again from the next walk.
+ *
+ * The flags are restored to three's defaults rather than to whatever they were before, because a
+ * game that had already turned `matrixAutoUpdate` off for its own reasons and then marked the
+ * subtree static is asking for the same behaviour either way.
+ */
+declare function unmarkStatic(root: Object3D): void;
+/**
+ * Announces that something inside a frozen subtree moved. The subtree recomposes once and refreezes
+ * at its new transform.
+ *
+ * Takes the object that moved, or the root; either way the root that owns it is what re-arms, since
+ * a world matrix deeper in the subtree is a product of everything above it.
+ */
+declare function invalidateStatic(object: Object3D): number | undefined;
+/** Whether this object is a frozen root. */
+declare function isStatic(root: Object3D): boolean;
+/** One window's census of what is frozen and what had to thaw. */
+interface IStaticTransformCensus {
+    /** Subtrees currently frozen. */
+    readonly roots: number;
+    /** Objects inside them, which is the count that stopped recomposing. */
+    readonly objects: number;
+    /** Roots the per-frame check found moved, and re-armed, since the previous census. */
+    readonly rearmed: number;
+}
+/**
+ * Re-arms any frozen root whose authored transform has changed since it was frozen.
+ *
+ * Called once per render phase, before the walk. It reads 26 numbers per frozen root and writes
+ * nothing when nothing moved, so a scene that stays still pays a comparison per subtree and no
+ * allocation at all. It cannot see a write deeper inside the subtree — that is `invalidateStatic`'s
+ * job and `TN_RENDERLIST_VALIDATE=1`'s proof — and it does not pretend to.
+ */
+declare function refreshStaticTransforms(): void;
+/** The census, and the re-arm counter it resets. */
+declare function staticTransformCensus(): IStaticTransformCensus;
+/** Drops every registration. A game that tore down its scene must not keep its roots alive. */
+declare function resetStaticTransforms(): void;
+
+/**
+ * The parity oracle for anything that stops recomputing a transform.
+ *
+ * A cache that is right on the scene you tested and wrong on the one you did not is worse than no
+ * cache, because it ships as a visual bug nobody can reproduce. This is the instrument that makes
+ * the difference falsifiable: with `TN_RENDERLIST_VALIDATE=1`, every frame recomputes every world
+ * matrix from the authored transforms, the long way, and compares it elementwise against the one
+ * the frame is about to draw with. The first disagreement throws, naming the object and the
+ * element, because a validation mode that logs and continues is a validation mode nobody reads.
+ *
+ * It is a validation mode, not a proof: it proves the frames it ran on. Run it on the scenes you
+ * care about, in CI, for as many frames as you can afford.
+ *
+ * Off by default and expensive by construction — it does the work it is checking, twice.
+ */
+
+/** Marker printed when the validator is installed, so a log says which mode produced it. */
+declare const RENDERLIST_VALIDATE_MARKER = "TN_RENDERLIST_VALIDATE";
+/** The launch flag. */
+declare const RENDERLIST_VALIDATE_FLAG = "TN_RENDERLIST_VALIDATE";
+/** Whether `TN_RENDERLIST_VALIDATE` asks for validation on this launch. */
+declare function renderListValidationRequested(): boolean;
+/** What one frame's check found. */
+interface IValidationReport {
+    /** Objects whose world matrix was recomputed and compared. */
+    readonly checked: number;
+    /** Objects skipped because they own their own world matrix; reported, never counted as checked. */
+    readonly gameOwned: number;
+    /** Frames validated so far. */
+    readonly frames: number;
+}
+/**
+ * Recomputes every world matrix under `root` and throws on the first that disagrees.
+ *
+ * The recomputation is deliberately independent of the flags a freeze sets: it composes the local
+ * matrix from `position`/`quaternion`/`scale` when the object composes its own, uses the authored
+ * `matrix` when it does not, and multiplies by the parent's *recomputed* world matrix rather than
+ * the cached one — so an error at the top of a subtree cannot be hidden by a matching error
+ * underneath it.
+ */
+declare function validateWorldMatrices(root: Object3D): {
+    checked: number;
+    gameOwned: number;
+};
+/**
+ * The per-frame validator, installed when the flag asks for it.
+ *
+ * Holds a frame counter so the marker can say how much was proven, which is the difference between
+ * "validation passed" and "validation passed on 1,800 frames of the reference game".
+ */
+declare class RenderListValidator {
+    #private;
+    /**
+     * Validates one frame. Throws on the first divergence.
+     *
+     * `roots` is the thing being drawn plus every frozen subtree. Those are not the same object
+     * when the engine's projection is collapsing the scene: the draw root is then the mirror, and
+     * validating only it reported three objects checked and zero divergences on a scene with two
+     * hundred frozen meshes, one of which really was stale. A freeze is authored on the authored
+     * scene, so the authored roots are checked whether or not they are what reaches the GPU.
+     */
+    frame(...roots: readonly Object3D[]): void;
+    report(): IValidationReport;
+}
+/** The marker line for one reported window. */
+declare function formatValidationReport(report: IValidationReport): string;
+
 /** The atlas has one copied edge texel on either side of each packed SH sub-volume. */
 declare const ATLAS_PADDING = 1;
 /** The machine-readable marker emitted whenever the probe state changes. */
@@ -1531,6 +2188,100 @@ declare class FluidField2D extends Group {
     detach(): void;
 }
 
+/**
+ * A disturbance that propagates. `WaveField` in this same package evaluates a fixed analytic
+ * swell: it is the sea a game always has, and nothing a game does changes it. This is the other
+ * half — a square patch of surface that is flat until something hits it, carries the rings
+ * outward at a real celerity, and forgets them again.
+ *
+ * The solve is the 2-D wave equation on a regular grid, plus an advected foam density. It owns no
+ * Three.js object, no material and no colour: it reports height, foam and horizontal flow, and the
+ * game decides what those look like. Add its height to an analytic swell; do not replace one.
+ *
+ * There is deliberately no obstacle or hull mask. A mask is only correct for a body that does not
+ * move, and a game whose hulls move is better served drawing the displacement those hulls make
+ * than re-rasterising a mask every time one of them advances a metre.
+ */
+interface IRippleFieldFlow {
+    x: number;
+    z: number;
+}
+interface IRippleFieldOptions {
+    /** Cells per side. Cost is quadratic in this; 128 over a 400 m patch is ~3 m per cell. */
+    readonly resolution: number;
+    /** Width of the patch in metres. */
+    readonly size: number;
+    /** Wave celerity in metres per second. Sets both ring speed and the stable step. */
+    readonly speed?: number;
+    /** Bulk damping. Higher forgets a disturbance sooner. */
+    readonly damping?: number;
+    /** Seconds for undisturbed foam to halve. */
+    readonly foamHalfLife?: number;
+    /** Steady surface drift in metres per second, added to the solved flow. */
+    readonly current?: IRippleFieldFlow;
+    /**
+     * Integration step in seconds. Defaults to 1/60 s, or the CFL limit for this cell size and
+     * celerity where that is smaller.
+     */
+    readonly step?: number;
+    /** Substeps one `advance` will run before it drops the rest of the frame's time. */
+    readonly maxSteps?: number;
+}
+declare class RippleField {
+    #private;
+    readonly resolution: number;
+    readonly size: number;
+    readonly dx: number;
+    readonly speed: number;
+    readonly damping: number;
+    readonly step: number;
+    readonly maxSteps: number;
+    foamHalfLife: number;
+    current: IRippleFieldFlow;
+    /** Surface height per cell, row-major from the patch's -x/-z corner. Read-only to the game. */
+    height: Float32Array;
+    /** Foam density per cell in 0..1. */
+    foam: Float32Array;
+    /** Horizontal flow per cell, metres per second, excluding `current`. */
+    readonly flowX: Float32Array;
+    readonly flowZ: Float32Array;
+    /** Patch centre in world metres, always snapped to a whole cell. */
+    centerX: number;
+    centerZ: number;
+    /** Simulated seconds elapsed. */
+    time: number;
+    /** Bumped whenever a cell changes, so a texture upload can skip an unchanged frame. */
+    version: number;
+    constructor(options: IRippleFieldOptions);
+    /** True while the point is inside the patch, `margin` metres in from its rim. */
+    contains(x: number, z: number, margin?: number): boolean;
+    /**
+     * Move the patch so it covers the action. The grid shifts by whole cells and the newly exposed
+     * band arrives flat, which is what the sponge rim had already damped it to.
+     */
+    recenter(x: number, z: number): void;
+    /**
+     * Push the surface at a point: a Gaussian of the given radius, with the kernel corrected so the
+     * disturbance injects no net volume. Without that correction every splash slowly raises the sea.
+     * Returns false when the point is outside the patch.
+     */
+    impulse(x: number, z: number, radius: number, amplitude: number, foam?: number): boolean;
+    /** Lay down entrained air without claiming a pressure impulse happened. */
+    depositFoam(x: number, z: number, radius: number, amount: number): boolean;
+    /** Run whole fixed steps to consume `dt`, and report how many ran. */
+    advance(dt: number): number;
+    /** Disturbance height in metres at a world point, zero outside the patch. */
+    heightAt(x: number, z: number): number;
+    /** Foam density in 0..1 at a world point. */
+    foamAt(x: number, z: number): number;
+    /** Surface flow in metres per second at a world point, including `current`. */
+    flowAt(x: number, z: number, out?: IRippleFieldFlow): IRippleFieldFlow;
+    /** Total disturbance energy. Zero on an undisturbed patch; useful as a test oracle. */
+    energy(): number;
+    /** Flatten the patch and forget every disturbance. Position, options and time survive. */
+    reset(): void;
+}
+
 type WaveDirection = readonly [number, number] | {
     readonly x: number;
     readonly z?: number;
@@ -1597,7 +2348,21 @@ declare class WaveField {
     constructor(options: IWaveFieldOptions);
     /** Update the default graph clock. Explicit sample times remain available for fixed-step code. */
     setTime(value: number): void;
+    /**
+     * Surface height and normal at a point. Allocates the result and its vector; a caller that wants
+     * only the number should call `heightAt`, which is the same evaluation without either.
+     */
     sample(x: number, z: number, time: number): IWaveFieldSample;
+    /**
+     * Surface height at a point, as a number.
+     *
+     * The scalar half of `sample`, and the same arithmetic in the same order, so the two agree
+     * exactly. What it skips is everything only a normal needs: the domain warp's jacobian, the
+     * cosine and slope of every wave, the normalisation, the result object and the `Vector3`. A
+     * floating hull, a splash query or a whitewater height test asks this question thousands of times
+     * a frame and throws the normal away every time.
+     */
+    heightAt(x: number, z: number, time: number): number;
     /** Surface height at a point, as a graph. The scalar half of what `sample` returns. */
     heightNode(options?: IWaveFieldGraphOptions): Node<"float">;
     /**
@@ -1617,17 +2382,53 @@ declare class WaveField {
     displacementNode(timeNode?: three_webgpu.UniformNode<"float", number>): Node<"vec3">;
 }
 
-/** How the mirrored pass is sized. Both numbers are cost, not appearance. */
+/** What the mirrored pass costs: how big it is, how many of them, and how much of the world. */
 interface IWaterReflectionOptions {
     /**
      * The mirrored pass's render target, as a fraction of the drawing buffer.
      *
-     * A reflection is a second draw of the whole world, so this is the one number that decides
-     * whether a water surface is affordable. Half is the usual answer.
+     * How many *pixels* the second pass costs. Half is the usual answer. This is not on its own the
+     * number that decides whether a surface is affordable, and a game that reads it that way will
+     * measure no improvement and conclude its water is free: a scene with many objects is bound by
+     * the draw calls the mirrored pass submits, not by its pixels, and those do not shrink with the
+     * target. Measured on `sandbox/midway-open-pacific` at 1920x1080 on an nvidia/turing adapter with
+     * 1,965 draws in the frame, halving this again — 0.5 to 0.25 — moved GPU p95 from 17.80 ms to
+     * 17.58 ms. Removing the pass entirely moved it to 7.67 ms. `layers` is the number that mattered.
      */
     readonly resolutionScale: number;
     /** Whether this surface may appear in other reflectors' passes. Off is one pass; on is n². */
     readonly bounces?: boolean;
+    /**
+     * Which layers the mirrored pass draws, as a three `Layers` mask. Omit to draw everything the
+     * scene camera draws, which is the default and what a reflection means when nothing says
+     * otherwise.
+     *
+     * This is how much *world* the second pass costs, and on a crowded scene it is the whole bill.
+     * The mirrored pass is a second draw of everything, so a frame with sixty-eight aircraft in it
+     * pays for sixty-eight aircraft twice — once where the player can see them and once in the water,
+     * where they are a few pixels and half of them are behind the camera anyway. Put the big
+     * silhouettes a player actually reads in the water on their own layer and name it here.
+     *
+     * The mask decides what appears in the mirror, so the game owns it: this only carries the number
+     * through to the pass, and a game that omits it gets the whole world reflected as before.
+     */
+    readonly layers?: number;
+    /**
+     * How often the mirrored pass redraws, in presented frames.
+     *
+     * The reflection is a second render of the world and on a crowded sea it is the largest single
+     * item in the frame. It is also low-frequency: a swell, a hull and a wake read the same whether
+     * the mirror was taken this frame or two frames ago, and at speed the eye cannot hold a reflected
+     * silhouette still enough to notice it lag. `2` redraws every second frame and samples the
+     * previous frame's target in between, halving the pass's cost; a higher number halves it again.
+     *
+     * Omit it — or pass `1` — and the pass redraws every frame, which is the shipping behaviour and
+     * the default. The trade is temporal: while the camera moves, the reflection is up to
+     * `refreshInterval - 1` frames behind the scene it mirrors. Fast camera motion can make a
+     * reflected edge shimmer, and a moving object's reflection trails it. A still camera sees none of
+     * that, so name it only where the measured pass dominates the frame.
+     */
+    readonly refreshInterval?: number;
 }
 interface IWaterSurfaceOptions {
     /** World-space height of the surface, in metres. The mirror plane, and where thickness is 0. */
@@ -1681,6 +2482,19 @@ declare class WaterSurface3D {
      */
     readonly target: Object3D | undefined;
     constructor(options: IWaterSurfaceOptions);
+    /**
+     * The camera the mirrored pass draws this surface with, for one scene camera.
+     *
+     * The pass mints one of these per scene camera, lazily, and reflects the camera through the
+     * mirror plane each frame. It is exposed because `layers` is not the only thing a game may need
+     * to say about the second draw — a near/far pair is the other — and because a reflection you
+     * cannot inspect is a reflection you cannot cost. Undefined when this surface has no reflection.
+     */
+    reflectionCameraFor(camera: Camera): Camera | undefined;
+    /** What the mirrored pass draws, as the mask the game supplied. Undefined means everything. */
+    readonly reflectionLayers: number | undefined;
+    /** How often the mirrored pass redraws, in presented frames. `1` is every frame, the default. */
+    readonly reflectionRefreshInterval: number;
     /** The world-space height of the surface, in metres. */
     get level(): number;
     /** Move the surface — a tide, a sluice, a flooding room. The mirror plane follows. */
@@ -1872,6 +2686,213 @@ declare class GroundSnap {
     audit(): number | null;
 }
 
+/**
+ * Force-integrated fixed-wing flight dynamics for a game-owned aircraft.
+ *
+ * The model integrates lift, drag, thrust and aerodynamic moments in SI units, `+Y` up, with the
+ * nose down local `-Z`. Attitude is a quaternion, so there are no Euler clamps and no commanded
+ * velocity vectors: the game writes controls, the model writes forces, and the aircraft keeps its
+ * own momentum. Every number that decides how the aircraft looks or performs — mass, wing area,
+ * engine power, inertia, control authority, wind, damage multipliers and payload — arrives from
+ * the game. This module owns only the mechanism that turns those inputs into motion.
+ */
+interface IFlightVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+interface IFlightQuaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+interface IFlightAxes {
+    readonly r: IFlightVector3;
+    readonly u: IFlightVector3;
+    readonly f: IFlightVector3;
+}
+/** Per-aircraft constants. The game supplies these; the model ships no airframe of its own. */
+interface IAircraftAirframe {
+    /** Empty mass, kg. */
+    readonly dryMass: number;
+    /** Mass of a full fuel load, kg. */
+    readonly fuelMass: number;
+    /** Reference wing area, m². */
+    readonly wingArea: number;
+    /** Wingspan, m. */
+    readonly span: number;
+    /** Mean aerodynamic chord, m. */
+    readonly chord: number;
+    /** Shaft power at full throttle, W. */
+    readonly power: number;
+    /** Propeller efficiency, 0–1. */
+    readonly propEfficiency: number;
+    /** Maximum static thrust, N. */
+    readonly staticThrust: number;
+    /** Pitch moment of inertia, kg·m². */
+    readonly pitchInertia: number;
+    /** Roll moment of inertia, kg·m². */
+    readonly rollInertia: number;
+    /** Yaw moment of inertia, kg·m². */
+    readonly yawInertia: number;
+}
+/** Multipliers a game applies for damage, load or upgrades. 1 / 0 is the undamaged case. */
+interface IFlightModifiers {
+    readonly power: number;
+    readonly lift: number;
+    readonly drag: number;
+    readonly roll: number;
+    readonly controls: number;
+}
+declare const NEUTRAL_FLIGHT_MODIFIERS: IFlightModifiers;
+/** One fixed step of pilot input. Every field is a dimensionless command in `[-1, 1]`. */
+interface IFlightControls {
+    readonly turn?: number;
+    readonly pitch?: number;
+    readonly rudder?: number;
+    readonly wheelBrake?: boolean;
+    /** When true, stability assist is bypassed and the game commands the attitude directly. */
+    readonly autopilot?: boolean;
+}
+/** The moving deck an aircraft launches from. */
+interface IFlightDeck {
+    readonly x: number;
+    readonly y?: number;
+    readonly z: number;
+    readonly heading: number;
+    readonly speed: number;
+    readonly length: number;
+    readonly width: number;
+}
+interface IFlightState {
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    attitude?: IFlightQuaternion;
+    heading: number;
+    pitch: number;
+    roll: number;
+    rollRate: number;
+    pitchRate: number;
+    yawRate: number;
+    speed: number;
+    ias: number;
+    groundSpeed: number;
+    throttle: number;
+    rpm: number;
+    fuel: number;
+    hp: number;
+    engineCut: boolean;
+    gear: boolean;
+    brakes: boolean;
+    gearPos: number;
+    brakePos: number;
+    flapPos: number;
+    flaps: number;
+    aileron: number;
+    elevator: number;
+    rudder: number;
+    controlAileron: number;
+    assist: boolean;
+    trim: number;
+    gforce: number;
+    aoa: number;
+    beta: number;
+    stall: number;
+    /** Mass of everything under the wings, kg. The game writes it as stores are released. */
+    payloadMass: number;
+    /** Extra flat-plate drag coefficient from external stores. */
+    payloadDrag: number;
+    flightTime: number;
+    lift: number;
+    drag: number;
+    thrust: number;
+    mass: number;
+    deckSpeed?: number;
+    deckLateral?: number;
+    deckOffset?: number;
+    chocks?: boolean;
+}
+interface IFlightEnvironment {
+    readonly airframe: IAircraftAirframe;
+    readonly wind?: IFlightVector3;
+    readonly modifiers?: IFlightModifiers;
+    readonly gravity?: number;
+    /** Height of the carrier deck surface above the water, m. */
+    readonly deckHeight?: number;
+}
+interface IFlightForces {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly normalLoad: number;
+    readonly lift: number;
+    readonly drag: number;
+    readonly thrust: number;
+    readonly alpha: number;
+    readonly beta: number;
+    readonly airspeed: number;
+    readonly density: number;
+    readonly mass: number;
+    readonly qs: number;
+    readonly axes: IFlightAxes;
+    readonly cl: number;
+    readonly cd: number;
+    readonly stall: number;
+    readonly critical: number;
+}
+/** ISA air density at altitude `y` metres, kg/m³. */
+declare function airDensity(y: number): number;
+/** Current mass of the aircraft from its empty mass, fuel load and game-written payload. */
+declare function aircraftMass(state: IFlightState, airframe: IAircraftAirframe): number;
+/** Lift and drag coefficients for an angle of attack and the deployed high-lift devices. */
+declare function aerodynamicCoefficients(alpha: number, flaps?: number, gear?: number, brakes?: number): {
+    cl: number;
+    cd: number;
+    stall: number;
+    critical: number;
+};
+/** Write a heading/pitch/roll pose into the body quaternion. Nose down local `-Z`. */
+declare function setAttitude(state: IFlightState, heading?: number, pitch?: number, roll?: number): IFlightQuaternion;
+/** Right, up and forward unit vectors of the body frame. */
+declare function attitudeAxes(state: IFlightState): IFlightAxes;
+/** Height of the gear contact point below the body origin at the current pitch. */
+declare function gearClearance(state: IFlightState): number;
+interface IFlightModelOptions<TState extends IFlightState = IFlightState> extends IFlightEnvironment {
+    /** The game's own aircraft object, extended with whatever else the game needs on it. */
+    readonly state: TState;
+}
+/**
+ * One aircraft's dynamics: a thin owner of a game-authored state object plus its environment.
+ *
+ * The step record copies the options' own fields once, at construction — so `airframe`, `wind`,
+ * `gravity` and `deckHeight` are read from the objects those fields reference, which stay live,
+ * but replacing a field on the options object afterwards is not observed. Change a model's airframe
+ * or deck by building it again, as a game that binds aircraft to carriers already does.
+ *
+ * @example
+ * const model = new FlightModel({ airframe: sbd, state: aircraft, wind: seaWind });
+ * model.setAttitude(0, 0.2, 0);
+ * model.step(1 / 60, { turn: -1, pitch: 0.4 });
+ */
+declare class FlightModel<TState extends IFlightState = IFlightState> {
+    #private;
+    readonly state: TState;
+    readonly environment: IFlightEnvironment;
+    constructor(options: IFlightModelOptions<TState>);
+    setAttitude(heading?: number, pitch?: number, roll?: number): void;
+    reset(): void;
+    axes(): IFlightAxes;
+    gearClearance(): number;
+    forces(modifiers?: IFlightModifiers): IFlightForces;
+    step(dt: number, controls: IFlightControls, modifiers?: IFlightModifiers): void;
+    stepDeck(deck: IFlightDeck, dt: number, controls: IFlightControls, modifiers?: IFlightModifiers): "liftoff" | "overrun" | null;
+}
+
 type ThreePoseVector = readonly [number, number, number];
 type ThreePoseQuaternion = readonly [number, number, number, number];
 interface IThreePoseBounds {
@@ -2189,6 +3210,6 @@ declare function boneLengthDeviations(root: Object3D, bind: IBoneLengthSnapshot,
  * unavoidable here — core is bundled for browsers and cannot read `package.json` at runtime — so
  * the spec now asserts this equals the manifest instead of asserting a number somebody typed.
  */
-declare const version = "0.3.1";
+declare const version = "0.3.3";
 
-export { ATLAS_PADDING, ATMOSPHERE_LUT_RESOLUTIONS, AnimationPlayer, Atmosphere, type AtmosphereDirection, AtmosphereLuts, type AtmosphereRgb, Billboard3D, type BillboardLockAxis, CameraShake, type CameraShakeCurve, ClusteredBatch, ClusteredMesh, FluidField2D, GPUParticles3D, GPUSceneBVH, type GPUSceneBVHTraceFunction, GroundSnap, type IAddInSlicesOptions, type IAddInSlicesProgress, type IAddInSlicesReport, type IAnimationPlayOptions, type IAnimationPlayerOptions, type IAtmosphereLutResolution, type IAtmosphereLutResolutions, type IAtmosphereOptions, type IAtmosphereParameterPatch, type IAtmosphereParameters, type IAtmosphereScenePass, type IBillboard3DOptions, type IBoneContactReport, type IBoneLengthDeviation, type IBoneLengthDeviationReport, type IBoneLengthDeviationsOptions, type IBoneLengthSnapshot, type IBonePoseError, type ICameraShakeOffset, type ICameraShakeOptions, type IClipBindingReport, type IClipCoverageReport, type IClipPoseErrorOptions, type IClipPoseErrorReport, type IClipPoseSubject, type IClipTrackBinding, type IClusterTable, type IClusteredBatchBuildOptions, type IClusteredBatchOptions, type IClusteredMeshOptions, type IClusteredPlacement, IComputeDriven$1 as IComputeDriven, type IFluidFieldOptions, type IFluidFieldSampler, type IFluidFieldVector2, IGPUReadbackSample, type IGPUSceneBVHMaterialGroup, type IGPUSceneBVHOptions, IGamePluginHooks, IGamePluginRuntime, type IGroundSnapOptions, type IInstancedBatchBuildOptions, type IInstancedBatchOptions, type IInstancedPlacement, type ILoadAllOptions, type ILoadAllProgress, type IMeasureThreePoseOptions, type IMergePart, type IMergePartsOptions, type INormaliseToMetresOptions, type IPathFollow3DOptions, type IPathFollow3DProjection, type IPathFollow3DSample, type IPlatformInfo, type IProbeVolumeBakeProgress, type IProbeVolumeCoefficient, type IProbeVolumeObservation, type IProbeVolumeOptions, type IReplayOptions, type IReplayRecording, type IReplayRecordingSample, type IResolvedAtmosphereParameters, type ISkeletalMesh3DOptions, type ISoftBody3DOptions, type ISoftBodyCollision, type ISolarPosition, type ISolarPositionInput, type ISpectralOceanCascade, type ISpectralOceanHeight, type ISpectralOceanOptions, type ISpriteAnimator3DOptions, type ISpriteFrame3D, type IStrideReport, type IThreePoseBounds, type IThreePoseMeasurement, type ITracerPool3DOptions, type ITracerSpawnOptions, type IVirtualShadowOptions, type IVirtualShadowStats, type IWaterReflectionOptions, type IWaterSurfaceOptions, type IWaveFieldDomainWarp, type IWaveFieldGraphOptions, type IWaveFieldOptions, type IWaveFieldSample, type IWaveFieldWave, InstancedBatch, LUT_RESOLUTIONS, type NormaliseAxis, PROBE_VOLUME_MARKER, PathFollow3D, type PlatformFormFactor, type PlatformOS, type PlatformRuntime, ProbeVolume, type ProbeVolumeDensity, type Recording, type ReplayPointer, SkeletalMesh3D, SoftBody3D, SpectralOcean, SpriteAnimator3D, type SpritePlaybackMode, type ThreePoseQuaternion, type ThreePoseVector, TracerPool3D, VIRTUAL_SHADOW_MARKER, VIRTUAL_SHADOW_MOVER_LAYER, VirtualShadowNode, WaterSurface3D, type WaveDirection, WaveField, addInSlices, attachToBone, boneContact, boneLengthDeviations, boneLengths, bvhIntersectFirstHit, clipBoneCoverage, clipPoseError, clipTrackBindings, createReplayDriver, directionFromSolarPosition, directionalTransmittance, getPlatform, isMobile, isNative, isTouchscreenAvailable, isWeb, loadAll, measureThreePose, mergeParts, normaliseToMetres, parseReplayRecording, posedBounds, rayStruct, readProbeVolumeObservation, readVirtualShadowMarker, replay, resolveAtmosphereLutResolutions, resolveAtmosphereParameters, skeletonBones, softCircleDataTexture, solarPosition, solarPositionAt, updateAtmosphereParameters, updateClusteredMeshes, version, zenithTransmittance };
+export { ATLAS_PADDING, ATMOSPHERE_LUT_RESOLUTIONS, AnimationPlayer, Atmosphere, type AtmosphereDirection, AtmosphereLuts, type AtmosphereRgb, Billboard3D, type BillboardLockAxis, CameraShake, type CameraShakeCurve, ClusteredBatch, ClusteredMesh, FlightModel, FluidField2D, FramePassKind, GPUParticles3D, GPUSceneBVH, type GPUSceneBVHTraceFunction, GroundSnap, type IAddInSlicesOptions, type IAddInSlicesProgress, type IAddInSlicesReport, type IAircraftAirframe, type IAnimationPlayOptions, type IAnimationPlayerOptions, type IAtmosphereLutResolution, type IAtmosphereLutResolutions, type IAtmosphereOptions, type IAtmosphereParameterPatch, type IAtmosphereParameters, type IAtmosphereScenePass, type IBillboard3DOptions, type IBoneContactReport, type IBoneLengthDeviation, type IBoneLengthDeviationReport, type IBoneLengthDeviationsOptions, type IBoneLengthSnapshot, type IBonePoseError, type ICameraShakeOffset, type ICameraShakeOptions, type IClipBindingReport, type IClipCoverageReport, type IClipPoseErrorOptions, type IClipPoseErrorReport, type IClipPoseSubject, type IClipTrackBinding, type IClusterTable, type IClusteredBatchBuildOptions, type IClusteredBatchOptions, type IClusteredMeshOptions, type IClusteredPlacement, IComputeDriven$1 as IComputeDriven, type IFlightAxes, type IFlightControls, type IFlightDeck, type IFlightEnvironment, type IFlightForces, type IFlightModelOptions, type IFlightModifiers, type IFlightQuaternion, type IFlightState, type IFlightVector3, type IFluidFieldOptions, type IFluidFieldSampler, type IFluidFieldVector2, IFrameBudgetWindow, IGPUReadbackSample, type IGPUSceneBVHMaterialGroup, type IGPUSceneBVHOptions, IGamePluginHooks, IGamePluginRuntime, type IGroundSnapOptions, type IInstancedBatchBuildOptions, type IInstancedBatchOptions, type IInstancedPlacement, type ILaunchFailure, type ILoadAllOptions, type ILoadAllProgress, type IMatrixWorldReport, type IMeasureThreePoseOptions, type IMergePart, type IMergePartsOptions, type INormaliseToMetresOptions, type IPathFollow3DOptions, type IPathFollow3DProjection, type IPathFollow3DSample, type IPlatformInfo, type IProbeVolumeBakeProgress, type IProbeVolumeCoefficient, type IProbeVolumeObservation, type IProbeVolumeOptions, type IReplayOptions, type IReplayRecording, type IReplayRecordingSample, type IResolvedAtmosphereParameters, type IRippleFieldFlow, type IRippleFieldOptions, type ISceneShape, type ISceneWarning, type ISkeletalMesh3DOptions, type ISoftBody3DOptions, type ISoftBodyCollision, type ISolarPosition, type ISolarPositionInput, type ISpanProbeTarget, type ISpanSummary, type ISpanWindow, type ISpectralOceanCascade, type ISpectralOceanHeight, type ISpectralOceanOptions, type ISpriteAnimator3DOptions, type ISpriteFrame3D, type IStaticTransformCensus, type IStrideReport, type IThreePoseBounds, type IThreePoseMeasurement, type ITracerPool3DOptions, type ITracerSpawnOptions, type IValidationReport, type IVirtualShadowOptions, type IVirtualShadowStats, type IWaterReflectionOptions, type IWaterSurfaceOptions, type IWaveFieldDomainWarp, type IWaveFieldGraphOptions, type IWaveFieldOptions, type IWaveFieldSample, type IWaveFieldWave, InstancedBatch, LUT_RESOLUTIONS, type LaunchFailureKind, type MatrixWorldMode, MatrixWorldPass, NEUTRAL_FLIGHT_MODIFIERS, type NormaliseAxis, PROBE_VOLUME_MARKER, PathFollow3D, type PlatformFormFactor, type PlatformOS, type PlatformRuntime, ProbeVolume, type ProbeVolumeDensity, RENDERLIST_VALIDATE_FLAG, RENDERLIST_VALIDATE_MARKER, type Recording, RenderListValidator, type ReplayPointer, RippleField, SCENE_WARNING_MARKER, SPANS, SPANS_FLAG, SPANS_MARKER, SPAN_COUNT, SPAN_NAMES, STATIC_TRANSFORM_MARKER, SkeletalMesh3D, SoftBody3D, type SpanId, SpanRecorder, SpectralOcean, SpriteAnimator3D, type SpritePlaybackMode, type ThreePoseQuaternion, type ThreePoseVector, TracerPool3D, VIRTUAL_SHADOW_MARKER, VIRTUAL_SHADOW_MOVER_LAYER, VirtualShadowNode, WaterSurface3D, type WaveDirection, WaveField, addInSlices, addSpan, aerodynamicCoefficients, airDensity, aircraftMass, alwaysRender, attachToBone, attitudeAxes, baseGeometryOf, beginSpan, boneContact, boneLengthDeviations, boneLengths, bvhIntersectFirstHit, clipBoneCoverage, clipPoseError, clipTrackBindings, createReplayDriver, describeSceneShape, describeSceneWarning, directionFromSolarPosition, directionalTransmittance, displayPeriodMs, endSpan, formatSceneWarning, formatSpansWindow, formatValidationReport, gearClearance, getPlatform, installSpanProbes, invalidateStatic, isMobile, isNative, isStatic, isTouchscreenAvailable, isWeb, loadAll, markStatic, measureThreePose, mergeParts, normaliseToMetres, onLaunchFailure, parseReplayRecording, posedBounds, rayStruct, readProbeVolumeObservation, readVirtualShadowMarker, refreshStaticTransforms, renderListValidationRequested, replay, resetStaticTransforms, resolveAtmosphereLutResolutions, resolveAtmosphereParameters, sceneWarning, setAttitude, setSpanRecorder, skeletonBones, softCircleDataTexture, solarPosition, solarPositionAt, spanNow, spanRecorder, spansRequested, staticTransformCensus, unmarkStatic, updateAtmosphereParameters, updateClusteredMeshes, updateModelLods, validateWorldMatrices, version, zenithTransmittance };