@threenative/core 0.3.3 → 0.3.4

package/dist/index.d.ts

@@ -1,16 +1,17 @@
 import * as three from 'three';
-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';
+import { Object3D, AnimationClip, AnimationMixer, Camera, Vector3, Group, Matrix4, Mesh, BufferGeometry, InstancedMesh, Material, ColorRepresentation, Box3, Scene, DirectionalLight, HemisphereLight, Color, FogExp2, Sprite, DataTexture, CatmullRomCurve3, Texture } from 'three';
+export { I as IAssetLoader, a as IAssetLoaderOptions, b as ITextureOptions, c as createAssetLoader, r as reconcileMirroredClips } from './assets-CqvE429w.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';
+export { C as CanvasLayer } from './canvas-layer-DDmC_VVF.js';
+import { a as IGamePluginRuntime, b as IGamePluginHooks } from './game-CljaDv4D.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 InputMap, a3 as InputPlatformSource, a4 as PointerEvent3DListener, a5 as PointerEvent3DType, a6 as PointerEvents3D, a7 as Scene, a8 as SceneFrame, a9 as ScenePicker, aa as ScheduleHandle, ab as Scheduler, ac as ThreeNativeBackgroundMode, ad as ThreeNativeLodMinTrianglesScope, ae as ThreeNativeLodPreset, af as ThreeNativeOrientation, ag as ThreeNativeUiRenderer, ah as WarmUpCacheStatus, ai as WarmUpObservationStatus, aj as afterPhysics, ak as captureMouse, al as createRandom, am as defineGame, an as warmUpScene } from './game-CljaDv4D.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, 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 { I as IRendererLike, F as FramePassKind, a as IFrameBudgetWindow } from './renderer-CfsS2hxi.js';
+export { D as DEFAULT_PIPELINE_CENSUS_LIMIT, b as DEFAULT_TARGET_FPS, c as FRAME_BUDGET_MARKER, d as FRAME_BUDGET_PHASES, e as FRAME_HITCH_MARKER, f as FrameBudget, g as FrameBudgetPhase, h as FrameCounters, i as ICounterDevice, j as IFrameBudgetOptions, k as IFrameBudgetPassSummary, l as IFrameBudgetSummary, m as IFrameCounters, n as IFramePhaseSample, o as IPipelineCensus, p as IPipelineCensusCounts, q as IPipelineCensusEvent, r as IPipelineCensusOptions, s as IPipelineProvenance, t as IPipelineShaderObservation, u as IPlatformInfo, v as IRenderChainApplied, w as IRenderChainBudgetWindow, x as IRenderChainDroppedStage, y as IRenderChainOptions, z as IRenderChainRenderer, A as IRenderChainRequest, B as IRenderChainStage, C as IRenderChainStageContext, E as IRenderChainVelocityMeasurement, G as IRenderChainVelocityReport, H as IRenderChainVelocityRequest, J as IRenderChainVelocityResult, K as IRenderPassSample, L as ITargetFps, M as IVelocityRenderPass, N as MAX_TARGET_FPS, P as PIPELINE_CENSUS_CAPABILITY, O as PIPELINE_CENSUS_VERSION, Q as PipelineCensus, R as PipelineCensusMode, S as PipelineCensusStatus, T as PlatformFormFactor, U as PlatformOS, V as PlatformRuntime, W as RENDER_CHAIN_MARKER, X as RENDER_CHAIN_STAGE_ORDER, Y as RENDER_CHAIN_TIERS, Z as RenderChain, _ as RenderChainSource, $ as RenderChainStageId, a0 as RenderChainStageName, a1 as RenderChainTier, a2 as RenderChainTierRequest, a3 as RenderChainVelocitySource, a4 as TargetFpsSource, a5 as VELOCITY_OUTPUT_NAME, a6 as VELOCITY_PREVIOUS_BONE_MATRICES, a7 as VELOCITY_PREVIOUS_INSTANCE_MATRICES, a8 as VELOCITY_PREVIOUS_WORLD_MATRIX, a9 as VelocityTracker, aa as counterDeviceOf, ab as createPipelineCensus, ac as ensureVelocityOutput, ad as getPlatform, ae as isMobile, af as isNative, ag as isTouchscreenAvailable, ah as isWeb, ai as prewarm, aj as readRenderChainObservation, ak as readRenderChainReport, al as readVelocityPreviousBoneMatrices, am as readVelocityPreviousMatrices, an as readVelocityPreviousWorldMatrix, ao as resolveTargetFps, ap as snapRefreshRate, aq as velocityTexture, ar as withVelocityContext } from './renderer-CfsS2hxi.js';
+import { I as IComputeDriven$1, a as IGPUReadbackSample } from './gpu-readback-CqJEfWNQ.js';
+export { C as ComputeDrivenRegistry, G as GPUReadback, b as IGPUReadbackOptions } from './gpu-readback-CqJEfWNQ.js';
+import { SkyMesh } from 'three/addons/objects/SkyMesh.js';
 import { Node as Node$1 } from 'three/src/nodes/Nodes.js';
 import 'zustand/vanilla';
 
@@ -757,6 +758,15 @@ interface IInstancedBatchBuildOptions {
     readonly parent?: Object3D;
     /** Passed straight to the built mesh. Default `false`, as in Three.js. */
     readonly receiveShadow?: boolean;
+    /**
+     * An existing mesh to refill instead of creating one: used when it draws this batch's geometry
+     * and material and holds at least this many instances. Reusing matters on WebGPU, where three
+     * keys an instanced mesh's compiled node program by the mesh itself — every new InstancedMesh
+     * rebuilds its shader, and a streamed world creating hundreds a cell stalls on it.
+     */
+    readonly into?: InstancedMesh;
+    /** Instance slots to allocate when a new mesh is created, so later refills fit. Default: count. */
+    readonly capacity?: number;
 }
 /**
  * Collapses many copies of one shape into a single draw, without knowing the count up front.
@@ -777,8 +787,22 @@ declare class InstancedBatch {
     constructor(options: IInstancedBatchOptions);
     /** How many instances have been placed so far. */
     get count(): number;
+    /**
+     * Writes every placed matrix into `target` (a mesh's `instanceMatrix.array`), starting at instance
+     * `offset`, and returns how many were written. For a caller that packs several batches into one
+     * shared instance buffer instead of building a mesh per batch.
+     */
+    writeMatrices(target: Float32Array, offset: number): number;
     /** The built mesh, or `undefined` before {@link build} — never a guess. */
     get mesh(): InstancedMesh | undefined;
+    /**
+     * True when this batch holds element-for-element the matrices of `other`.
+     *
+     * A refilter rebuilds a cell's batch from the same run in the same order, so "did the answer
+     * change" is exactly this question, and comparing is what lets the swap skip a rebuild that came
+     * back identical instead of writing, clearing and compacting records the buffer already holds.
+     */
+    equals(other: InstancedBatch | undefined): boolean;
     /**
      * Records one instance from a matrix the game composed itself, and returns its instance index.
      *
@@ -833,6 +857,33 @@ interface IMergePartsOptions {
      */
     readonly preserve?: readonly ("uv" | "normal")[];
 }
+interface IMergeByMaterialOptions {
+    /** Named in the error when a group's merge is refused. Say what was being built. */
+    readonly label: string;
+    /**
+     * Leaves one mesh out of its material's group and out of the result — a piece that moves at run
+     * time, or one a capture script addresses by name.
+     */
+    readonly skip?: (mesh: Mesh) => boolean;
+    /**
+     * An `InstancedMesh` is baked into its material's group as one part per instance matrix while that
+     * group stays at or below this many triangles. Above it — or absent, which is the old behaviour —
+     * it comes back in the result untouched, because one instanced draw is already cheaper than the
+     * triangles it expands into.
+     */
+    readonly expandInstancedUnderTriangles?: number;
+    /**
+     * Vertices one merged group may hold before the rest of its material's parts start a second mesh.
+     *
+     * One merged group is one upload on the frame that first draws it, and that upload is the frame's
+     * whole cost: measured in a browser, a streamed world created 826 GPU buffers totalling 228.8 MB
+     * out of `createAttribute`, 33 of them over 1 MB, and the first draw of the largest chunk meshes
+     * took up to 230 ms. Splitting a material group in traversal order — which keeps the pieces
+     * adjacent to the pieces they were placed beside — bounds each of those uploads instead of
+     * trading one draw for a single enormous buffer. See `CHUNK_MERGE_MAX_VERTICES`.
+     */
+    readonly maxGroupVertices?: number;
+}
 /**
  * Merge game-authored pieces into one buffer, keeping each piece's own colour and, when asked,
  * its uv and authored normals.
@@ -846,8 +897,69 @@ interface IMergePartsOptions {
  * 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.
+ *
+ * A group whose parts are all indexed merges indexed — the sum of their vertex counts, not three
+ * times their triangles — and only a mixed group falls back to the de-indexed soup. One crossing
+ * 65,535 vertices gets a 32-bit index, because a 16-bit one cannot name the vertex.
  */
 declare function mergeParts(parts: Iterable<IMergePart>, options: IMergePartsOptions): BufferGeometry;
+/**
+ * Bake a hierarchy's static meshes into one mesh per material, transforms and all.
+ *
+ * A building or a ship is dozens of boxes and cylinders that never move relative to each other, and
+ * every one of them is a draw call. Grouping by material and merging each group is the ordinary
+ * fix, and the ordinary fix is thirty lines an agent rewrites in every game, each time slightly
+ * differently: walk the tree, group by material, bake `matrixWorld` into the vertices, hand the
+ * group to `mergeParts`, build a mesh on the game's own material. The parts here are the same
+ * `IMergePart` list, so a game that already merges by hand gets the same refusals — a group that
+ * cannot merge throws naming `label:material`, not silently vanishing.
+ *
+ * Nothing here decides how anything looks: the material is the game's own instance, the geometry is
+ * exactly what was authored, and the group split follows the materials the game already made.
+ *
+ * `normal` survives when every mesh in a group carries it and is recomputed otherwise. `uv` survives
+ * when any mesh carries it, so a group where only some do is the refusal `mergeParts` raises, never
+ * a texture silently left unmapped. Skinned meshes are left alone — their vertices are posed per
+ * frame — and an instanced one is left alone unless `expandInstancedUnderTriangles` names a cap its
+ * group fits under and its own shape is small enough to be worth repeating, which bakes every
+ * instance matrix into the merge.
+ *
+ * `maxGroupVertices` bounds a single group, and a material whose parts cross it is merged into
+ * several meshes in traversal order — more draws, none of them carrying a buffer big enough to stall
+ * the frame that first submits it.
+ */
+declare function mergeByMaterial(root: Object3D, options: IMergeByMaterialOptions): Mesh[];
+
+/**
+ * A debug switch a game reads the same way on every platform it ships to.
+ *
+ * Two questions an agent answers differently in every game, both of which cost a rewrite: how do I
+ * turn this on for one run without changing the code, and how does a capture script reach the object
+ * it wants to look at. The answers here are one function each, and neither decides how anything
+ * looks.
+ */
+/**
+ * A debug switch read from the URL, or from the environment on a native launch.
+ *
+ * @situation read a debug toggle from the URL or an environment variable
+ *
+ * A browser asks with the query string — `?freeCam`, or `?freeCam=0` to force it off — and a native
+ * launch asks with `TN_DEBUG_FREE_CAM`, because a query string is not something a developer sets on
+ * a command line. `0` and `false` are off, so a saved URL that used to enable a switch still says
+ * "off" rather than quietly turning it back on.
+ */
+declare function debugFlag(name: string): boolean;
+/**
+ * Publish one game object for a capture script or the console, in development builds only.
+ *
+ * @situation expose a game object to a capture script or the console in dev builds
+ *
+ * Playtest reads `__THREENATIVE__` in a dev build and is silent in a production one, so a game that
+ * publishes its player, its camera or a scene handle under `.debug` is reachable from the same
+ * place a production build is not. Other keys on the shared object are left alone; the dev surfaces
+ * the engine installs beside them keep working.
+ */
+declare function exposeDebug(name: string, value: unknown): void;
 
 /**
  * A mesh that draws only the clusters this camera can resolve.
@@ -1015,6 +1127,14 @@ declare class ClusteredBatch {
     update(camera: Camera, viewportHeight: number): number;
 }
 
+/**
+ * Pixels a one-world-unit error at `depth` covers, for this camera and viewport.
+ *
+ * Perspective divides the projected scale by the depth; orthographic has no depth term and uses the
+ * frustum height instead. A non-positive depth or an unprojectable camera throws rather than
+ * returning a plausible-looking wrong scale.
+ */
+declare function lodPixelScale(camera: Camera, viewportHeight: number, depth: 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;
 /**
@@ -1609,6 +1729,8 @@ interface IClipWindow {
     readonly level: number;
     readonly extent: number;
     readonly pageWorldSize: number;
+    /** Pages a window trails its followed centre by before it moves and re-renders. */
+    readonly refreshPages: number;
     readonly minX: number;
     readonly minY: number;
     readonly maxX: number;
@@ -1620,8 +1742,18 @@ interface IDirectionalClipmapOptions {
     /** Half-width of each level's window in world units, finest first. */
     readonly clipExtents: readonly number[];
     readonly pagesPerAxis: number;
-    /** Fraction of an extent inside which a point selects that level; `(0, 1]`. */
-    readonly selectionGuard?: number;
+    /**
+     * Fraction of an extent inside which a point selects that level, `(0, 1]`, default 0.9. One value
+     * for every level, or one per level finest first, the last entry standing in for the rest.
+     */
+    readonly selectionGuard?: number | readonly number[];
+    /**
+     * Fraction of an extent a level's window may trail its followed centre by before it re-renders,
+     * `[0, 1)`, default 0.125. Rounded to a whole number of the level's texels, so `0` keeps the
+     * old one-texel step. Larger steps re-render a level less often as the camera walks. One value
+     * for every level, or one per level finest first, the last entry standing in for the rest.
+     */
+    readonly refreshStep?: number | readonly number[];
 }
 /**
  * Camera-centred clip windows in a light-space basis, snapped to whole pages.
@@ -1634,14 +1766,21 @@ declare class DirectionalClipmap {
     #private;
     readonly clipExtents: readonly number[];
     readonly pagesPerAxis: number;
-    readonly selectionGuard: number;
+    /**
+     * Per level, finest first; the last entry stands in for every level past it. Mutable through
+     * {@link setRefreshStep} so a level whose own render is expensive can be stepped further, which
+     * is fewer grid positions for its window rather than a different grid.
+     */
+    refreshStep: number[];
+    /** Per level, finest first; the last entry stands in for every level past it. */
+    readonly selectionGuard: readonly number[];
     readonly levelCount: number;
     basisU: IVector3Like;
     basisV: IVector3Like;
     basisW: IVector3Like;
     centerWorld: IVector3Like;
     centerLight: ILightSpacePoint;
-    constructor({ direction, clipExtents, pagesPerAxis, selectionGuard, }: IDirectionalClipmapOptions);
+    constructor({ direction, clipExtents, pagesPerAxis, selectionGuard, refreshStep, }: IDirectionalClipmapOptions);
     /** Re-orient the basis; returns true when it changed enough that cached pages are stale. */
     setDirection(direction: IVector3Like): boolean;
     project(worldPoint: IVector3Like): ILightSpacePoint;
@@ -1650,6 +1789,8 @@ declare class DirectionalClipmap {
         v: number;
         w?: number;
     }): IVector3Like;
+    /** Re-step one level's window: the trail its followed centre may move before it re-renders. */
+    setRefreshStep(level: number, step: number): void;
     updateCenter(worldPoint: IVector3Like): readonly IClipWindow[];
     getWindow(level: number): IClipWindow;
     pageWorldSize(level: number): number;
@@ -1722,12 +1863,130 @@ interface IVirtualShadowOptions {
     /**
      * Fraction of a level's extent inside which a fragment still selects that level, `(0, 1]`,
      * default 0.9 — the outer ring falls through to the next level so the edge is never sampled.
+     * `selectionGuard` minus `refreshStep`, since a window trails its centre by that much. One value
+     * for every level, or one per level finest first, the last entry standing in for the rest.
+     */
+    readonly selectionGuard?: number | readonly number[];
+    /**
+     * Fraction of a level's extent its window may trail the followed centre by before it re-renders,
+     * `[0, selectionGuard)`, default 0.125 — `refreshStep: 0` keeps the old one-texel step. The step
+     * is rounded to a whole number of that level's texels, so a walking camera re-renders a level
+     * ~`1/refreshStep` times less often while the shadow texels stay on one fixed world grid. Costs
+     * that much of `selectionGuard`, which it is already reduced by, so a window never reaches past
+     * the trailing edge of a map rendered before the centre moved. One value for every level, or one
+     * per level finest first, the last entry standing in for the rest — the fine level is the one a
+     * walking camera re-renders most, so it is the one that wants the larger step.
+     */
+    readonly refreshStep?: number | readonly number[];
+    /**
+     * Let a level buy itself a wider `refreshStep` out of what its own last render cost, default true.
+     *
+     * A level render is a whole scene draw, so the engine cannot know what one is worth until it has
+     * paid for it: the node measures the draw it just took and smooths that reading, and a level whose
+     * smoothed cost is a large share of the frame period is re-rendered less often. This is automatic
+     * because the value it reacts to is a measurement, not a setting — a game sets nothing, and a
+     * cheap level is never widened and behaves exactly as before. The widened trail is capped by the
+     * window's own margin, so the camera stays inside the region that level serves and everything that
+     * level serves stays inside the map; a level with no such margin is never widened at all.
+     *
+     * `false` puts every level back on the `refreshStep` it was given, which is also what a harness
+     * that wants to count today's renders uses.
+     */
+    readonly adaptiveRefresh?: boolean;
+    /**
+     * Fraction of the display period a level's smoothed render cost may take before its refresh trail
+     * widens, `(0, 1]`, default 0.4.
+     *
+     * The period is the frame's own `deltaTime`, capped at the 60 fps frame (16.7 ms). The cap is what
+     * keeps the budget honest: the frame that renders an expensive level is itself long because of that
+     * render, so reading the share against its own inflated delta would count the cost twice and let
+     * the very level that needs adapting pass its own test. At 60 Hz the cap is the frame itself; on a
+     * 120 Hz panel the same render is twice the share it is at 60; below 60 the cap holds the budget
+     * at the 60 fps frame rather than growing with the stall. Below the share nothing changes at all,
+     * and above it the trail widens in proportion to the overshoot,
+     * because that is the ratio between what the level costs and what a frame can afford to spend on
+     * it — a level four times over the share refreshs about four times less often, until the cap
+     * below it runs out.
+     */
+    readonly expensiveRefreshShare?: number;
+    /**
+     * Raise a level's texel size gate while its own render is too expensive for the frame, default
+     * true.
+     *
+     * The same measurement adaptive refresh reads — the smoothed cost of the level's own last render,
+     * against the share of the frame it may take — drives a second, independent adaptation: a level
+     * whose render is over budget sizes its gate up in steps of 1.5 until it is affordable again, up
+     * to 8 times the configured gate, and halves it back toward 1 once the render is comfortably under
+     * half the budget. The gate only ever judges a caster by its size (see `minCasterTexels`), so this
+     * drops the tiniest props first and never a building, and a level that is cheap is never touched:
+     * it stays at scale 1 and submits exactly what it did before.
+     *
+     * `false` pins every level at scale 1, which is also what a harness that wants today's draw
+     * counts uses.
+     */
+    readonly adaptiveCasterGate?: boolean;
+    /**
+     * How long a level waits after its own last render before an invalidation may re-render it, in
+     * seconds. One value for every level, or one per level finest first, the last entry standing in
+     * for the rest. Default `0.25 * extent / finestExtent` — 0.25 s, 1 s and 3.33 s for extents
+     * 24 / 96 / 320 — and `0` renders on the very next frame, which is what the node did before.
+     *
+     * A streamed world invalidates its shadows on every residency update, and a cell admitted at the
+     * ring edge lands in the coarsest window: the level that redraws for it is the one paying for the
+     * whole ring's wide casters, ten times a second where movement alone asks for two. A level
+     * waiting out its delay keeps the map and window it has, which is already right for every static
+     * caster in it, so only a newly streamed caster is missing — the trade is that a far tree's
+     * shadow can appear up to the delay late (3.33 s at extent 320, invisible on a level whose texel
+     * is wider than the tree). A window that moved is never delayed: that is a different reason, and
+     * it is not this option's.
+     */
+    readonly invalidationDelay?: number | readonly number[];
+    /**
+     * How far behind the window centre each level camera sits, in world units. Default 200. An
+     * explicit `lightDistance` *and* `depthRange` switch the level's light-space depth off the derived
+     * span below and back onto this pair, so a game that knows its own world sizes can still say so.
      */
-    readonly selectionGuard?: number;
-    /** How far behind the window centre each level camera sits, in world units. Default 200. */
     readonly lightDistance?: number;
-    /** Depth range each level camera covers past its centre, in world units. Default 400. */
+    /**
+     * Depth range each level camera covers past its centre, in world units. Default 400. Read only
+     * together with `lightDistance`; on its own the span is still derived.
+     */
     readonly depthRange?: number;
+    /**
+     * Texels of a level a caster must cover before it draws into that level, default 1.5. A level's
+     * texel is `2 * extent / mapSize`, so the finest levels keep everything and the coarse ones keep
+     * only what they can resolve: a fern is a whole number of texels in a 48 m window and a fraction
+     * of one in a 640 m window, so it stops being drawn there and the shadow it casts is the ground
+     * cover's own, not its silhouette's. Set 0 to draw every caster into every level.
+     */
+    readonly minCasterTexels?: number;
+    /**
+     * Draw every level past the finest one with less geometry than the main pass would, default true.
+     *
+     * Two defaults, both Unreal's and both applied in one place — the traverse a level render already
+     * makes over the casters in its window, where each of the two is a change to the object three
+     * draws from and is put back the moment that render is over:
+     *
+     * 1. **Shadow LOD bias.** A mesh whose geometry carries a registered AutoLOD chain
+     *    (`lodChainOf`) is submitted with the chain's *coarsest* geometry. A level 2 window cannot
+     *    resolve a tree's needles, so drawing LOD0 there is a texel of needles per texel of shadow;
+     *    the coarse level's own texel is metres wide. Level 0 draws what the main pass draws.
+     * 2. **Alpha-caster range.** An alpha-tested (`alphaTest > 0`) or transparent mesh casts into the
+     *    finest level only. Its cutout is its own texture: a coarse level either drops it — the
+     *    level's texel is wider than the card, so the fence is sub-texel — or keeps resolving a
+     *    texture it cannot afford. This is a per-primitive shadow cull distance, and the trade is
+     *    honest and one-sided: a fence's or a foliage card's shadow ends where the finest level's
+     *    window ends, and a wide level shows bare ground where it stood. Opaque casters — a merged
+     *    chunk's position-only proxy, a tree's silhouette — are drawn on every level as before.
+     *
+     * Neither is left changed: a hidden caster's `castShadow` and a coarse mesh's `geometry` are put
+     * back before the next level, before the mover maps and before the main pass, which see the world
+     * exactly as the game authored it. Mover maps keep full detail — a 256² map over the level's own
+     * window, drawing only the tracked casters.
+     * `false` puts every level back on stock full-detail draws, which is what the node did before
+     * either default existed.
+     */
+    readonly shadowLodBias?: boolean;
     /** Print the `TN_VIRTUAL_SHADOW` line every `markerEvery` frames; `false` silences it. Default 300. */
     readonly marker?: boolean | number;
 }
@@ -1747,8 +2006,76 @@ interface IVirtualShadowStats {
     readonly cached: number;
     /** Levels rendered this frame, for any reason. */
     readonly rendered: number;
+    /**
+     * Levels that wanted a render this frame and did not get one, because the node renders at most
+     * one level per frame. They keep the map they already have and come due again next frame.
+     */
+    readonly deferred: number;
+    /**
+     * Levels holding a redraw for an invalidation that is still inside its own `invalidationDelay`,
+     * so this frame is not the frame they render on. They keep the map they have, which is right for
+     * every static caster in it: only a caster streamed in since is missing, and the cumulative
+     * `coalesced` below is what is being waited out.
+     */
+    readonly held: number;
     /** Fraction of levels served from cache over the node's lifetime. */
     readonly reuseRatio: number;
+    /**
+     * Level renders over the node's lifetime, for any reason. `byMove` and `byInvalidation` are the two
+     * the node has — a window that moved, and an invalidation that asked and waited out its delay — and
+     * they add up to this exactly, because a render the single per-frame budget defers is counted
+     * against the reason that queued it and not again when it is finally taken.
+     */
+    readonly rendersTotal: number;
+    /** Of those, the renders taken because a level's window moved. */
+    readonly byMove: number;
+    /** Of those, the renders taken because an invalidation asked and its level's delay had passed. */
+    readonly byInvalidation: number;
+    /**
+     * Invalidation asks that cost no render of their own, over the node's lifetime: absorbed by a
+     * render the level was taking anyway for its window, or merged into an ask already waiting out
+     * that level's delay. The two of these are the shape of the win — with the default delays a walk
+     * asks once a second and renders about that often, and every ask in between is counted here.
+     */
+    readonly coalesced: number;
+    /**
+     * The same four counters per level, finest first: which window moved, which invalidation asked
+     * for a redraw, which level took the frame's single render, and which wanted one and did not get
+     * it. One entry per level per frame, so a harness reading this — or the `TN_VIRTUAL_SHADOW`
+     * marker line, which carries it — can see which level a walk keeps re-rendering instead of only
+     * how many.
+     */
+    readonly perLevel: readonly IVirtualShadowLevelStat[];
+}
+/** One level's row of {@link IVirtualShadowStats}: 1 or 0 per counter, per frame. */
+interface IVirtualShadowLevelStat {
+    /** The level's clip extent, in world units. */
+    readonly extent: number;
+    readonly deferred: number;
+    readonly invalidated: number;
+    readonly moved: number;
+    readonly rendered: number;
+    /** Caster meshes this level's chosen camera layers submit this frame. Zero if it did not render. */
+    readonly draws: number;
+    /** The same bill split by kind; the five parts sum to {@link draws}. */
+    readonly drawsBy: IVirtualShadowDraws;
+    /** The adaptive caster gate's scale on this level, 1 when it is not shedding casters. */
+    readonly gateScale: number;
+    /** Casters the gate hid on the render this level took this frame; zero if it did not render. */
+    readonly gateHidden: number;
+}
+/** One level's caster draws, by the kind of mesh that submitted them. */
+interface IVirtualShadowDraws {
+    /** Caster batch meshes on the cluster layer, when the cluster half is the level's choice. */
+    readonly cluster: number;
+    /** Key-wide caster meshes on the wide layer, when the wide half is the level's choice. */
+    readonly wide: number;
+    /** Small casters, submitted by the finest level and by any level rendering a prewarm. */
+    readonly small: number;
+    /** Merged per-chunk shadow proxies (`<name>-shadow`), drawn with the cluster half. */
+    readonly chunkProxy: number;
+    /** Everything else casting from layer 0 — terrain, props — which every level draws. */
+    readonly layer0: number;
 }
 declare const VIRTUAL_SHADOW_MARKER = "TN_VIRTUAL_SHADOW";
 /**
@@ -1756,6 +2083,21 @@ declare const VIRTUAL_SHADOW_MARKER = "TN_VIRTUAL_SHADOW";
  * Keep it free of other uses; the main camera never needs it (tracked objects keep layer 0).
  */
 declare const VIRTUAL_SHADOW_MOVER_LAYER = 29;
+/**
+ * The object layer a shadow-only caster is put on, so each level's own shadow camera renders it and
+ * the main camera never sees it. The level cameras have it enabled already; an object that exists
+ * only as a shadow caster calls `object.layers.set(VIRTUAL_SHADOW_CASTER_LAYER)`.
+ */
+declare const VIRTUAL_SHADOW_CASTER_LAYER = 28;
+/**
+ * The wide counterpart of {@link VIRTUAL_SHADOW_CASTER_LAYER}: one caster mesh per
+ * `asset:level:part` holding every resident cell's records, for the levels whose window covers the
+ * whole resident ring. A level renders exactly one of the two caster layers — whichever submits
+ * fewer draws, counted off the meshes themselves, because a cluster per square is a draw per square
+ * for the same pixels once the window holds the ring. `WorldCells` writes both halves of every key,
+ * so whichever a level picks is there; the main camera renders neither.
+ */
+declare const VIRTUAL_SHADOW_WIDE_CASTER_LAYER = 27;
 /**
  * One directional shadow for a whole open world: camera-centred clip levels, each snapped to its
  * own texel grid and re-rendered only when its window moves. Movers never touch that cache: a
@@ -1770,7 +2112,9 @@ declare const VIRTUAL_SHADOW_MOVER_LAYER = 29;
  * map type and filter, and those source settings are mirrored into each stock level node before
  * rendering. Per-level map sizes, cameras, `autoUpdate` and `needsUpdate` are owned by this node.
  * Each level is rendered by the stock {@link ShadowNode} through the renderer's shadow-map type,
- * so the look is the same code path a plain shadow uses.
+ * so the look is the same code path a plain shadow uses. At most one level renders per frame,
+ * finest first — a level render is a whole scene draw, and a level passed over keeps the map and
+ * window it has, so a fragment only ever samples a map that level drew.
  *
  * Ported from the virtual-shadow-map prototype's clipmap and invalidation; the sparse page atlas
  * is deliberately not the first cut — a page needs the scene rendered once per page, and on a
@@ -1793,8 +2137,18 @@ declare const VIRTUAL_SHADOW_MOVER_LAYER = 29;
 declare class VirtualShadowNode extends ShadowBaseNode {
     #private;
     static get type(): string;
-    readonly options: Required<Omit<IVirtualShadowOptions, "marker">> & {
+    readonly options: Required<Omit<IVirtualShadowOptions, "marker" | "refreshStep" | "selectionGuard" | "invalidationDelay">> & {
         readonly markerEvery: number;
+        /** Per level, finest first; the last entry stands in for every level past it. */
+        readonly refreshStep: readonly number[];
+        /** The per-level `selectionGuard` each level's own window is drawn with. */
+        readonly selectionGuard: readonly number[];
+        /**
+         * Per level, finest first: the seconds a dirty level waits after its own last render before an
+         * invalidation may re-render it. Already scaled by that level's extent, so the fine levels
+         * answer a streamed caster promptly and the coarse ones let a burst merge into one render.
+         */
+        readonly invalidationDelay: readonly number[];
     };
     readonly clipmap: DirectionalClipmap;
     /**
@@ -1820,6 +2174,18 @@ declare class VirtualShadowNode extends ShadowBaseNode {
     untrackCaster(objectOrId: Object3D | string): boolean;
     /** Force every level to re-render on the next frame — a tree fell, a door opened. */
     invalidateAll(): void;
+    /**
+     * Force only the levels whose current window covers `bounds`, on the next frame. A streamed world
+     * that hands its shadow casters over has a moving near set, and a blanket `invalidateAll()` on
+     * every refresh redrew all three levels for a change that lands in one corner of one of them. A
+     * level whose window does not cover the region draws the same thing either way, so skipping it is
+     * the same frame with fewer draws in it.
+     *
+     * `bounds` is `{ min: {x,y,z}, max: {x,y,z} }`, a plain object so a game can hand one over without
+     * importing three. Regions are consumed by the next `updateBefore`; one that arrives before the
+     * levels exist is dropped, because their first frame renders all of them anyway.
+     */
+    invalidateRegion(bounds: IBoundsLike): void;
     setup(builder: NodeBuilder): Node | null | undefined;
     updateBefore(frame: NodeFrame): undefined;
     dispose(): void;
@@ -1835,6 +2201,87 @@ declare class VirtualShadowNode extends ShadowBaseNode {
  */
 declare function readVirtualShadowMarker(line: string): IVirtualShadowStats | undefined;
 
+/** Every value is the game's: this rig wires them and chooses none. */
+interface IDaylightOptions {
+    /** The eye the sky, the sun's shadow windows and the haze centre on; usually the camera. */
+    readonly follow: Object3D;
+    /** Unit vector from the ground towards the sun. */
+    readonly sunDirection: Vector3;
+    readonly sunColor: Color;
+    /** Irradiance in three's physical units; the same number a Blender sun strength carries. */
+    readonly sunIntensity: number;
+    /** Half-widths of the shadow windows in world units, finest first, strictly increasing. */
+    readonly shadowExtents: readonly number[];
+    /**
+     * How far a window may trail the camera before it re-renders, as a fraction of its own extent:
+     * one value for every level, or one per level finest first, the last entry standing in for the
+     * rest. One for all of them spends the hysteresis the fine level can least afford on the coarse
+     * one, which is the level a walking camera re-renders least. Default 0.125.
+     */
+    readonly refreshStep?: number | readonly number[];
+    /** Preetham sky parameters, as three's `SkyMesh` takes them. */
+    readonly sky: {
+        readonly turbidity: number;
+        readonly rayleigh: number;
+        readonly mieCoefficient: number;
+        readonly mieDirectionalG: number;
+    };
+    /** Sky fill from above and bounce from below, as a hemisphere light. */
+    readonly fill: {
+        readonly sky: Color;
+        readonly ground: Color;
+        readonly intensity: number;
+    };
+    /** Exponential-squared haze in the sky's horizon colour, so distance fades into the sky. */
+    readonly haze: {
+        readonly color: Color;
+        readonly density: number;
+    };
+    /** Linear exposure multiplier for the AgX tone curve (2^EV). */
+    readonly exposure: number;
+    /**
+     * Edge of the sky box in world units. It must sit inside the camera's far plane with its corners
+     * included (a box, so half-diagonal ≈ 0.87 × this).
+     */
+    readonly skySize: number;
+}
+/**
+ * An outdoor daylight rig: a physical sky that stays on the eye, one sun whose open-world shadow
+ * windows follow the eye (`VirtualShadowNode`), a hemisphere fill, sky-coloured distance haze and
+ * the AgX tone curve at the game's exposure. It is plumbing, not a look: every colour, angle,
+ * intensity and density is a required option, and the rig adds nothing a game did not ask for.
+ *
+ * Add it with `ctx.add(daylight)`: `attachRenderer` sets tone mapping, exposure and the shadow map
+ * once, and `process` (render cadence) keeps the sky box, the sun and its target on the eye every
+ * frame, so a 2 km map never walks out of its own sky or shadow.
+ *
+ * @situation daytime sky, sun and shadows for a large outdoor map
+ * @situation distant terrain should fade into the sky instead of a coloured wall
+ * @situation match a Blender look-dev scene's sun, sky and exposure in the game
+ * @constraint every value is required; there is no default sun, sky, haze or exposure
+ * @constraint `skySize` must keep the sky box's corners inside the camera's far plane
+ * @constraint shadowExtents follow `VirtualShadowNode`: half-widths, finest first, strictly increasing
+ * @override sky uniforms stay live on `daylight.sky`; the light and fill are `daylight.sun` and `daylight.fill`
+ * @example
+ * const daylight = new Daylight({ follow: ctx.camera, sunDirection, sunColor, sunIntensity: 4, shadowExtents: [24, 96, 320], sky: { turbidity: 3, rayleigh: 1.4, mieCoefficient: 0.004, mieDirectionalG: 0.8 }, fill: { sky, ground, intensity: 1.1 }, haze: { color: horizon, density: 0.0011 }, exposure: 2 ** -0.6, skySize: 1600 });
+ * ctx.add(daylight);
+ */
+declare class Daylight extends Group implements IComputeDriven$1 {
+    #private;
+    readonly warmupNodes: readonly unknown[];
+    readonly processCadence: "render";
+    readonly sky: SkyMesh;
+    readonly sun: DirectionalLight;
+    readonly fill: HemisphereLight;
+    constructor(options: IDaylightOptions);
+    get released(): boolean;
+    /** The haze this rig owns; `attachRenderer` puts it on the scene the rig was added to. */
+    get haze(): FogExp2;
+    attachRenderer(renderer: IRendererLike): void;
+    process(): void;
+    detach(): void;
+}
+
 /**
  * Two load-time mechanisms every streaming game writes by hand, and gets wrong in the same places.
  *
@@ -2938,21 +3385,6 @@ declare function measureThreePose(object: Object3D, options?: IMeasureThreePoseO
  */
 declare function posedBounds(root: Object3D, meshes?: readonly Object3D[]): IThreePoseBounds;
 
-type PlatformRuntime = "web" | "native";
-type PlatformOS = "android" | "ios" | "linux" | "macos" | "windows" | "unknown";
-type PlatformFormFactor = "mobile" | "desktop" | "unknown";
-interface IPlatformInfo {
-    readonly runtime: PlatformRuntime;
-    readonly os: PlatformOS;
-    readonly formFactor: PlatformFormFactor;
-    readonly maxTouchPoints: number;
-}
-declare function getPlatform(): Readonly<IPlatformInfo>;
-declare function isWeb(): boolean;
-declare function isNative(): boolean;
-declare function isMobile(): boolean;
-declare function isTouchscreenAvailable(): boolean;
-
 type ReplayPointer = readonly [number, number, number, number, number];
 interface IReplayRecordingSample {
     readonly keys: readonly string[];
@@ -3210,6 +3642,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.3";
+declare const version = "0.3.4";
 
-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 };
+export { ATLAS_PADDING, ATMOSPHERE_LUT_RESOLUTIONS, AnimationPlayer, Atmosphere, type AtmosphereDirection, AtmosphereLuts, type AtmosphereRgb, Billboard3D, type BillboardLockAxis, CameraShake, type CameraShakeCurve, ClusteredBatch, ClusteredMesh, Daylight, 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 IDaylightOptions, 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 IMergeByMaterialOptions, type IMergePart, type IMergePartsOptions, type INormaliseToMetresOptions, type IPathFollow3DOptions, type IPathFollow3DProjection, type IPathFollow3DSample, 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, 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_CASTER_LAYER, VIRTUAL_SHADOW_MARKER, VIRTUAL_SHADOW_MOVER_LAYER, VIRTUAL_SHADOW_WIDE_CASTER_LAYER, VirtualShadowNode, WaterSurface3D, type WaveDirection, WaveField, addInSlices, addSpan, aerodynamicCoefficients, airDensity, aircraftMass, alwaysRender, attachToBone, attitudeAxes, baseGeometryOf, beginSpan, boneContact, boneLengthDeviations, boneLengths, bvhIntersectFirstHit, clipBoneCoverage, clipPoseError, clipTrackBindings, createReplayDriver, debugFlag, describeSceneShape, describeSceneWarning, directionFromSolarPosition, directionalTransmittance, displayPeriodMs, endSpan, exposeDebug, formatSceneWarning, formatSpansWindow, formatValidationReport, gearClearance, installSpanProbes, invalidateStatic, isStatic, loadAll, lodPixelScale, markStatic, measureThreePose, mergeByMaterial, 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 };