hilo3d 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/Hilo3d.d.ts

@@ -4304,6 +4304,8 @@ interface LightParameters extends NodeParameters {
     quadraticAttenuation?: number;
     range?: number;
     isDirty?: boolean;
+    /** Receiver-layer mask used by clustered lighting; defaults to every layer. */
+    lightLayerMask?: number;
 }
 /** Parameters shared only by light kinds that implement shadows on every rendering backend. */
 interface ShadowCastingLightParameters extends LightParameters {
@@ -4326,6 +4328,10 @@ declare class Light extends Node {
      * 光强度
      */
     amount: number;
+    private lightLayerMaskValue;
+    /** Receiver-layer mask evaluated independently from camera/node visibility. */
+    get lightLayerMask(): number;
+    set lightLayerMask(value: number);
     /**
      * 是否开启灯光
      */
@@ -4567,6 +4573,28 @@ interface SpotLightParameters extends ShadowCastingLightParameters {
     direction?: Vector3;
     cutoff?: number;
     outerCutoff?: number;
+    /** Optional analytic projected cookie for native clustered lighting. */
+    cookie?: Readonly<SpotLightCookie> | null;
+    /** Optional normalized axial IES fit for native clustered lighting. */
+    iesProfile?: Readonly<SpotLightIESProfile> | null;
+}
+/** Analytic projected cookie carried by the high-end clustered-light ABI. */
+interface SpotLightCookie {
+    /** Projected half-extent on the light plane. */
+    readonly scale?: readonly [number, number];
+    /** Projected cookie-center offset. */
+    readonly offset?: readonly [number, number];
+    /** Cookie multiplier. Defaults to one. */
+    readonly intensity?: number;
+    /** Edge transition as a fraction of the cookie extent. Defaults to 0.1. */
+    readonly softness?: number;
+}
+/** Compact axial fit for an imported IES photometric profile. */
+interface SpotLightIESProfile {
+    /** Candela multiplier after normalization. Defaults to one. */
+    readonly intensity?: number;
+    /** Axial concentration exponent. Defaults to one. */
+    readonly exponent?: number;
 }
 /**
  * 聚光灯
@@ -4576,6 +4604,16 @@ declare class SpotLight extends Light {
     isSpotLight: boolean;
     className: string;
     direction: Vector3;
+    private cookieValue;
+    private iesProfileValue;
+    /** Analytic projected cookie used by native clustered Spot lighting. */
+    get cookie(): Readonly<Required<SpotLightCookie>> | null;
+    /** Analytic projected cookie used by native clustered Spot lighting. */
+    set cookie(value: Readonly<SpotLightCookie> | null);
+    /** Normalized axial IES fit used by native clustered Spot lighting. */
+    get iesProfile(): Readonly<Required<SpotLightIESProfile>> | null;
+    /** Normalized axial IES fit used by native clustered Spot lighting. */
+    set iesProfile(value: Readonly<SpotLightIESProfile> | null);
     private cutoffCosine;
     private cutoffDegrees;
     /**
@@ -5761,6 +5799,8 @@ interface RendererContract {
     useInstanced: boolean;
     readonly cameraRelative: boolean;
     readonly renderingProfile: 'portable' | 'high-end';
+    /** Shadow-atlas page-budget policy selected when this renderer was created. */
+    readonly shadowUpdateMode: 'paged' | 'full';
     forceMaterial: MaterialInstance | null;
     clearColor: Color;
     resize(width: number, height: number, force?: boolean): void;
@@ -6169,6 +6209,162 @@ interface ScriptableRenderGraph {
     addPass<P extends object>(pass: ScriptableRenderPass<P>, parameters: P): RenderGraphPassHandle;
 }
 
+/** Sample interpretation supported by whole-subresource compute graph textures. */
+type ComputeTextureSampleType = 'float' | 'unfilterable-float' | 'depth';
+/** Compute graph textures currently expose one complete two-dimensional subresource. */
+type ComputeTextureViewDimension = '2d';
+/** Compute storage textures currently expose one complete two-dimensional subresource. */
+type ComputeStorageTextureViewDimension = '2d';
+/** Sample interpretation supported by storage-aware graphics shaders. */
+type ShaderTextureSampleType = ComputeTextureSampleType | 'sint' | 'uint';
+/** Texture views supported by the Material-backed storage graphics path. */
+type ShaderTextureViewDimension = ComputeTextureViewDimension | '2d-array' | '3d' | 'cube';
+/** Public color formats that can be requested for a storage-texture binding. */
+type ComputeStorageTextureFormat = 'r32float' | 'rg32float' | 'rgba8unorm' | 'rgba16float' | 'rgba32float';
+/** Graph initialization promise for a writable storage-buffer binding. */
+type ComputeStorageBufferAccess = 'read-write' | 'write-discard';
+/** Resource binding that a shader may only read. */
+type ShaderReadBinding = Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'uniform-buffer' | 'read-only-storage-buffer';
+    minBindingSize?: number;
+    dynamicOffset?: boolean;
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'sampled-texture';
+    sampleType: ShaderTextureSampleType;
+    viewDimension?: ShaderTextureViewDimension;
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'sampler' | 'comparison-sampler';
+}>;
+/** Explicit binding ABI for one Direct WGSL compute shader. */
+type ComputeShaderBinding = Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'uniform-buffer' | 'read-only-storage-buffer';
+    minBindingSize?: number;
+    dynamicOffset?: boolean;
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'sampled-texture';
+    sampleType: ComputeTextureSampleType;
+    viewDimension?: ComputeTextureViewDimension;
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'sampler' | 'non-filtering-sampler' | 'comparison-sampler';
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'storage-buffer';
+    /** Graph access promise; both modes use a WGSL `read_write` storage declaration. */
+    access: ComputeStorageBufferAccess;
+    minBindingSize?: number;
+    dynamicOffset?: boolean;
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'storage-texture';
+    /**
+     * WGSL access mode. Declaring this binding also promises that the pass completely
+     * replaces the bound texture subresource before a later graph read.
+     */
+    access: 'write-only';
+    format: ComputeStorageTextureFormat;
+    viewDimension?: ComputeStorageTextureViewDimension;
+}>;
+/** Immutable source, entry point, workgroup size, and binding ABI for {@link ComputeShader}. */
+interface ComputeShaderDescriptor {
+    /** Optional diagnostic label. */
+    readonly label?: string;
+    /** Direct WGSL source containing exactly the declared compute entry point and resources. */
+    readonly source: string;
+    /** Compute entry-point name. Defaults to `main`. */
+    readonly entryPoint?: string;
+    /** One to three positive literal dimensions, which must match `@workgroup_size`. */
+    readonly workgroupSize: readonly [number, number?, number?];
+    /** Complete explicit resource ABI; entries are snapshotted and sorted by group/binding. */
+    readonly bindings: readonly ComputeShaderBinding[];
+}
+/** Normalized three-dimensional compute workgroup size. */
+type NormalizedComputeWorkgroupSize = readonly [number, number, number];
+/** Immutable, backend-neutral Direct WGSL compute shader configuration. */
+declare class ComputeShader {
+    /** Stable diagnostic label, or an empty string. */
+    readonly label: string;
+    /** Validated Direct WGSL source. */
+    readonly source: string;
+    /** Validated compute entry point. */
+    readonly entryPoint: string;
+    /** Normalized workgroup dimensions. */
+    readonly workgroupSize: NormalizedComputeWorkgroupSize;
+    /** Immutable bindings in group/binding order. */
+    readonly bindings: readonly ComputeShaderBinding[];
+    /** Snapshot a Direct WGSL compute shader contract without creating device objects. */
+    constructor(descriptor: Readonly<ComputeShaderDescriptor>);
+}
+
+/** Constrained GLSL ES 3.10 graphics source and readonly resource ABI. */
+interface StorageGraphicsShaderDescriptor {
+    /** Optional diagnostic label. */
+    readonly label?: string;
+    /** GLSL ES 3.10 vertex source; storage blocks must be `readonly` and `std430`. */
+    readonly vertexSource: string;
+    /** GLSL ES 3.10 fragment source; storage blocks must be `readonly` and `std430`. */
+    readonly fragmentSource: string;
+    /** Complete read-only resource ABI shared by the two graphics stages. */
+    readonly bindings: readonly ShaderReadBinding[];
+}
+/** Internal adapter for a preprocessed portable shader promoted into the storage-raster dialect. */
+interface PortableStorageGraphicsShaderDescriptor {
+    readonly label?: string;
+    /** Fully preprocessed GLSL ES 3.00 vertex source. */
+    readonly portableVertexSource: string;
+    /** Fully preprocessed GLSL ES 3.00 fragment source with constrained readonly storage blocks. */
+    readonly portableFragmentSource: string;
+    readonly bindings: readonly ShaderReadBinding[];
+}
+/**
+ * Immutable WebGPU-only graphics shader configuration for readonly storage-buffer rendering.
+ *
+ * Sources use the constrained GLSL ES 3.10 contract. Compilation still runs through the shared
+ * engine GLSL preprocessing and Naga translation path; this object never accepts hand-written
+ * graphics WGSL.
+ */
+declare class StorageGraphicsShader {
+    /** Stable diagnostic label, or an empty string. */
+    readonly label: string;
+    /** Immutable GLSL ES 3.10 vertex source. */
+    readonly vertexSource: string;
+    /** Immutable GLSL ES 3.10 fragment source. */
+    readonly fragmentSource: string;
+    /** Immutable bindings in group/binding order. */
+    readonly bindings: readonly ShaderReadBinding[];
+    /** Snapshot a WebGPU-only storage-aware graphics shader contract. */
+    constructor(descriptor: Readonly<StorageGraphicsShaderDescriptor>);
+}
+/**
+ * Promote fully preprocessed portable raster source at the single storage-graphics boundary.
+ * This keeps dynamic built-in material variants on the same GLSL/Naga path without admitting a
+ * second handwritten WGSL or raster-material tree.
+ *
+ * @internal
+ */
+declare function createStorageGraphicsShaderFromPortable(descriptor: Readonly<PortableStorageGraphicsShaderDescriptor>): StorageGraphicsShader;
+
 /** Optional renderer capabilities exposed only after their complete SRP/RHI path is available. */
 type RenderPipelineCapabilityName = 'storage-buffer' | 'storage-texture' | 'compute-pass' | 'indirect-draw';
 /** Portable texture roles available to creation-time requirement validation. */
@@ -6259,6 +6455,8 @@ interface RenderPipelineCreateContext {
      * recording while avoiding native backend access.
      */
     createStorageBuffer(descriptor: Readonly<StorageBufferDescriptor>): StorageBuffer;
+    /** Translate and validate storage-aware raster variants before the first application frame. */
+    warmupStorageGraphicsShaders(shaders: readonly StorageGraphicsShader[], batchSize?: number): Promise<void>;
 }
 /** Attachment operations selected for one physical output color attachment. */
 interface RenderPipelineOutputColorAttachment {
@@ -6348,6 +6546,58 @@ interface RenderPipelineShadowResources {
     readonly pointBiases: Float32Array;
     /** Six view-space-to-shadow-clip face matrices per shadowed point light. */
     readonly pointMatrices: Float32Array;
+    /** Physical atlas slices in dense render order. Values are valid only for this invocation. */
+    readonly slices: readonly Readonly<RenderPipelineShadowSlice>[];
+    /** Page-granular atlas updates recorded this frame, in render order. */
+    readonly pageRegions: readonly Readonly<RenderPipelineShadowPageRegion>[];
+}
+/** One frame-scoped physical page update within a shadow slice. */
+interface RenderPipelineShadowPageRegion {
+    /** Dense physical slice containing this page. */
+    readonly slicePhysicalIndex: number;
+    /** Zero-based horizontal virtual-page coordinate within the slice. */
+    readonly pageX: number;
+    /** Zero-based vertical virtual-page coordinate within the slice. */
+    readonly pageY: number;
+    /** Physical atlas X origin in pixels. */
+    readonly x: number;
+    /** Physical atlas Y origin in pixels. */
+    readonly y: number;
+    /** Physical page width in pixels; edge pages may be smaller than the page size. */
+    readonly width: number;
+    /** Physical page height in pixels; edge pages may be smaller than the page size. */
+    readonly height: number;
+}
+/** One frame-scoped shadow-atlas slice exposed for GPU-driven caster work. */
+interface RenderPipelineShadowSlice {
+    /** Light projection represented by the slice. */
+    readonly kind: 'directional' | 'spot' | 'point';
+    /** Stable LightBlock ABI index. */
+    readonly sliceIndex: number;
+    /** Dense physical placement index within the atlas. */
+    readonly physicalIndex: number;
+    /** Point-light cube face, or null for planar shadows. */
+    readonly face: number | null;
+    /** Directional cascade index, or null for local lights. */
+    readonly cascade: number | null;
+    /** Atlas viewport as `[x, y, width, height]`. */
+    readonly viewport: RendererViewport;
+    /** World-space to shadow clip-space transform. */
+    readonly viewProjectionMatrix: Float32Array;
+    /** Shadow-camera near plane. */
+    readonly near: number;
+    /** Shadow-camera far plane. */
+    readonly far: number;
+    /** Whether the submission-aware cache scheduled this slice for update. */
+    readonly dirty: boolean;
+}
+/** Optional hybrid-shadow selection used by GPU-managed pipelines. */
+interface RenderPipelineShadowOptions {
+    /**
+     * Mesh identities omitted from CPU shadow draws while remaining part of cache invalidation.
+     * The caller must record equivalent atlas writes for every exposed `pageRegions` entry.
+     */
+    readonly excludeMeshes?: readonly Mesh[];
 }
 /** Frame-scoped recording context; retaining it after record() returns is an error. */
 interface RenderPipelineContext {
@@ -6365,6 +6615,8 @@ interface RenderPipelineContext {
     readonly output: RenderPipelineOutput;
     /** Effective capabilities for the current device generation. */
     readonly capabilities: RenderPipelineCapabilities;
+    /** Whether scene depth uses the renderer's logarithmic depth encoding. */
+    readonly useLogDepth: boolean;
     /** Backend-neutral graph facade for this invocation. */
     readonly graph: ScriptableRenderGraph;
     /** Update scene world matrices and the active camera without building a CPU render list. */
@@ -6378,7 +6630,7 @@ interface RenderPipelineContext {
      * Returns the exact graph texture and packed sampling data, or `null` when no shadow slice is
      * active. The returned arrays are frame-scoped and must not be retained after `record()`.
      */
-    recordShadows(cullingResults: CullingResultsHandle): Readonly<RenderPipelineShadowResources> | null;
+    recordShadows(cullingResults: CullingResultsHandle, options?: Readonly<RenderPipelineShadowOptions>): Readonly<RenderPipelineShadowResources> | null;
     /** Acquire one runtime-owned, high-water reusable parameter slot. */
     acquirePassParameters<P extends object>(pool: RenderPassParameterPool<P>): P;
     /**
@@ -6427,6 +6679,8 @@ type RendererAdapterPowerPreference = 'low-power' | 'high-performance';
 type RendererContextPowerPreference = 'default' | RendererAdapterPowerPreference;
 /** Shared renderer policy bundle. `high-end` enables reversed-Z cameras and camera-relative GPU transforms. */
 type RendererRenderingProfile = 'portable' | 'high-end';
+/** Shadow-atlas update policy. `full` disables page-budget deferral within a renderer frame. */
+type RendererShadowUpdateMode = 'paged' | 'full';
 /** Optional device capabilities that the renderer can request through the portable RHI. */
 type RendererFeatureName = 'texture-compression-bc' | 'texture-compression-etc2' | 'texture-compression-astc' | 'timestamp-query' | 'shader-f16' | 'subgroups' | 'depth32float-stencil8' | 'float32-filterable' | 'float32-blendable';
 /** Backend-independent construction options. */
@@ -6450,6 +6704,8 @@ interface RendererCommonOptions {
     cameraRelative?: boolean;
     /** Renderer policy bundle. Defaults to `portable`. */
     renderingProfile?: RendererRenderingProfile;
+    /** Shadow-atlas update policy. Defaults to `paged`; use `full` for fully dynamic scenes. */
+    shadowUpdateMode?: RendererShadowUpdateMode;
     vertexPrecision?: ShaderPrecision;
     fragmentPrecision?: ShaderPrecision;
     fog?: Fog | null;
@@ -6513,6 +6769,8 @@ declare class Renderer<Backend extends RendererBackend = RendererBackend> implem
     readonly renderTarget: RendererContract['renderTarget'];
     readonly cameraRelative: RendererContract['cameraRelative'];
     readonly renderingProfile: RendererContract['renderingProfile'];
+    /** Shadow-atlas page-budget policy selected at creation. */
+    readonly shadowUpdateMode: RendererContract['shadowUpdateMode'];
     width: RendererContract['width'];
     height: RendererContract['height'];
     pixelRatio: RendererContract['pixelRatio'];
@@ -8212,56 +8470,6 @@ declare namespace util_d {
   export type { util_d_GeometryDataLike as GeometryDataLike, util_d_MutableArrayLike as MutableArrayLike, util_d_TypedArray as TypedArray, util_d_TypedArrayConstructor as TypedArrayConstructor };
 }
 
-interface SkinnedMeshParameters extends MeshParameters {
-    skeleton?: Skeleton | null;
-}
-/**
- * 蒙皮Mesh
- */
-declare class SkinnedMesh extends Mesh {
-    static readonly typeName: string;
-    private jointMat;
-    private clonedFrom;
-    isSkinnedMesh: boolean;
-    className: string;
-    /**
-     * 是否支持 Instanced
-     */
-    useInstanced: boolean;
-    /**
-     * 是否开启视锥体裁剪
-     */
-    frustumTest: boolean;
-    /**
-     * 骨架
-     */
-    skeleton: Skeleton | null;
-    /**
-     * @param params - 初始化参数，所有params都会复制到实例上
-     * - `params.geometry`: 几何体
-     * - `params.material`: 材质
-     * - `params.skeleton`: 骨骼
-     */
-    constructor(params?: SkinnedMeshParameters);
-    /**
-     * 获取每个骨骼对应的矩阵数组
-     * @returns 返回矩阵数组
-     */
-    getJointMat(): Float32Array;
-    /**
-     * 用新骨骼的 node name 重设 jointNames
-     * @param skeleton - 新骨架
-     */
-    resetJointNamesByNodeName(skeleton: Skeleton): void;
-    /**
-     * 用新骨骼重置skinIndices
-     * @param skeleton -
-     */
-    resetSkinIndices(skeleton: Skeleton): void;
-    clone(isChild?: boolean): SkinnedMesh;
-    getRenderOption(opt?: ShaderOptions): ShaderOptions;
-}
-
 type DOMViewport = ReturnType<typeof getElementRect>;
 interface StageCommonParameters extends NodeParameters {
     container?: HTMLElement;
@@ -8281,6 +8489,8 @@ interface StageCommonParameters extends NodeParameters {
     useLogDepth?: boolean;
     /** Renderer policy bundle. `high-end` enables reversed-Z and camera-relative transforms. */
     renderingProfile?: RendererRenderingProfile;
+    /** Shadow-atlas update policy. Use `full` for scenes whose shadow casters move every frame. */
+    shadowUpdateMode?: RendererShadowUpdateMode;
     alpha?: boolean;
     depth?: boolean;
     stencil?: boolean;
@@ -8290,6 +8500,8 @@ interface StageCommonParameters extends NodeParameters {
     gameMode?: boolean;
     /** Renderer-local scriptable pipeline factory snapshotted during Stage.create(). */
     renderPipeline?: RenderPipelineFactory;
+    /** Optional Stage Systems initialized transactionally before `Stage.create()` resolves. */
+    systems?: readonly StageSystem[];
 }
 /** Requested backend policy. `auto` probes WebGPU first and otherwise selects WebGL 2. */
 type StageBackend = RendererBackend | 'auto';
@@ -8347,6 +8559,8 @@ declare class Stage<Backend extends RendererBackend = RendererBackend> extends N
      * 渲染器
      */
     renderer: Renderer<Backend>;
+    /** Per-Stage scheduler and service registry for optional addon Systems. */
+    readonly systems: StageSystemRegistry;
     /** Resolves when the selected graphics backend is ready for rendering. */
     readonly ready: Promise<void>;
     /** Ordered cameras rendered by `tick()`. */
@@ -8449,7 +8663,11 @@ declare class Stage<Backend extends RendererBackend = RendererBackend> extends N
      * @returns 舞台本身。链式调用支持。
      */
     tick(dt: number): this;
-    private prepareParticleRendererResources;
+    /** Install one optional addon after this Stage is ready. */
+    installSystem(system: StageSystem): Promise<this>;
+    /** Remove one leaf addon System. Hard dependants must be removed first. */
+    uninstallSystem(id: string): this;
+    private prepareAddonRendererResources;
     /**
      * Replace the ordered camera composition.
      * @param cameras - Unique Camera instances in back-to-front render order.
@@ -8502,46 +8720,211 @@ declare class Stage<Backend extends RendererBackend = RendererBackend> extends N
     destroy(): this;
 }
 
-type TweenEaseFunction = (ratio: number) => number;
-type TweenProperties = Readonly<Record<string, number>>;
-interface TweenParameters {
-    duration?: number;
-    delay?: number | string;
-    paused?: boolean;
-    loop?: boolean;
-    reverse?: boolean;
-    repeat?: number;
-    repeatDelay?: number;
-    ease?: TweenEaseFunction | null;
-    time?: number;
-    stagger?: number;
-    onStart?: TweenStartCallback | null;
-    onUpdate?: TweenUpdateCallback | null;
-    onComplete?: TweenCompleteCallback | null;
-}
-type TweenStartCallback = (this: Tween, tween: Tween) => void;
-type TweenUpdateCallback = (this: Tween, ratio: number, tween: Tween) => void;
-type TweenCompleteCallback = (this: Tween, tween: Tween) => void;
-interface TweenEaseObject {
-    EaseIn: TweenEaseFunction;
-    EaseOut: TweenEaseFunction;
-    EaseInOut: TweenEaseFunction;
-}
-interface TweenEaseNoneObject {
-    EaseNone: TweenEaseFunction;
+/** Stage System ABI implemented by this Hilo3D release. */
+declare const STAGE_SYSTEM_API_VERSION: 1;
+/** Typed identity used by systems to publish services without string-key collisions. */
+declare class StageSystemService<T> {
+    /** Human-readable token name used in diagnostics. */
+    readonly name: string;
+    private readonly serviceType;
+    constructor(name: string);
+}
+/** Create a typed service identity shared by a provider and its consumers. */
+declare function createStageSystemService<T>(name: string): StageSystemService<T>;
+/** Immutable metadata compiled before System setup begins. */
+interface StageSystemDescriptor {
+    /** Stable, package-qualified System identity. */
+    readonly id: string;
+    /** System implementation version for diagnostics. */
+    readonly version: string;
+    /** Exact Hilo3D Stage System ABI expected by this System. */
+    readonly apiVersion: typeof STAGE_SYSTEM_API_VERSION;
+    /** System identities that must be present, initialized first, and destroyed last. */
+    readonly requires?: readonly string[];
+    /** Optional System identities that this System runs before when they are present. */
+    readonly before?: readonly string[];
+    /** Optional System identities that this System runs after when they are present. */
+    readonly after?: readonly string[];
+    /** Complete set of typed services published during setup. */
+    readonly provides?: readonly StageSystemService<unknown>[];
+}
+/** Context available only while a System factory is being initialized. */
+interface StageSystemSetupContext {
+    /** Stage that owns this System runtime. */
+    readonly stage: Stage;
+    /** Publish one descriptor-declared service. */
+    provide<T>(service: StageSystemService<T>, value: T): void;
+    /** Read a required service published by an initialized dependency. */
+    get<T>(service: StageSystemService<T>): T;
+    /** Read an optional service published by an initialized dependency. */
+    getOptional<T>(service: StageSystemService<T>): T | undefined;
+}
+/** Synchronous phase hooks owned by one initialized Stage System. */
+interface StageSystemRuntime {
+    /** Run before scene-node updates for a frame. */
+    beforeUpdate?(deltaTimeMilliseconds: number): void;
+    /** Run after scene-node updates for a frame. */
+    afterUpdate?(deltaTimeMilliseconds: number): void;
+    /** Run immediately before rendering a frame. */
+    beforeRender?(): void;
+    /** Run after each render attempt, including a failed render. */
+    afterRender?(): void;
+    /** Release resources owned by this runtime. */
+    destroy?(): void;
+}
+/** Reusable factory. Each Stage receives a distinct runtime from `setup()`. */
+interface StageSystem {
+    /** Versioned identity, ordering, dependency, and service metadata. */
+    readonly descriptor: StageSystemDescriptor;
+    /** Create a fresh runtime for one Stage. */
+    setup(context: StageSystemSetupContext): StageSystemRuntime | Promise<StageSystemRuntime>;
 }
-interface ElasticEaseObject extends TweenEaseObject {
-    a: number;
-    p: number;
-    s: number;
-    config(amplitude: number, period: number): void;
+/**
+ * Per-Stage System scheduler and service registry. Ordering is compiled only when the installed set
+ * changes; frame dispatch walks flat phase-specific callback arrays.
+ */
+declare class StageSystemRegistry {
+    /** Stage that owns this System registry. */
+    readonly stage: Stage;
+    private readonly installed;
+    private readonly installationOrder;
+    private readonly services;
+    private executionOrder;
+    private beforeUpdateHooks;
+    private afterUpdateHooks;
+    private beforeRenderHooks;
+    private afterRenderHooks;
+    private dispatching;
+    private initializing;
+    private settingUp;
+    private destroyingRuntime;
+    private initialized;
+    private destroyed;
+    constructor(stage: Stage);
+    /** Initialize an entire System set transactionally. Intended for `Stage.create()`. */
+    initialize(systems: readonly StageSystem[]): Promise<void>;
+    /** Install one System and recompile the frame schedule. */
+    install(system: StageSystem): Promise<void>;
+    /** Remove one leaf System. Hard dependants must be removed first. */
+    uninstall(id: string): void;
+    /** Return whether a System identity is currently installed. */
+    has(id: string): boolean;
+    /** Read an installed System runtime for diagnostics or explicit extension APIs. */
+    getRuntime(id: string): StageSystemRuntime | undefined;
+    /** Read a required typed service published by an installed System. */
+    get<T>(service: StageSystemService<T>): T;
+    /** Read a typed service when its provider is optional. */
+    getOptional<T>(service: StageSystemService<T>): T | undefined;
+    /** Dispatch the pre-update phase in compiled order. */
+    runBeforeUpdate(deltaTimeMilliseconds: number): void;
+    /** Dispatch the post-update phase in compiled order. */
+    runAfterUpdate(deltaTimeMilliseconds: number): void;
+    /** Dispatch the pre-render phase in compiled order. */
+    runBeforeRender(): void;
+    /** Dispatch the post-render phase in compiled order. */
+    runAfterRender(): void;
+    /** Destroy every runtime and its services in reverse compiled order. */
+    destroy(): void;
+    private installResolved;
+    private destroyInstalled;
+    private rebuildSchedule;
+    private clearSchedule;
+    private dispatchDelta;
+    private dispatch;
+    private beginDispatch;
+    private requireMutable;
 }
-interface BackEaseObject extends TweenEaseObject {
-    o: number;
-    s: number;
-    config(overshoot: number): void;
+
+interface SkinnedMeshParameters extends MeshParameters {
+    skeleton?: Skeleton | null;
 }
-interface TweenEaseCollection {
+/**
+ * 蒙皮Mesh
+ */
+declare class SkinnedMesh extends Mesh {
+    static readonly typeName: string;
+    private jointMat;
+    private clonedFrom;
+    isSkinnedMesh: boolean;
+    className: string;
+    /**
+     * 是否支持 Instanced
+     */
+    useInstanced: boolean;
+    /**
+     * 是否开启视锥体裁剪
+     */
+    frustumTest: boolean;
+    /**
+     * 骨架
+     */
+    skeleton: Skeleton | null;
+    /**
+     * @param params - 初始化参数，所有params都会复制到实例上
+     * - `params.geometry`: 几何体
+     * - `params.material`: 材质
+     * - `params.skeleton`: 骨骼
+     */
+    constructor(params?: SkinnedMeshParameters);
+    /**
+     * 获取每个骨骼对应的矩阵数组
+     * @returns 返回矩阵数组
+     */
+    getJointMat(): Float32Array;
+    /**
+     * 用新骨骼的 node name 重设 jointNames
+     * @param skeleton - 新骨架
+     */
+    resetJointNamesByNodeName(skeleton: Skeleton): void;
+    /**
+     * 用新骨骼重置skinIndices
+     * @param skeleton -
+     */
+    resetSkinIndices(skeleton: Skeleton): void;
+    clone(isChild?: boolean): SkinnedMesh;
+    getRenderOption(opt?: ShaderOptions): ShaderOptions;
+}
+
+type TweenEaseFunction = (ratio: number) => number;
+type TweenProperties = Readonly<Record<string, number>>;
+interface TweenParameters {
+    duration?: number;
+    delay?: number | string;
+    paused?: boolean;
+    loop?: boolean;
+    reverse?: boolean;
+    repeat?: number;
+    repeatDelay?: number;
+    ease?: TweenEaseFunction | null;
+    time?: number;
+    stagger?: number;
+    onStart?: TweenStartCallback | null;
+    onUpdate?: TweenUpdateCallback | null;
+    onComplete?: TweenCompleteCallback | null;
+}
+type TweenStartCallback = (this: Tween, tween: Tween) => void;
+type TweenUpdateCallback = (this: Tween, ratio: number, tween: Tween) => void;
+type TweenCompleteCallback = (this: Tween, tween: Tween) => void;
+interface TweenEaseObject {
+    EaseIn: TweenEaseFunction;
+    EaseOut: TweenEaseFunction;
+    EaseInOut: TweenEaseFunction;
+}
+interface TweenEaseNoneObject {
+    EaseNone: TweenEaseFunction;
+}
+interface ElasticEaseObject extends TweenEaseObject {
+    a: number;
+    p: number;
+    s: number;
+    config(amplitude: number, period: number): void;
+}
+interface BackEaseObject extends TweenEaseObject {
+    o: number;
+    s: number;
+    config(overshoot: number): void;
+}
+interface TweenEaseCollection {
     Linear: TweenEaseNoneObject;
     Quad: TweenEaseObject;
     Cubic: TweenEaseObject;
@@ -8875,1231 +9258,6 @@ declare class OrbitControls {
     private readGesture;
 }
 
-/** Addressing behavior outside the normalized curve domain. */
-type ParticleCurveWrapMode = 'clamp' | 'loop' | 'ping-pong';
-/** Interpolation applied between authored curve keyframes. */
-type ParticleCurveInterpolation = 'linear' | 'smooth';
-/** One scalar key in normalized authoring time. */
-interface ParticleCurveKeyframe {
-    readonly time: number;
-    readonly value: number;
-}
-/** Immutable curve construction options. */
-interface ParticleCurveOptions {
-    readonly wrap?: ParticleCurveWrapMode;
-    readonly interpolation?: ParticleCurveInterpolation;
-}
-/** Immutable scalar curve baked to identical float32 LUT bytes for CPU and GPU plans. */
-declare class ParticleCurve {
-    readonly keys: readonly Readonly<ParticleCurveKeyframe>[];
-    readonly wrap: ParticleCurveWrapMode;
-    readonly interpolation: ParticleCurveInterpolation;
-    constructor(keys: readonly ParticleCurveKeyframe[], options?: ParticleCurveOptions);
-    /** Sample the authoring curve with explicitly defined wrap and interpolation semantics. */
-    sample(time: number): number;
-    /** Bake a fixed-size float32 lookup table. */
-    bake(sampleCount?: number): Float32Array;
-}
-
-/** One linear-RGBA gradient key in normalized authoring time. */
-interface ParticleGradientKey {
-    readonly time: number;
-    readonly color: ParticleColor;
-}
-/** Immutable linear-RGBA gradient with a fixed CPU/GPU LUT representation. */
-declare class ParticleGradient {
-    readonly keys: readonly Readonly<ParticleGradientKey>[];
-    constructor(keys: readonly ParticleGradientKey[]);
-    /** Sample into a caller-provided array to avoid hot-path allocation. */
-    sample(time: number, target: Float32Array, offset?: number): void;
-    /** Bake tightly packed linear RGBA float32 texels. */
-    bake(sampleCount?: number): Float32Array;
-}
-
-/** Closed value-kind set accepted by typed particle parameters. */
-type ParticleParameterType = 'float' | 'uint' | 'boolean' | 'vector2' | 'vector3' | 'vector4' | 'color' | 'texture' | 'curve' | 'gradient';
-/** Runtime values accepted by a typed particle parameter. */
-type ParticleParameterValue = number | boolean | ParticleVector2 | ParticleVector3 | ParticleVector4 | Texture<unknown> | ParticleCurve | ParticleGradient;
-/** Typed identity token for runtime parameter updates that do not change plan topology. */
-declare class ParticleParameter<T extends ParticleParameterValue = ParticleParameterValue> {
-    readonly name: string;
-    readonly type: ParticleParameterType;
-    readonly defaultValue: T;
-    constructor(name: string, type: ParticleParameterType, defaultValue: T);
-}
-/** Runtime typed parameter values with a monotonic revision. */
-declare class ParticleParameterSet {
-    #private;
-    get revision(): number;
-    get<T extends ParticleParameterValue>(parameter: ParticleParameter<T>): T;
-    set<T extends ParticleParameterValue>(parameter: ParticleParameter<T>, value: T): this;
-    reset(parameter?: ParticleParameter): this;
-}
-
-/** Current serialized particle-definition schema version. */
-declare const PARTICLE_DEFINITION_VERSION: 1;
-/** Two-component serializable particle value. */
-type ParticleVector2 = readonly [number, number];
-/** Three-component serializable particle value. */
-type ParticleVector3 = readonly [number, number, number];
-/** Four-component serializable particle value. */
-type ParticleVector4 = readonly [number, number, number, number];
-/** Linear RGBA particle color. */
-type ParticleColor = ParticleVector4;
-/** Constant or deterministic random range evaluated from a particle counter key. */
-type ParticleRange<T> = Readonly<{
-    min: T;
-    max: T;
-}>;
-/** Scalar authoring value accepted by fixed particle modules. */
-type ParticleScalarValue = number | ParticleRange<number>;
-/** Vector authoring value accepted by fixed particle modules. */
-type ParticleVector3Value = ParticleVector3 | ParticleRange<ParticleVector3>;
-/** Color authoring value accepted by fixed particle modules. */
-type ParticleColorValue = ParticleColor | ParticleRange<ParticleColor>;
-/** Runtime-bindable scalar source used only where plan topology remains unchanged. */
-type ParticleScalarSource = ParticleScalarValue | ParticleParameter<number>;
-/** Runtime-bindable vector source used only by spawn-time data evaluated on the CPU. */
-type ParticleVector3Source = ParticleVector3Value | ParticleParameter<ParticleVector3>;
-/** Runtime-bindable color source used only by spawn-time data evaluated on the CPU. */
-type ParticleColorSource = ParticleColorValue | ParticleParameter<ParticleColor>;
-/** Requested emitter execution policy. `auto` remains portable and capability driven. */
-type ParticleExecutionMode = 'auto' | 'cpu' | 'gpu' | 'stateless';
-/** Simulation coordinate system. */
-type ParticleSimulationSpace = 'local' | 'world';
-/** Reaction used when an emitter is culled by a renderer. */
-type ParticleCullingReaction = 'render-only' | 'pause' | 'pause-and-catch-up' | 'stop';
-/** Capacity overflow behavior. */
-type ParticleOverflowPolicy = 'drop-new' | 'replace-oldest';
-/** Overflow behavior for bounded particle event and data-channel buffers. */
-type ParticleEventOverflowPolicy = 'drop-new' | 'drop-oldest';
-/** Manual local-space bounds. */
-interface ParticleManualBounds {
-    readonly mode: 'manual';
-    readonly min: ParticleVector3;
-    readonly max: ParticleVector3;
-}
-/** Compiler-derived conservative bounds. */
-interface ParticleAutomaticBounds {
-    readonly mode: 'automatic';
-}
-/** Exact CPU bounds recomputed from the dense alive range. */
-interface ParticleDynamicBounds {
-    readonly mode: 'dynamic';
-}
-/** Public emitter bounds policy. */
-type ParticleBoundsDefinition = ParticleManualBounds | ParticleAutomaticBounds | ParticleDynamicBounds;
-/** One deterministic time-based burst. */
-interface ParticleBurstDefinition {
-    readonly time: number;
-    readonly count: number;
-    readonly cycles?: number;
-    readonly interval?: number;
-}
-/** Fixed emission sources evaluated before initialize modules. */
-interface ParticleEmissionDefinition {
-    readonly rateOverTime?: ParticleScalarSource;
-    readonly rateOverDistance?: ParticleScalarSource;
-    readonly bursts?: readonly ParticleBurstDefinition[];
-}
-/** Common distribution controls shared by analytic particle shapes. */
-interface ParticleShapeBase {
-    readonly distribution?: 'surface' | 'volume';
-    readonly arc?: number;
-    readonly thickness?: number;
-}
-/** Point emitter shape. */
-interface ParticlePointShape extends ParticleShapeBase {
-    readonly type: 'point';
-}
-/** Line-segment or edge emitter shape. */
-interface ParticleLineShape extends ParticleShapeBase {
-    readonly type: 'line' | 'edge';
-    readonly start: ParticleVector3;
-    readonly end: ParticleVector3;
-}
-/** Axis-aligned box emitter shape. */
-interface ParticleBoxShape extends ParticleShapeBase {
-    readonly type: 'box';
-    readonly size: ParticleVector3;
-}
-/** Circle or filled-disc emitter shape. */
-interface ParticleCircleShape extends ParticleShapeBase {
-    readonly type: 'circle' | 'disc';
-    readonly radius: number;
-}
-/** Sphere or hemisphere emitter shape. */
-interface ParticleSphereShape extends ParticleShapeBase {
-    readonly type: 'sphere' | 'hemisphere';
-    readonly radius: number;
-}
-/** Cone emitter shape with a degree-based half-angle. */
-interface ParticleConeShape extends ParticleShapeBase {
-    readonly type: 'cone';
-    readonly radius: number;
-    /** Cone half-angle in degrees. */
-    readonly angle: number;
-    readonly length?: number;
-}
-/** Torus or donut emitter shape. */
-interface ParticleTorusShape extends ParticleShapeBase {
-    readonly type: 'torus' | 'donut';
-    readonly radius: number;
-    readonly tubeRadius: number;
-}
-/** Analytic shape sampled without allocating per-particle objects. */
-type ParticleShapeDefinition = ParticlePointShape | ParticleLineShape | ParticleBoxShape | ParticleCircleShape | ParticleSphereShape | ParticleConeShape | ParticleTorusShape;
-/** Initial attributes evaluated once for every spawn. */
-interface ParticleInitializeDefinition {
-    readonly lifetime?: ParticleScalarSource;
-    readonly position?: ParticleVector3Source;
-    readonly direction?: ParticleVector3Source;
-    readonly speed?: ParticleScalarSource;
-    readonly color?: ParticleColorSource;
-    readonly size?: ParticleScalarSource;
-    /** Rotation in radians. */
-    readonly rotation?: ParticleScalarSource;
-    readonly mass?: ParticleScalarSource;
-    /** Integer mesh bucket selected at spawn. Omit to distribute by stable particle id. */
-    readonly meshIndex?: ParticleScalarSource;
-    /** Integer ribbon group selected at spawn. Particles only link inside the same group. */
-    readonly ribbonId?: ParticleScalarSource;
-}
-/** Constant velocity added before integration. */
-interface ParticleVelocityModule {
-    readonly type: 'velocity-over-lifetime';
-    readonly velocity: ParticleVector3Value;
-    readonly space?: ParticleSimulationSpace;
-}
-/** Acceleration or force applied every fixed step. */
-interface ParticleForceModule {
-    readonly type: 'force-over-lifetime' | 'gravity' | 'wind';
-    readonly force: ParticleVector3Value;
-    readonly space?: ParticleSimulationSpace;
-}
-/** Exponential velocity damping. */
-interface ParticleDragModule {
-    readonly type: 'drag';
-    readonly coefficient: number;
-}
-/** Clamp particle speed and optionally damp the removed component. */
-interface ParticleLimitVelocityModule {
-    readonly type: 'limit-velocity';
-    readonly limit: ParticleScalarValue;
-    readonly dampen?: number;
-}
-/** Add the emitter velocity observed at spawn. */
-interface ParticleInheritVelocityModule {
-    readonly type: 'inherit-emitter-velocity';
-    readonly multiplier?: number;
-}
-/** Deterministic lattice noise shared by CPU and generated WebGPU kernels. */
-interface ParticleNoiseModule {
-    readonly type: 'noise';
-    readonly mode: 'position-offset' | 'force';
-    readonly field: 'vector' | 'curl';
-    readonly strength: ParticleVector3Value;
-    readonly frequency: number;
-    readonly octaves: 1 | 2 | 3 | 4;
-    readonly lacunarity?: number;
-    readonly persistence?: number;
-    readonly scrollVelocity?: ParticleVector3;
-    readonly damping?: number;
-    readonly space?: ParticleSimulationSpace;
-    readonly seedOffset?: number;
-}
-/** Scalar curve applied over normalized lifetime. */
-interface ParticleScalarOverLifetimeModule {
-    readonly type: 'alpha-over-lifetime' | 'size-over-lifetime' | 'rotation-over-lifetime' | 'frame-over-lifetime';
-    readonly curve: ParticleCurve;
-    readonly cycles?: number;
-}
-/** Gradient applied over normalized lifetime. */
-interface ParticleColorOverLifetimeModule {
-    readonly type: 'color-over-lifetime';
-    readonly gradient: ParticleGradient;
-}
-/** Scalar speed-driven attribute modifier. */
-interface ParticleScalarBySpeedModule {
-    readonly type: 'size-by-speed' | 'rotation-by-speed';
-    readonly speedRange: readonly [number, number];
-    readonly curve: ParticleCurve;
-}
-/** Gradient speed-driven color modifier. */
-interface ParticleColorBySpeedModule {
-    readonly type: 'color-by-speed';
-    readonly speedRange: readonly [number, number];
-    readonly gradient: ParticleGradient;
-}
-/** First portable speed-driven attribute modifiers. */
-type ParticleBySpeedModule = ParticleScalarBySpeedModule | ParticleColorBySpeedModule;
-/** Texture-sheet frame selection. */
-interface ParticleTextureSheetModule {
-    readonly type: 'texture-sheet';
-    readonly mode: 'lifetime' | 'speed' | 'fps';
-    readonly rows: number;
-    readonly columns: number;
-    readonly cycles?: number;
-    readonly fps?: number;
-    readonly speedRange?: readonly [number, number];
-}
-/** Advanced P2 force families. */
-interface ParticleRadialForceModule {
-    readonly type: 'radial-force' | 'orbital-force' | 'vortex-force';
-    readonly center?: ParticleVector3;
-    readonly strength: ParticleScalarValue;
-    readonly axis?: ParticleVector3;
-}
-/** Point or closest-point-on-line attraction force. */
-interface ParticleAttractionModule {
-    readonly type: 'point-attraction' | 'line-attraction';
-    readonly point?: ParticleVector3;
-    readonly lineStart?: ParticleVector3;
-    readonly lineEnd?: ParticleVector3;
-    readonly strength: ParticleScalarValue;
-}
-/** Tangential motion around an authored point and axis. */
-interface ParticleRotateAroundPointModule {
-    readonly type: 'rotate-around-point';
-    readonly center?: ParticleVector3;
-    readonly axis?: ParticleVector3;
-    readonly angularSpeed: ParticleScalarValue;
-}
-/** Force particles toward an analytic sphere surface. */
-interface ParticleConformSphereModule {
-    readonly type: 'conform-sphere';
-    readonly center?: ParticleVector3;
-    readonly radius: number;
-    readonly strength: number;
-}
-/** Remap initial lifetime from the emitter's spawn-time speed. */
-interface ParticleLifetimeByEmitterSpeedModule {
-    readonly type: 'lifetime-by-emitter-speed';
-    readonly speedRange: readonly [number, number];
-    readonly lifetimeRange: readonly [number, number];
-}
-/** Kill particles outside an allowed speed or distance range. */
-interface ParticleKillModule {
-    readonly type: 'kill-speed' | 'kill-distance';
-    readonly range: readonly [number, number];
-}
-/** Kill particles inside or outside an analytic volume. */
-interface ParticleKillVolumeModule {
-    readonly type: 'kill-plane' | 'kill-box' | 'kill-sphere';
-    readonly center?: ParticleVector3;
-    readonly size?: ParticleVector3;
-    readonly radius?: number;
-    readonly normal?: ParticleVector3;
-    readonly offset?: number;
-    readonly mode?: 'inside' | 'outside';
-}
-/** Per-view camera offset, fade, or screen-space size modifier. */
-interface ParticleCameraModule {
-    readonly type: 'camera-offset' | 'camera-fade' | 'screen-space-size';
-    readonly range?: readonly [number, number];
-    readonly scale?: number;
-}
-/** Typed fixed value allocated as a custom particle attribute. */
-interface ParticleCustomChannelModule {
-    readonly type: 'custom-channel';
-    readonly name: string;
-    readonly valueType: 'float' | 'vec2' | 'vec3' | 'vec4' | 'color';
-    readonly value: number | ParticleVector2 | ParticleVector3 | ParticleVector4;
-}
-/** Texture-driven vector field force. */
-interface ParticleVectorFieldModule {
-    readonly type: 'vector-field';
-    readonly texture: Texture<unknown>;
-    readonly strength: number;
-}
-/** Infinite plane used by analytic particle collision and trigger modules. */
-interface ParticlePlaneCollider {
-    readonly type: 'plane';
-    readonly normal: ParticleVector3;
-    readonly offset?: number;
-}
-/** Solid sphere used by analytic particle collision and trigger modules. */
-interface ParticleSphereCollider {
-    readonly type: 'sphere';
-    readonly center?: ParticleVector3;
-    readonly radius: number;
-}
-/** Axis-aligned solid box used by analytic particle collision and trigger modules. */
-interface ParticleBoxCollider {
-    readonly type: 'box';
-    readonly center?: ParticleVector3;
-    readonly size: ParticleVector3;
-}
-/** Line-swept solid sphere used by analytic particle collision and trigger modules. */
-interface ParticleCapsuleCollider {
-    readonly type: 'capsule';
-    readonly start: ParticleVector3;
-    readonly end: ParticleVector3;
-    readonly radius: number;
-}
-/** Backend-neutral analytic collision primitive. */
-type ParticleAnalyticCollider = ParticlePlaneCollider | ParticleSphereCollider | ParticleBoxCollider | ParticleCapsuleCollider;
-/** Resolve particles against a fixed list of analytic primitives. */
-interface ParticleCollisionModule {
-    readonly type: 'collision';
-    readonly colliders: readonly ParticleAnalyticCollider[];
-    readonly bounce?: number;
-    readonly friction?: number;
-    readonly radiusScale?: number;
-    readonly lifetimeLoss?: number;
-    readonly event?: string;
-}
-/** Emit batched inside/enter/exit events for analytic trigger volumes. */
-interface ParticleTriggerModule {
-    readonly type: 'trigger';
-    readonly volumes: readonly ParticleAnalyticCollider[];
-    readonly events?: Readonly<{
-        inside?: string;
-        enter?: string;
-        exit?: string;
-    }>;
-}
-/** WebGPU-only collision against the sampled opaque scene depth. */
-interface ParticleSceneDepthCollisionModule {
-    readonly type: 'scene-depth-collision';
-    readonly thickness?: number;
-    readonly bounce?: number;
-    readonly friction?: number;
-    readonly event?: string;
-}
-/** Route a batched source event into another emitter without a CPU per-event callback. */
-interface ParticleSubEmitterModule {
-    readonly type: 'sub-emitter';
-    readonly event: string;
-    readonly emitter: string;
-    readonly count?: number;
-    readonly inheritVelocity?: boolean;
-}
-/** Closed fixed-module union. Arbitrary code and per-particle callbacks are intentionally absent. */
-type ParticleModule = ParticleVelocityModule | ParticleForceModule | ParticleDragModule | ParticleLimitVelocityModule | ParticleInheritVelocityModule | ParticleNoiseModule | ParticleScalarOverLifetimeModule | ParticleColorOverLifetimeModule | ParticleBySpeedModule | ParticleTextureSheetModule | ParticleRadialForceModule | ParticleAttractionModule | ParticleRotateAroundPointModule | ParticleConformSphereModule | ParticleLifetimeByEmitterSpeedModule | ParticleKillModule | ParticleKillVolumeModule | ParticleCameraModule | ParticleCustomChannelModule | ParticleVectorFieldModule | ParticleCollisionModule | ParticleTriggerModule | ParticleSceneDepthCollisionModule | ParticleSubEmitterModule;
-/** Sprite-facing mode evaluated per camera by the portable particle shader. */
-type ParticleSpriteAlignment = 'view' | 'world-up' | 'stretched' | 'velocity';
-/** Particle-level sort mode. */
-type ParticleSortMode = 'none' | 'distance' | 'youngest' | 'oldest';
-/** Surface coverage used to place particle output in the shared render queues. */
-type ParticleSurfaceCoverage = 'opaque' | 'masked' | 'transparent';
-/** Deliberately small scene-light subset supported by mesh and ribbon particles. */
-type ParticleLightingMode = 'unlit' | 'lambert';
-/** Particle composition behavior relative to temporal and bloom stages. */
-type ParticleCompositionMode = 'scene';
-/** Shared controls for non-sprite particle surfaces. */
-interface ParticleAdvancedSurfaceDefinition {
-    readonly texture?: Texture<unknown> | null;
-    readonly coverage?: ParticleSurfaceCoverage;
-    readonly alphaCutoff?: number;
-    readonly blend?: 'alpha' | 'premultiplied-alpha' | 'additive';
-    readonly lighting?: ParticleLightingMode;
-    readonly depthTest?: boolean;
-    readonly depthWrite?: boolean;
-    readonly sort?: ParticleSortMode;
-    readonly renderOrder?: number;
-    /** P5 renders into linear scene color before Bloom; other policies fail at compile time. */
-    readonly composition?: ParticleCompositionMode;
-}
-/** Portable sprite output consumed by CPU and WebGPU plans. */
-interface ParticleSpriteRendererDefinition {
-    readonly type: 'sprite';
-    readonly texture?: Texture<unknown> | null;
-    readonly alignment?: ParticleSpriteAlignment;
-    readonly blend?: 'alpha' | 'premultiplied-alpha' | 'additive';
-    readonly depthTest?: boolean;
-    readonly depthWrite?: boolean;
-    readonly sort?: ParticleSortMode;
-    readonly renderOrder?: number;
-    readonly pivot?: ParticleVector2;
-    /** Relative elongation per world-space velocity unit for stretched alignment. */
-    readonly stretchScale?: number;
-    /** WebGPU storage-raster depth fade. Depth write must remain disabled. */
-    readonly softParticle?: Readonly<{
-        readonly distance: number;
-        readonly contrast?: number;
-    }>;
-}
-/** One immutable geometry bucket consumed by a mesh particle renderer. */
-interface ParticleMeshAsset {
-    readonly geometry: Geometry;
-    readonly texture?: Texture<unknown> | null;
-}
-/** Instanced mesh output. One draw is emitted per non-empty mesh bucket, never per particle. */
-interface ParticleMeshRendererDefinition extends ParticleAdvancedSurfaceDefinition {
-    readonly type: 'mesh';
-    readonly meshes: readonly ParticleMeshAsset[];
-    readonly orientation?: 'rotation' | 'velocity';
-    /** Available only for opaque/masked portable CPU mesh output. */
-    readonly motionVectors?: boolean;
-}
-/** Ribbon and trail output compacting adjacent members of each ribbon into dense segments. */
-interface ParticleRibbonRendererDefinition extends ParticleAdvancedSurfaceDefinition {
-    readonly type: 'ribbon' | 'trail';
-    readonly facing?: 'view' | 'world-up';
-    readonly widthScale?: number;
-    readonly uvMode?: 'stretch' | 'repeat';
-    readonly tilesPerUnit?: number;
-    /** Optional WebGPU scene-depth fade. Depth write must remain disabled. */
-    readonly softParticle?: Readonly<{
-        readonly distance: number;
-        readonly contrast?: number;
-    }>;
-}
-/** Renderer definitions remain separate from simulation modules. */
-type ParticleRendererDefinition = ParticleSpriteRendererDefinition | ParticleMeshRendererDefinition | ParticleRibbonRendererDefinition;
-/** Immutable emitter authoring input. */
-interface ParticleEmitterDefinitionInput {
-    readonly name: string;
-    readonly capacity: number;
-    readonly execution?: ParticleExecutionMode;
-    readonly duration?: number;
-    readonly looping?: boolean;
-    readonly startDelay?: number;
-    readonly prewarm?: boolean;
-    readonly fixedStep?: number;
-    readonly maxCatchUpSteps?: number;
-    readonly simulationSpace?: ParticleSimulationSpace;
-    readonly overflow?: ParticleOverflowPolicy;
-    readonly culling?: ParticleCullingReaction;
-    readonly eventCapacity?: number;
-    readonly eventOverflow?: ParticleEventOverflowPolicy;
-    readonly bounds?: ParticleBoundsDefinition;
-    readonly emission?: ParticleEmissionDefinition;
-    readonly shape?: ParticleShapeDefinition;
-    readonly initialize?: ParticleInitializeDefinition;
-    readonly modules?: readonly ParticleModule[];
-    readonly renderers: readonly ParticleRendererDefinition[];
-}
-/** Versioned immutable particle-system authoring input. */
-interface ParticleSystemDefinitionInput {
-    readonly version?: typeof PARTICLE_DEFINITION_VERSION;
-    readonly emitters: readonly ParticleEmitterDefinitionInput[];
-}
-
-/** Immutable, independently hashable emitter definition. */
-declare class ParticleEmitterDefinition {
-    readonly name: string;
-    readonly capacity: number;
-    readonly execution: ParticleExecutionMode;
-    readonly duration: number;
-    readonly looping: boolean;
-    readonly startDelay: number;
-    readonly prewarm: boolean;
-    readonly fixedStep: number;
-    readonly maxCatchUpSteps: number;
-    readonly simulationSpace: ParticleSimulationSpace;
-    readonly overflow: ParticleOverflowPolicy;
-    readonly culling: ParticleCullingReaction;
-    readonly eventCapacity: number;
-    readonly eventOverflow: ParticleEventOverflowPolicy;
-    readonly bounds: ParticleBoundsDefinition;
-    readonly emission: ParticleEmissionDefinition;
-    readonly shape: ParticleShapeDefinition;
-    readonly initialize: ParticleInitializeDefinition;
-    readonly modules: readonly ParticleModule[];
-    readonly renderers: readonly ParticleRendererDefinition[];
-    readonly hash: string;
-    constructor(input: Readonly<ParticleEmitterDefinitionInput>);
-}
-
-/** How faithfully a fixed module can be reconstructed without cross-frame particle state. */
-type ParticleStatelessSupport = 'exact' | 'approximated' | 'stateful-only';
-/** Asset-level stateless diagnostic retained by the compiled particle plan. */
-interface ParticleStatelessModuleMetadata {
-    readonly moduleIndex: number;
-    readonly moduleType: ParticleModule['type'] | 'rate-over-distance';
-    readonly support: ParticleStatelessSupport;
-    readonly reason: string;
-}
-/** Analyze the complete fixed module set without compiling renderer or backend objects. */
-declare function analyzeParticleStatelessEligibility(emitter: ParticleEmitterDefinition): readonly Readonly<ParticleStatelessModuleMetadata>[];
-/** Return only the diagnostics that prevent selection of a stateless execution plan. */
-declare function particleStatelessBlockingDiagnostics(metadata: readonly Readonly<ParticleStatelessModuleMetadata>[]): readonly string[];
-
-/** Immutable, versioned particle asset compiled independently by each renderer. */
-declare class ParticleSystemDefinition {
-    readonly version: 1;
-    readonly emitters: readonly ParticleEmitterDefinition[];
-    readonly hash: string;
-    private constructor();
-    /** Validate and snapshot mutable authoring input. */
-    static create(input: Readonly<ParticleSystemDefinitionInput>): ParticleSystemDefinition;
-    /** Resolve one immutable emitter by stable authored name. */
-    getEmitter(name: string): ParticleEmitterDefinition | null;
-}
-
-/** Typed particle attributes allocated only when a module or renderer consumes them. */
-type ParticleAttributeName = 'stable-id' | 'generation' | 'alive' | 'age' | 'lifetime' | 'normalized-age' | 'position' | 'previous-position' | 'spawn-position' | 'velocity' | 'size' | 'base-size' | 'rotation' | 'base-rotation' | 'color' | 'base-color' | 'sprite-frame' | 'mass' | 'noise-offset' | 'collision-state' | 'mesh-index' | 'ribbon-id' | `custom:${string}`;
-interface ParticleAttributeLayout {
-    readonly name: ParticleAttributeName;
-    readonly storage: 'f32' | 'u32';
-    readonly components: 1 | 2 | 3 | 4;
-    /** Sixteen-byte-aligned byte offset in the generated WebGPU SoA storage buffer. */
-    readonly byteOffset: number;
-    readonly byteLength: number;
-}
-/** Baked scalar curve table retained by a compiled emitter. */
-interface ParticleCurveLUT {
-    readonly curve: ParticleCurve;
-    readonly values: Float32Array;
-}
-/** Baked linear-RGBA gradient table retained by a compiled emitter. */
-interface ParticleGradientLUT {
-    readonly gradient: ParticleGradient;
-    readonly values: Float32Array;
-}
-/** Backend-neutral compiled emitter plan. Shader/native objects remain renderer-internal. */
-interface ParticleCompiledEmitterPlan {
-    readonly definition: ParticleEmitterDefinition;
-    readonly emitterId: number;
-    readonly kind: 'cpu-stateful' | 'gpu-stateful' | 'stateless';
-    readonly attributes: readonly Readonly<ParticleAttributeLayout>[];
-    readonly attributeByteLength: number;
-    readonly layoutHash: string;
-    readonly curveLUTs: readonly Readonly<ParticleCurveLUT>[];
-    readonly gradientLUTs: readonly Readonly<ParticleGradientLUT>[];
-    readonly bounds: Readonly<Bounds>;
-    readonly statelessEligible: boolean;
-    readonly statelessDiagnostics: readonly string[];
-    /** Per-module reconstruction contract consumed by diagnostics and stateless generators. */
-    readonly statelessModules: readonly Readonly<ParticleStatelessModuleMetadata>[];
-    /** Cross-frame particle-state bytes. Stateless renderer input is intentionally excluded. */
-    readonly persistentStateByteLength: number;
-}
-/** Immutable compilation result cached by definition hash and execution environment. */
-interface ParticleCompiledPlan {
-    readonly definition: ParticleSystemDefinition;
-    readonly hash: string;
-    readonly emitters: readonly Readonly<ParticleCompiledEmitterPlan>[];
-}
-
-/** Backend capabilities and optional automatic execution threshold used during plan selection. */
-interface ParticleAdvancedQualityPlan {
-    /** Enable ribbon/trail topology. Explicit false fails definitions that require it. */
-    readonly ribbons?: boolean;
-    /** Enable the controlled Lambert scene-light subset. */
-    readonly litParticles?: boolean;
-    /** Enable portable opaque/masked mesh motion-vector output. */
-    readonly motionVectors?: boolean;
-}
-interface ParticleCompilationEnvironment {
-    readonly backend?: 'webgl2' | 'webgpu';
-    readonly preferGPUAboveCapacity?: number;
-    readonly advancedQuality?: Readonly<ParticleAdvancedQualityPlan>;
-}
-/** Compile immutable particle definitions before any RHI frame begins. */
-declare function compileParticleSystemDefinition(definition: ParticleSystemDefinition, environment?: Readonly<ParticleCompilationEnvironment>): Readonly<ParticleCompiledPlan>;
-
-/** Stable identifier stored at the root of every serialized particle definition. */
-declare const PARTICLE_DEFINITION_SCHEMA: "hilo3d.particle-system";
-/** JSON value accepted by the version upgrade and definition serialization APIs. */
-type ParticleDefinitionJSONValue = null | boolean | number | string | ParticleDefinitionJSONRecord | readonly ParticleDefinitionJSONValue[];
-/** JSON object accepted by the version upgrade and definition serialization APIs. */
-interface ParticleDefinitionJSONRecord {
-    readonly [key: string]: ParticleDefinitionJSONValue;
-}
-/** One serialized parameter declaration referenced by stable document-local identity. */
-interface ParticleDefinitionJSONParameter extends ParticleDefinitionJSONRecord {
-    /** Stable document-local identity used by parameter reference tags. */
-    readonly id: string;
-    /** Public runtime parameter name. */
-    readonly name: string;
-    /** Runtime value kind enforced when the parameter token is recreated. */
-    readonly type: ParticleParameterType;
-    /** Tagged JSON representation of the immutable default value. */
-    readonly defaultValue: ParticleDefinitionJSONValue;
-}
-/** Current versioned JSON representation of an immutable particle-system definition. */
-interface ParticleSystemDefinitionJSON extends ParticleDefinitionJSONRecord {
-    /** Stable particle document family identifier. */
-    readonly schema: typeof PARTICLE_DEFINITION_SCHEMA;
-    /** Current particle document schema version. */
-    readonly version: typeof PARTICLE_DEFINITION_VERSION;
-    /** Shared parameter declarations referenced by emitters. */
-    readonly parameters: readonly ParticleDefinitionJSONParameter[];
-    /** Serialized emitter authoring records. */
-    readonly emitters: readonly ParticleDefinitionJSONRecord[];
-}
-/** Opaque engine resource kinds represented by stable application-owned asset identifiers. */
-type ParticleDefinitionResourceKind = 'texture' | 'geometry';
-/** Opaque engine resources that require application-owned identifiers in JSON. */
-type ParticleDefinitionResource = Texture<unknown> | Geometry;
-/** Options used while converting a runtime definition into portable JSON data. */
-interface ParticleDefinitionSerializationOptions {
-    /** Return a stable asset identifier for every Texture or Geometry encountered. */
-    readonly getResourceId?: (resource: ParticleDefinitionResource, kind: ParticleDefinitionResourceKind) => string;
-}
-/** One sequential JSON schema upgrade. The returned document must use `fromVersion + 1`. */
-interface ParticleDefinitionUpgrade {
-    /** Source version accepted by this step. */
-    readonly fromVersion: number;
-    /** Produce a plain JSON document whose version is exactly `fromVersion + 1`. */
-    readonly upgrade: (document: Readonly<ParticleDefinitionJSONRecord>) => Readonly<ParticleDefinitionJSONRecord>;
-}
-/** Options used while upgrading and materializing a serialized definition. */
-interface ParticleDefinitionDeserializationOptions {
-    /** Resolve stable asset identifiers without embedding runtime object IDs in the document. */
-    readonly resolveResource?: (kind: ParticleDefinitionResourceKind, id: string) => ParticleDefinitionResource;
-    /** Sequential application-owned upgrades for schema versions older than the engine version. */
-    readonly upgrades?: readonly ParticleDefinitionUpgrade[];
-    /** Optional compile target used for backend-specific definition validation. */
-    readonly compilationEnvironment?: Readonly<ParticleCompilationEnvironment>;
-}
-/** Convert an immutable runtime definition into a deeply frozen, versioned JSON document. */
-declare function serializeParticleSystemDefinition(definition: ParticleSystemDefinition, options?: Readonly<ParticleDefinitionSerializationOptions>): Readonly<ParticleSystemDefinitionJSON>;
-/** Upgrade, strictly decode, validate, and snapshot a particle JSON document. */
-declare function deserializeParticleSystemDefinition(source: unknown, options?: Readonly<ParticleDefinitionDeserializationOptions>): ParticleSystemDefinition;
-/** Parse JSON text before applying the same upgrade, resource, and validation contract. */
-declare function parseParticleSystemDefinitionJSON(source: string, options?: Readonly<ParticleDefinitionDeserializationOptions>): ParticleSystemDefinition;
-
-/** Stable external fixed-module graph document family. */
-declare const PARTICLE_AUTHORING_SCHEMA: "hilo3d.particle-authoring";
-/** Current external fixed-module graph and normalized IR version. */
-declare const PARTICLE_AUTHORING_VERSION: 1;
-/** Closed node kinds understood by the external authoring compiler. */
-type ParticleAuthoringNodeKind = 'system' | 'emitter' | 'module' | 'renderer';
-/** Closed ownership ports; edges do not represent arbitrary executable data flow. */
-type ParticleAuthoringPort = 'emitters' | 'modules' | 'renderers';
-/** One JSON node in the external fixed-module authoring graph. */
-interface ParticleAuthoringNode {
-    readonly id: string;
-    readonly kind: ParticleAuthoringNodeKind;
-    readonly data: ParticleDefinitionJSONRecord;
-    /** Opaque JSON retained for an external editor and ignored by runtime compilation. */
-    readonly metadata?: ParticleDefinitionJSONRecord;
-}
-/** One ordered ownership edge in the external authoring graph. */
-interface ParticleAuthoringEdge {
-    readonly id: string;
-    readonly from: string;
-    readonly to: string;
-    readonly port: ParticleAuthoringPort;
-    readonly order: number;
-}
-/** Versioned pure-JSON graph consumed by the external authoring compiler. */
-interface ParticleAuthoringGraph {
-    readonly schema: typeof PARTICLE_AUTHORING_SCHEMA;
-    readonly version: typeof PARTICLE_AUTHORING_VERSION;
-    readonly definitionSchema: typeof PARTICLE_DEFINITION_SCHEMA;
-    readonly definitionVersion: typeof PARTICLE_DEFINITION_VERSION;
-    readonly parameters: readonly ParticleDefinitionJSONParameter[];
-    readonly nodes: readonly Readonly<ParticleAuthoringNode>[];
-    readonly edges: readonly Readonly<ParticleAuthoringEdge>[];
-    /** Opaque graph-level JSON retained for external editor layout/project data. */
-    readonly metadata?: ParticleDefinitionJSONRecord;
-}
-/** Structured compiler feedback addressable to one graph path/node. */
-interface ParticleAuthoringDiagnostic {
-    readonly severity: 'error' | 'warning' | 'info';
-    readonly code: string;
-    readonly message: string;
-    /** Stable graph path; node-addressed paths use the submitted node id. */
-    readonly path: string;
-    readonly nodeId?: string;
-}
-/** Compiler-derived emitter data used by inspectors and preview hosts. */
-interface ParticleAuthoringEmitterIR {
-    readonly nodeId: string;
-    readonly name: string;
-    readonly emitterId: number;
-    readonly planKind: 'cpu-stateful' | 'gpu-stateful' | 'stateless';
-    readonly layoutHash: string;
-    readonly attributes: readonly Readonly<ParticleAttributeLayout>[];
-    readonly moduleNodeIds: readonly string[];
-    readonly rendererNodeIds: readonly string[];
-    readonly statelessEligible: boolean;
-    readonly statelessDiagnostics: readonly string[];
-}
-/** Normalized fixed-module IR; runtime still consumes the embedded ordinary definition. */
-interface ParticleAuthoringIR {
-    readonly schema: typeof PARTICLE_AUTHORING_SCHEMA;
-    readonly version: typeof PARTICLE_AUTHORING_VERSION;
-    readonly systemNodeId: string;
-    readonly definitionJSON: Readonly<ParticleSystemDefinitionJSON>;
-    readonly definitionHash: string;
-    readonly compiledPlanHash: string;
-    readonly emitters: readonly Readonly<ParticleAuthoringEmitterIR>[];
-}
-/** Environment/resource policy for compiling an external authoring graph. */
-type ParticleAuthoringCompileOptions = ParticleDefinitionDeserializationOptions;
-/** Successful external authoring compilation. */
-interface ParticleAuthoringCompileSuccess {
-    readonly success: true;
-    readonly diagnostics: readonly Readonly<ParticleAuthoringDiagnostic>[];
-    readonly graph: Readonly<ParticleAuthoringGraph>;
-    readonly ir: Readonly<ParticleAuthoringIR>;
-    readonly definition: ParticleSystemDefinition;
-    readonly compiledPlan: Readonly<ParticleCompiledPlan>;
-}
-/** Failed external authoring compilation; no partial runtime definition escapes. */
-interface ParticleAuthoringCompileFailure {
-    readonly success: false;
-    readonly diagnostics: readonly Readonly<ParticleAuthoringDiagnostic>[];
-}
-/** Fail-closed result returned to external authoring and preview hosts. */
-type ParticleAuthoringCompileResult = ParticleAuthoringCompileSuccess | ParticleAuthoringCompileFailure;
-/**
- * JSON Schema for graph transport and editor-side structural validation. Definition node payloads
- * remain governed by `PARTICLE_DEFINITION_SCHEMA` and are revalidated by the engine compiler.
- */
-declare const PARTICLE_AUTHORING_JSON_SCHEMA: Readonly<ParticleDefinitionJSONRecord>;
-/** Convert one immutable definition into a deterministic editable fixed-module graph. */
-declare function createParticleAuthoringGraph(definition: ParticleSystemDefinition, options?: Readonly<ParticleDefinitionSerializationOptions>): Readonly<ParticleAuthoringGraph>;
-/** Validate topology, rebuild the ordinary definition, compile it, and expose normalized IR. */
-declare function compileParticleAuthoringGraph(source: unknown, options?: Readonly<ParticleAuthoringCompileOptions>): ParticleAuthoringCompileResult;
-
-/** Renderer-local particle quality and capacity budget. */
-interface ParticleBudgetProfile {
-    readonly maxSystems?: number;
-    readonly maxEmitters?: number;
-    readonly maxParticles?: number;
-    readonly maxDistance?: number;
-    readonly capacityScale?: number;
-    readonly spawnRateScale?: number;
-    readonly sorting?: boolean;
-    readonly softParticles?: boolean;
-    readonly collision?: boolean;
-    readonly ribbons?: boolean;
-}
-/** One stable emitter request submitted to a particle budget manager. */
-interface ParticleBudgetRequest {
-    readonly systemId: string;
-    readonly emitterId: number;
-    readonly capacity: number;
-    readonly estimatedAlive: number;
-    readonly priority?: number;
-    readonly distance?: number;
-    readonly visible?: boolean;
-}
-/** Deterministic quality decision and its explainable degradation reasons. */
-interface ParticleBudgetDecision {
-    readonly systemId: string;
-    readonly emitterId: number;
-    readonly enabled: boolean;
-    readonly particleLimit: number;
-    readonly spawnRateScale: number;
-    readonly sorting: boolean;
-    readonly softParticles: boolean;
-    readonly collision: boolean;
-    readonly ribbons: boolean;
-    readonly reasons: readonly string[];
-}
-/** Shared deterministic allocator used by renderer-local particle managers. */
-declare class ParticleBudgetManager {
-    readonly profile: Readonly<Required<ParticleBudgetProfile>>;
-    constructor(profile?: Readonly<ParticleBudgetProfile>);
-    /** Resolve and immediately apply one complete frame-wide budget to live systems. */
-    apply(systems: readonly ParticleSystem[], camera?: Camera): readonly Readonly<ParticleBudgetDecision>[];
-    /** Resolve a complete frame at once so request order cannot alter the result. */
-    resolve(requests: readonly Readonly<ParticleBudgetRequest>[]): readonly Readonly<ParticleBudgetDecision>[];
-}
-
-/** Current deterministic particle baking artifact format. */
-declare const PARTICLE_BAKE_VERSION: 1;
-/** Shared fixed-rate, half-open timeline used by particle baking. */
-interface ParticleBakeTimelineOptions {
-    /** Sampled duration in seconds. */
-    readonly duration: number;
-    /** Samples per second. */
-    readonly frameRate: number;
-    /** Seconds simulated before the first captured frame. Defaults to zero. */
-    readonly startTime?: number;
-    /** Add one exact sample at `startTime + duration`. Defaults to false. */
-    readonly includeEnd?: boolean;
-    /** Safety limit for generated frames. Defaults to 4096. */
-    readonly maxFrames?: number;
-}
-/** Options for deterministic CPU particle instance-stream baking. */
-interface ParticleMeshCacheOptions extends ParticleBakeTimelineOptions {
-    /** Optional named emitter. Omit to bake every emitter containing a mesh renderer. */
-    readonly emitter?: string;
-    /** Safety limit across all materialized emitter/frame particle records. Defaults to 1048576. */
-    readonly maxSampledParticles?: number;
-}
-/** One emitter's frame-major particle instance streams. */
-interface ParticleBakedMeshEmitter {
-    readonly name: string;
-    readonly emitterId: number;
-    readonly capacity: number;
-    readonly simulationSpace: ParticleSimulationSpace;
-    /** Per-frame record boundaries; frame N occupies `[offsets[N], offsets[N + 1])`. */
-    readonly frameOffsets: Uint32Array;
-    readonly stableIds: Uint32Array;
-    readonly generations: Uint32Array;
-    readonly positions: Float32Array;
-    readonly previousPositions: Float32Array;
-    readonly velocities: Float32Array;
-    readonly sizes: Float32Array;
-    readonly rotations: Float32Array;
-    readonly colors: Float32Array;
-    readonly meshIndices: Uint32Array;
-    /** Per-frame `[xMin, yMin, zMin, xMax, yMax, zMax]`, or zeros for an empty frame. */
-    readonly frameBounds: Float32Array;
-    readonly storageByteLength: number;
-}
-/** Portable frame-major instance data baked from CPU or CPU-materialized stateless simulation. */
-interface ParticleMeshCache {
-    readonly version: typeof PARTICLE_BAKE_VERSION;
-    readonly definitionHash: string;
-    readonly seed: number;
-    readonly duration: number;
-    readonly frameRate: number;
-    readonly startTime: number;
-    readonly includeEnd: boolean;
-    readonly frameCount: number;
-    readonly frameTimes: Float32Array;
-    readonly emitters: readonly Readonly<ParticleBakedMeshEmitter>[];
-    readonly storageByteLength: number;
-}
-/** Context supplied to an offline flipbook renderer/readback callback. */
-interface ParticleFlipbookFrameContext {
-    readonly system: ParticleSystem;
-    readonly frameIndex: number;
-    readonly timeSeconds: number;
-}
-/** Options for packing real render-target captures into one flipbook atlas. */
-interface ParticleFlipbookOptions extends ParticleBakeTimelineOptions {
-    /** Render and asynchronously read one tightly packed color attachment. */
-    readonly captureFrame: (context: Readonly<ParticleFlipbookFrameContext>) => RenderTargetColorAttachmentReadback | PromiseLike<RenderTargetColorAttachmentReadback>;
-    /** Atlas column count. Defaults to a near-square layout. */
-    readonly columns?: number;
-    /** Safety limit for either atlas dimension. Defaults to 16384. */
-    readonly maxTextureSize?: number;
-    /** Safety limit for the packed atlas payload. Defaults to 256 MiB. */
-    readonly maxAtlasByteLength?: number;
-}
-/** One tightly packed native-format flipbook atlas produced from real rendered frames. */
-interface ParticleFlipbook {
-    readonly version: typeof PARTICLE_BAKE_VERSION;
-    readonly definitionHash: string;
-    readonly seed: number;
-    readonly duration: number;
-    readonly frameRate: number;
-    readonly startTime: number;
-    readonly includeEnd: boolean;
-    readonly frameCount: number;
-    readonly frameTimes: Float32Array;
-    readonly frameWidth: number;
-    readonly frameHeight: number;
-    readonly columns: number;
-    readonly rows: number;
-    readonly width: number;
-    readonly height: number;
-    readonly format: RenderTargetColorFormat;
-    readonly bytesPerPixel: number;
-    readonly data: Uint8Array;
-    /** Top-left atlas-space `[uMin, vMin, uMax, vMax]` for each frame. */
-    readonly frameUVs: Float32Array;
-    readonly storageByteLength: number;
-}
-
-/** One application-visible particle event materialized only at a batch boundary. */
-interface ParticleEventRecord {
-    readonly name: string;
-    readonly emitter: string;
-    readonly stableId: number;
-    readonly position: ParticleVector3;
-    readonly velocity: ParticleVector3;
-}
-/** Bounded asynchronous aggregate returned to application code. */
-interface ParticleEventAggregate {
-    readonly events: readonly Readonly<ParticleEventRecord>[];
-    readonly counts: Readonly<Record<string, number>>;
-    readonly droppedCount: number;
-    readonly remainingCount: number;
-}
-
-/** Current in-memory deterministic particle simulation cache format. */
-declare const PARTICLE_SIMULATION_CACHE_VERSION: 1;
-/**
- * Opaque reusable in-memory checkpoint for deterministic particle replay.
- *
- * A cache is intentionally bound to the immutable definition, compiled plan, seed, parameter-set
- * identity/revision, and event-readback capacity from which it was captured. It is not a serialized
- * asset; use definition serialization for persistence and particle baking for portable output.
- */
-interface ParticleSimulationCache {
-    readonly version: typeof PARTICLE_SIMULATION_CACHE_VERSION;
-    readonly definitionHash: string;
-    readonly compiledPlanHash: string;
-    readonly seed: number;
-    readonly parameterRevision: number;
-    readonly elapsedSeconds: number;
-    readonly emitterCount: number;
-    /** Copied typed-array storage retained by this cache, excluding JavaScript metadata. */
-    readonly storageByteLength: number;
-}
-
-/** Construction parameters for a runtime particle scene node. */
-interface ParticleSystemParameters extends NodeParameters {
-    readonly definition: ParticleSystemDefinition;
-    readonly seed?: number;
-    readonly autoPlay?: boolean;
-    readonly timeScale?: number;
-    /** Live typed values used by bindable emission and initialization fields. */
-    readonly parameters?: ParticleParameterSet;
-    /** Stable identifier used by deterministic frame-wide particle budgeting. */
-    readonly budgetId?: string;
-    /** Higher values win budget allocation before distance and identifier tie-breaks. */
-    readonly budgetPriority?: number;
-    /** Optional compile target. Omit for a portable CPU-first plan. */
-    readonly compilationEnvironment?: Readonly<ParticleCompilationEnvironment>;
-    /** Maximum materialized CPU events retained for bounded asynchronous application reads. */
-    readonly eventReadbackCapacity?: number;
-}
-/** Options for an explicit particle simulation advance. */
-interface ParticleSystemSimulateOptions {
-    readonly fixedStep?: number;
-}
-/** Deterministic manual emission targeting the first or a named emitter. */
-interface ParticleSystemEmitCommand {
-    readonly emitter?: string;
-    readonly count: number;
-    readonly position?: ParticleVector3;
-    readonly velocity?: ParticleVector3;
-}
-/** Runtime scene node for immutable compiled particle-system definitions. */
-declare class ParticleSystem extends Node {
-    #private;
-    static readonly typeName = "ParticleSystem";
-    className: string;
-    readonly definition: ParticleSystemDefinition;
-    readonly compiledPlan: Readonly<ParticleCompiledPlan>;
-    readonly seed: number;
-    readonly parameters: ParticleParameterSet;
-    readonly budgetId: string;
-    readonly budgetPriority: number;
-    constructor(parameters: Readonly<ParticleSystemParameters>);
-    /** Whether Stage updates currently advance this particle system. */
-    get playing(): boolean;
-    /** Scaled runtime age in seconds, excluding prewarm. */
-    get elapsedSeconds(): number;
-    /** Total dense alive count across CPU/stateless emitters; GPU plans avoid count readback. */
-    get aliveCount(): number;
-    /** Whether the compiled system contains renderer-owned stateful WebGPU emitters. @internal */
-    get hasGPUEmitters(): boolean;
-    /** Whether a GPU emitter contributes opaque or alpha-masked advanced draws. @internal */
-    get hasGPUOpaqueRenderers(): boolean;
-    /** Whether this system needs a sampled Forward depth texture for GPU simulation/raster. @internal */
-    get requiresGPUSampledDepth(): boolean;
-    /** Whether any GPU emitter has simulation or spawn work waiting for graph recording. @internal */
-    get hasPendingGPUWork(): boolean;
-    /** Whether this node contributes a visible GPU draw for one camera. @internal */
-    isGPUVisible(camera: Camera): boolean;
-    /** True after all non-looping emitters finished and their dense alive ranges became empty. */
-    get completed(): boolean;
-    /** Bounded aggregate event diagnostics; no GPU or per-particle synchronous readback occurs. */
-    get eventDiagnostics(): Readonly<{
-        pendingCount: number;
-        droppedCount: number;
-    }>;
-    /** Build current per-emitter requests for a frame-wide budget allocation. @internal */
-    createBudgetRequests(camera?: Camera): readonly Readonly<ParticleBudgetRequest>[];
-    /** Apply one complete set of frame-wide budget decisions. @internal */
-    applyBudgetDecisions(decisions: readonly Readonly<ParticleBudgetDecision>[]): this;
-    get timeScale(): number;
-    set timeScale(value: number);
-    play(): this;
-    pause(): this;
-    stop(): this;
-    restart(): this;
-    /** Reset simulation and authored node state before a pool lease. @internal */
-    resetForPool(parameters: Readonly<ParticleSystemParameters>): this;
-    /** Advance explicitly in seconds even when playback is paused. */
-    simulate(seconds: number, options?: Readonly<ParticleSystemSimulateOptions>): this;
-    /** Queue deterministic manual emission on the first or named emitter. */
-    emit(count: number, emitter?: string): this;
-    emit(command: Readonly<ParticleSystemEmitCommand>): this;
-    /** Dispatch a named gameplay event without admitting arbitrary simulation callbacks. */
-    sendEvent(name: string, payload?: unknown): this;
-    /** Materialize at most `maxEvents` from compact CPU event buffers on an async boundary. */
-    readEvents(maxEvents?: number): Promise<ParticleEventAggregate>;
-    /** Deterministic dense-state hash for replay and regression tests. */
-    stateHash(emitter?: string): string;
-    /**
-     * Bake stable-ID-sorted frame-major instance streams for authored mesh emitters.
-     *
-     * The system is restored to its exact simulation checkpoint after the synchronous bake.
-     */
-    bakeMeshCache(options: Readonly<ParticleMeshCacheOptions>): ParticleMeshCache;
-    /**
-     * Bake real render-target readbacks into a tightly packed flipbook atlas.
-     *
-     * The callback owns rendering and asynchronous readback; the system owns deterministic timeline
-     * advancement and restores its exact checkpoint after completion or failure.
-     */
-    bakeFlipbook(options: Readonly<ParticleFlipbookOptions>): Promise<ParticleFlipbook>;
-    /**
-     * Capture one reusable deterministic replay checkpoint without GPU readback.
-     *
-     * Stateful GPU emitters are rejected because their authoritative state is device-resident.
-     * Stateless GPU emitters capture only absolute reconstruction time.
-     */
-    captureSimulation(): ParticleSimulationCache;
-    /** Restore a compatible checkpoint and make its simulation state current. */
-    restoreSimulation(cache: ParticleSimulationCache): this;
-    update(deltaTimeMilliseconds: number): void;
-    clone(isChild?: boolean): ParticleSystem;
-    destroy(renderer?: Renderer, destroyTextures?: boolean): this;
-    /** Allocate renderer-owned GPU state before the renderer enters its frame transaction. @internal */
-    prepareGPU(renderer: RendererContract): void;
-    /** Refresh per-camera CPU sort and topology streams before scene collection. @internal */
-    prepareView(camera: Camera): void;
-    /** Record GPU simulation and storage-raster passes through the active Forward graph. @internal */
-    recordGPU(context: RenderPipelineContext, color: RenderGraphTextureHandle, depth: RenderGraphTextureHandle | null, drawVisible: boolean, phase: 'opaque' | 'transparent'): void;
-    /** Commit staged GPU clocks only after the enclosing graph submission succeeds. @internal */
-    gpuFrameSubmitted(frameIndex: number): void;
-    /** Preserve queued GPU commands and roll the double-buffer index back on failure. @internal */
-    gpuFrameDiscarded(frameIndex: number): void;
-    private createRuntime;
-    private updateWorldContext;
-    private advance;
-    private advanceWithCulling;
-    private runtimeVisible;
-    private hierarchyVisible;
-    private runtimeBoundsVisible;
-    private syncWriters;
-    private prewarmEmitters;
-    private collectCPUEvents;
-    private updateCompletion;
-    private advanceRuntime;
-    private materializeStatelessCPU;
-    private findStage;
-}
-
-/** Current deterministic external particle preview command protocol. */
-declare const PARTICLE_PREVIEW_PROTOCOL_VERSION: 1;
-/** Commands accepted by `ParticleAuthoringPreviewController`. */
-type ParticleAuthoringPreviewCommand = 'compile' | 'play' | 'pause' | 'restart' | 'seek' | 'step' | 'inspect' | 'dispose';
-interface ParticleAuthoringPreviewRequestBase {
-    readonly protocolVersion: typeof PARTICLE_PREVIEW_PROTOCOL_VERSION;
-    readonly requestId: string;
-    readonly command: ParticleAuthoringPreviewCommand;
-}
-/** Compile and install one external authoring graph for preview. */
-interface ParticleAuthoringPreviewCompileRequest extends ParticleAuthoringPreviewRequestBase {
-    readonly command: 'compile';
-    readonly graph: Readonly<ParticleAuthoringGraph>;
-    readonly seed?: number;
-}
-/** Playback/control request without a numeric payload. */
-interface ParticleAuthoringPreviewControlRequest extends ParticleAuthoringPreviewRequestBase {
-    readonly command: 'play' | 'pause' | 'restart' | 'inspect' | 'dispose';
-}
-/** Deterministically seek from authored start/prewarm state. */
-interface ParticleAuthoringPreviewSeekRequest extends ParticleAuthoringPreviewRequestBase {
-    readonly command: 'seek';
-    readonly timeSeconds: number;
-}
-/** Advance one explicit preview step regardless of play/pause state. */
-interface ParticleAuthoringPreviewStepRequest extends ParticleAuthoringPreviewRequestBase {
-    readonly command: 'step';
-    readonly deltaSeconds: number;
-}
-/** Closed request union transported between an external editor and preview host. */
-type ParticleAuthoringPreviewRequest = ParticleAuthoringPreviewCompileRequest | ParticleAuthoringPreviewControlRequest | ParticleAuthoringPreviewSeekRequest | ParticleAuthoringPreviewStepRequest;
-/** Compact backend-neutral preview state; no GPU particle readback is performed. */
-interface ParticleAuthoringPreviewState {
-    readonly status: 'empty' | 'ready' | 'playing' | 'completed' | 'disposed';
-    readonly timeSeconds: number;
-    readonly definitionHash: string | null;
-    readonly compiledPlanHash: string | null;
-    readonly seed: number | null;
-    readonly aliveCount: number;
-    readonly stateHash: string | null;
-}
-/** Structured response returned for every accepted or rejected preview command. */
-interface ParticleAuthoringPreviewResponse {
-    readonly protocolVersion: typeof PARTICLE_PREVIEW_PROTOCOL_VERSION;
-    readonly requestId: string;
-    readonly command: ParticleAuthoringPreviewCommand | 'invalid';
-    readonly success: boolean;
-    readonly diagnostics: readonly Readonly<ParticleAuthoringDiagnostic>[];
-    readonly state: Readonly<ParticleAuthoringPreviewState>;
-    /** Present after successful compilation so external inspectors can rebuild without runtime access. */
-    readonly ir?: Readonly<ParticleAuthoringIR>;
-}
-/** Factory used when a preview host needs custom ParticleSystem construction/attachment. */
-type ParticleAuthoringPreviewSystemFactory = (definition: ParticleSystemDefinition, seed: number, compilationEnvironment?: Readonly<ParticleCompilationEnvironment>) => ParticleSystem;
-/** Preview host integration hooks and compiler resource/environment policy. */
-interface ParticleAuthoringPreviewControllerOptions {
-    readonly compileOptions?: Readonly<ParticleAuthoringCompileOptions>;
-    readonly createSystem?: ParticleAuthoringPreviewSystemFactory;
-    /** Release renderer/scene ownership when a compiled preview is replaced or disposed. */
-    readonly disposeSystem?: (system: ParticleSystem) => void;
-}
-/**
- * Deterministic preview command adapter. The controller owns simulation time and never renders;
- * hosts render the current `system` through the ordinary Renderer/Stage contract.
- */
-declare class ParticleAuthoringPreviewController {
-    #private;
-    constructor(options?: Readonly<ParticleAuthoringPreviewControllerOptions>);
-    /** Current preview node for host-owned scene attachment/rendering. */
-    get system(): ParticleSystem | null;
-    /** Validate and execute one protocol request without throwing authoring errors. */
-    handle(request: unknown): Readonly<ParticleAuthoringPreviewResponse>;
-    private compile;
-    private withSystem;
-    private releaseSystem;
-    private state;
-    private response;
-    private parseRequest;
-}
-
-/** Fixed field types accepted by a typed particle event channel. */
-type ParticleEventFieldType = 'float' | 'uint' | 'boolean' | 'vec2' | 'vec3' | 'vec4' | 'color';
-/** Runtime values accepted by typed event fields. */
-type ParticleEventFieldValue = number | boolean | ParticleVector2 | ParticleVector3 | ParticleVector4;
-/** Stable field schema participating in an event channel's public contract. */
-type ParticleEventChannelSchema = Readonly<Record<string, ParticleEventFieldType>>;
-/** Small typed payload submitted by applications or aggregate event routing. */
-type ParticleEventChannelPayload = Readonly<Record<string, ParticleEventFieldValue>>;
-/** Construction parameters for a bounded typed data channel. */
-interface ParticleEventChannelParameters<Payload extends ParticleEventChannelPayload> {
-    readonly schema: Readonly<{
-        [Name in keyof Payload]: ParticleEventFieldType;
-    }>;
-    readonly capacity: number;
-    readonly overflow?: ParticleEventOverflowPolicy;
-    readonly name?: string;
-}
-/**
- * Bounded typed event/data channel for sharing impact-style bursts with a resident particle
- * system. Overflow is explicit and draining is batched.
- */
-declare class ParticleEventChannel<Payload extends ParticleEventChannelPayload> {
-    #private;
-    readonly name: string;
-    readonly schema: Readonly<ParticleEventChannelSchema>;
-    readonly capacity: number;
-    readonly overflow: ParticleEventOverflowPolicy;
-    constructor(parameters: Readonly<ParticleEventChannelParameters<Payload>>);
-    get size(): number;
-    get droppedCount(): number;
-    submit(payload: Readonly<Payload>): boolean;
-    drain(maxCount?: number): readonly Readonly<Payload>[];
-    /** Drain position/velocity payloads into one resident emitter without creating systems. */
-    emitTo(system: ParticleSystem, options?: Readonly<{
-        emitter?: string;
-        count?: number;
-        positionField?: keyof Payload & string;
-        velocityField?: keyof Payload & string;
-    }>): number;
-}
-
-/** Reuses stopped ParticleSystem nodes for large numbers of short-lived effects. */
-declare class ParticleSystemPool {
-    #private;
-    constructor(capacity?: number);
-    get activeCount(): number;
-    get pooledCount(): number;
-    acquire(parameters: Readonly<ParticleSystemParameters>): ParticleSystem;
-    release(system: ParticleSystem, renderer?: Renderer): void;
-    destroy(renderer: Renderer): void;
-}
-
 interface BoxGeometryParameters extends GeometryParameters {
     width?: number;
     height?: number;
@@ -10661,114 +9819,6 @@ declare class UiButton extends SlicedSprite {
     private updateState;
 }
 
-/** Sample interpretation supported by whole-subresource compute graph textures. */
-type ComputeTextureSampleType = 'float' | 'unfilterable-float' | 'depth';
-/** Compute graph textures currently expose one complete two-dimensional subresource. */
-type ComputeTextureViewDimension = '2d';
-/** Compute storage textures currently expose one complete two-dimensional subresource. */
-type ComputeStorageTextureViewDimension = '2d';
-/** Sample interpretation supported by storage-aware graphics shaders. */
-type ShaderTextureSampleType = ComputeTextureSampleType | 'sint' | 'uint';
-/** Texture views supported by the Material-backed storage graphics path. */
-type ShaderTextureViewDimension = ComputeTextureViewDimension | '2d-array' | '3d' | 'cube';
-/** Public color formats that can be requested for a storage-texture binding. */
-type ComputeStorageTextureFormat = 'r32float' | 'rg32float' | 'rgba8unorm' | 'rgba16float' | 'rgba32float';
-/** Graph initialization promise for a writable storage-buffer binding. */
-type ComputeStorageBufferAccess = 'read-write' | 'write-discard';
-/** Resource binding that a shader may only read. */
-type ShaderReadBinding = Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'uniform-buffer' | 'read-only-storage-buffer';
-    minBindingSize?: number;
-    dynamicOffset?: boolean;
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'sampled-texture';
-    sampleType: ShaderTextureSampleType;
-    viewDimension?: ShaderTextureViewDimension;
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'sampler' | 'comparison-sampler';
-}>;
-/** Explicit binding ABI for one Direct WGSL compute shader. */
-type ComputeShaderBinding = Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'uniform-buffer' | 'read-only-storage-buffer';
-    minBindingSize?: number;
-    dynamicOffset?: boolean;
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'sampled-texture';
-    sampleType: ComputeTextureSampleType;
-    viewDimension?: ComputeTextureViewDimension;
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'sampler' | 'non-filtering-sampler' | 'comparison-sampler';
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'storage-buffer';
-    /** Graph access promise; both modes use a WGSL `read_write` storage declaration. */
-    access: ComputeStorageBufferAccess;
-    minBindingSize?: number;
-    dynamicOffset?: boolean;
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'storage-texture';
-    /**
-     * WGSL access mode. Declaring this binding also promises that the pass completely
-     * replaces the bound texture subresource before a later graph read.
-     */
-    access: 'write-only';
-    format: ComputeStorageTextureFormat;
-    viewDimension?: ComputeStorageTextureViewDimension;
-}>;
-/** Immutable source, entry point, workgroup size, and binding ABI for {@link ComputeShader}. */
-interface ComputeShaderDescriptor {
-    /** Optional diagnostic label. */
-    readonly label?: string;
-    /** Direct WGSL source containing exactly the declared compute entry point and resources. */
-    readonly source: string;
-    /** Compute entry-point name. Defaults to `main`. */
-    readonly entryPoint?: string;
-    /** One to three positive literal dimensions, which must match `@workgroup_size`. */
-    readonly workgroupSize: readonly [number, number?, number?];
-    /** Complete explicit resource ABI; entries are snapshotted and sorted by group/binding. */
-    readonly bindings: readonly ComputeShaderBinding[];
-}
-/** Normalized three-dimensional compute workgroup size. */
-type NormalizedComputeWorkgroupSize = readonly [number, number, number];
-/** Immutable, backend-neutral Direct WGSL compute shader configuration. */
-declare class ComputeShader {
-    /** Stable diagnostic label, or an empty string. */
-    readonly label: string;
-    /** Validated Direct WGSL source. */
-    readonly source: string;
-    /** Validated compute entry point. */
-    readonly entryPoint: string;
-    /** Normalized workgroup dimensions. */
-    readonly workgroupSize: NormalizedComputeWorkgroupSize;
-    /** Immutable bindings in group/binding order. */
-    readonly bindings: readonly ComputeShaderBinding[];
-    /** Snapshot a Direct WGSL compute shader contract without creating device objects. */
-    constructor(descriptor: Readonly<ComputeShaderDescriptor>);
-}
-
 /** Value accepted by a fixed WGSL pipeline override constant. */
 type ComputePipelineConstant = number | boolean;
 /** Immutable compute pipeline configuration shared across renderer-local caches. */
@@ -10854,37 +9904,6 @@ declare class ComputeSampler {
     constructor(descriptor?: Readonly<ComputeSamplerDescriptor>);
 }
 
-/** Constrained GLSL ES 3.10 graphics source and readonly resource ABI. */
-interface StorageGraphicsShaderDescriptor {
-    /** Optional diagnostic label. */
-    readonly label?: string;
-    /** GLSL ES 3.10 vertex source; storage blocks must be `readonly` and `std430`. */
-    readonly vertexSource: string;
-    /** GLSL ES 3.10 fragment source; storage blocks must be `readonly` and `std430`. */
-    readonly fragmentSource: string;
-    /** Complete read-only resource ABI shared by the two graphics stages. */
-    readonly bindings: readonly ShaderReadBinding[];
-}
-/**
- * Immutable WebGPU-only graphics shader configuration for readonly storage-buffer rendering.
- *
- * Sources use the constrained GLSL ES 3.10 contract. Compilation still runs through the shared
- * engine GLSL preprocessing and Naga translation path; this object never accepts hand-written
- * graphics WGSL.
- */
-declare class StorageGraphicsShader {
-    /** Stable diagnostic label, or an empty string. */
-    readonly label: string;
-    /** Immutable GLSL ES 3.10 vertex source. */
-    readonly vertexSource: string;
-    /** Immutable GLSL ES 3.10 fragment source. */
-    readonly fragmentSource: string;
-    /** Immutable bindings in group/binding order. */
-    readonly bindings: readonly ShaderReadBinding[];
-    /** Snapshot a WebGPU-only storage-aware graphics shader contract. */
-    constructor(descriptor: Readonly<StorageGraphicsShaderDescriptor>);
-}
-
 /** Scalar WGSL storage-address-space types supported by {@link StorageLayout}. */
 type StorageScalarType = 'f32' | 'i32' | 'u32' | 'atomic<i32>' | 'atomic<u32>';
 /** Two-, three-, and four-component WGSL storage vector types. */
@@ -11205,30 +10224,62 @@ interface ScreenSpaceReflectionsOptions {
     readonly historyWeight?: number;
     /** Maximum relative reprojected view-depth error. Defaults to 0.03. */
     readonly depthThreshold?: number;
-    /** Linear HDR reflection multiplier. Defaults to 1. */
+    /** Linear HDR multiplier applied to SSR radiance, without scaling fallback removal. Defaults to 1. */
     readonly intensity?: number;
 }
 
+/** Quality preset used when an individual GTAO sampling control is omitted. */
+type GroundTruthAmbientOcclusionQuality = 'low' | 'medium' | 'high' | 'ultra';
+/** Normal source used for GTAO horizon integration and edge rejection. */
+type GroundTruthAmbientOcclusionNormalSource = 'material' | 'geometry' | 'hybrid';
 /** Production controls for ground-truth ambient occlusion. */
 interface GroundTruthAmbientOcclusionOptions {
-    /** Internal AO resolution relative to opaque rendering. Defaults to 0.5. */
+    /** Sampling preset. Individual resolution/direction/step controls override it. Defaults to high. */
+    readonly quality?: GroundTruthAmbientOcclusionQuality;
+    /** Internal AO resolution relative to opaque rendering. Defaults to the quality preset. */
     readonly resolutionScale?: number;
     /** View-space horizon-search radius. Defaults to 2. */
     readonly radius?: number;
     /** Fraction of the radius at which distance falloff begins. Defaults to 0.6. */
     readonly falloffStart?: number;
-    /** Thin-surface tolerance in view-space units. Defaults to 0.05. */
+    /** View-space self-intersection rejection distance. Defaults to 0.05. */
     readonly thickness?: number;
-    /** Number of rotated horizon slices per pixel. Defaults to 6. */
-    readonly directionCount?: 4 | 6 | 8;
-    /** Samples evaluated on each side of a horizon slice. Defaults to 4. */
-    readonly stepCount?: 3 | 4 | 5 | 6;
+    /** Blend between a thin depth field and a solid occluder. Defaults to 0.5. */
+    readonly thicknessBlend?: number;
+    /** Number of rotated horizon slices per pixel. Defaults to the quality preset. */
+    readonly directionCount?: 2 | 3 | 4 | 6 | 8;
+    /** Samples evaluated on each side of a horizon slice. Defaults to the quality preset. */
+    readonly stepCount?: 3 | 4 | 5 | 6 | 8 | 10 | 12;
     /** Contrast applied to the physically normalized visibility. Defaults to 1.2. */
     readonly power?: number;
+    /** Occlusion intensity before contrast. Defaults to 1. */
+    readonly intensity?: number;
+    /** Angular self-occlusion bias in radians. Defaults to 0.035. */
+    readonly bias?: number;
+    /** Radius of the additional contact-occlusion lobe, relative to radius. Defaults to 0.2. */
+    readonly contactRadiusScale?: number;
+    /** Strength of the contact-occlusion lobe. Defaults to 0.35. */
+    readonly contactStrength?: number;
+    /** Normal source used by the horizon search. Defaults to hybrid. */
+    readonly normalSource?: GroundTruthAmbientOcclusionNormalSource;
+    /** Geometric-normal contribution in hybrid mode. Defaults to 0.65. */
+    readonly geometricNormalWeight?: number;
+    /** Strength of bent-normal redirection. Defaults to 1. */
+    readonly bentNormalStrength?: number;
+    /** Strength of color-aware multi-bounce diffuse AO. Defaults to 1. */
+    readonly multiBounce?: number;
+    /** View distance where AO starts fading. Defaults to 100. */
+    readonly distanceFadeStart?: number;
+    /** View distance where AO is fully disabled. Defaults to 200. */
+    readonly distanceFadeEnd?: number;
+    /** Screen-edge fade width in AO pixels. Defaults to 2. */
+    readonly edgeFadePixels?: number;
     /** Maximum accepted temporal contribution. Defaults to 0.9. */
     readonly historyWeight?: number;
     /** Maximum relative reprojected view-depth error. Defaults to 0.03. */
     readonly depthThreshold?: number;
+    /** Minimum normal agreement accepted by temporal reprojection. Defaults to 0.82. */
+    readonly normalThreshold?: number;
 }
 /**
  * Portable production GTAO for the shared Forward pipeline.
@@ -11440,6 +10491,41 @@ declare class AutoExposure implements ForwardRenderPipelineFeature {
     readDiagnostics(): Promise<Readonly<AutoExposureDiagnostics>>;
 }
 
+/** GPU receiver-driven shadow-page allocation and directional clipmap controls. */
+interface VirtualShadowMapOptions {
+    /** Square virtual resolution for every directional clipmap level. Defaults to 4096. */
+    readonly virtualResolution?: number;
+    /** Square physical page edge in pixels. Defaults to 128. */
+    readonly pageSize?: number;
+    /** Shared physical depth-page capacity. Defaults to 32. */
+    readonly physicalPageCount?: number;
+    /** Maximum missing or invalidated pages rendered by one frame. Defaults to 16. */
+    readonly maxPageUpdatesPerFrame?: number;
+    /** Camera-centered directional clipmap levels. Defaults to 4. */
+    readonly directionalClipmapLevels?: number;
+    /** Full world-space width covered by the finest clipmap. Defaults to 64. */
+    readonly firstDirectionalClipmapExtent?: number;
+}
+/** On-demand counters copied only when diagnostics are explicitly requested. */
+interface VirtualShadowMapDiagnostics {
+    /** Unique logical pages requested by the latest submitted receiver pass. */
+    readonly requestedPageCount: number;
+    /** Physical pages whose depth contents were refreshed by the latest submitted frame. */
+    readonly renderedPageCount: number;
+    /** Requested or dirty pages postponed by the configured update/physical-page budgets. */
+    readonly deferredPageCount: number;
+    /** Valid physical residency records retained after the latest submitted allocation. */
+    readonly residentPageCount: number;
+    /** Resident physical pages remapped to another logical identity. */
+    readonly evictionCount: number;
+    /** Unique logical pages touched by changed caster coverage. */
+    readonly invalidatedPageCount: number;
+    /** Configured physical depth-page capacity. */
+    readonly physicalPageCapacity: number;
+    /** Configured camera-centered clipmap levels per directional light. */
+    readonly directionalClipmapLevelCount: number;
+}
+
 /** Rendering budgets for the physical atmosphere and volumetric clouds. */
 type AtmosphereWeatherQuality = 'low' | 'medium' | 'high' | 'ultra';
 /** Optional diagnostic texture shown in place of the weather composition. */
@@ -11558,6 +10644,22 @@ interface GPUSceneBucket {
     /** Optional coarse levels ordered from smallest to largest projected-radius threshold. */
     readonly lods?: readonly GPUSceneLOD[];
 }
+/** One concrete scene shader topology requested before the first application frame. */
+interface ClusteredMaterialVariantManifestEntry {
+    /** Exemplar carrying the exact geometry deformation and PBR material topology. */
+    readonly mesh: Mesh;
+    /** Also warm the receive-shadow variant. Defaults to the exemplar's current setting. */
+    readonly shadowed?: boolean;
+}
+/** Bounded startup manifest for clustered scene shader translation and diagnostics. */
+interface ClusteredMaterialVariantManifest {
+    /** Exact mesh/material exemplars whose native clustered variants are required at startup. */
+    readonly entries: readonly Readonly<ClusteredMaterialVariantManifestEntry>[];
+    /** Maximum unique native scene variants, including runtime discoveries. Defaults to 64. */
+    readonly maxVariants?: number;
+    /** Variants translated before yielding back to renderer initialization. Defaults to 4. */
+    readonly warmupBatchSize?: number;
+}
 /** Construction options for the WebGPU high-end GPU Scene and Clustered Forward+ pipeline. */
 interface ClusteredForwardPlusPipelineOptions {
     /**
@@ -11565,7 +10667,10 @@ interface ClusteredForwardPlusPipelineOptions {
      * other scene meshes remain renderable through the shared Forward compatibility path.
      */
     readonly buckets: readonly GPUSceneBucket[];
-    /** Stable GPU Scene object capacity. Excess meshes use the Forward fallback. Defaults to 16,384. */
+    /**
+     * Stable fixed-bucket GPU Scene object capacity. Compatible excess PBR uses the direct native
+     * clustered lane; unsupported content uses Forward compatibility. Defaults to 16,384.
+     */
     readonly maxObjects?: number;
     /** GPU light-database capacity. Extra traversal-order lights are deterministically dropped. */
     readonly maxLights?: number;
@@ -11583,6 +10688,11 @@ interface ClusteredForwardPlusPipelineOptions {
     readonly maxViewportHeight?: number;
     /** Enable previous-frame Hi-Z occlusion. Defaults to true. */
     readonly hiZ?: boolean;
+    /**
+     * GPU receiver-driven virtual directional shadows with arbitrary page-table remapping and
+     * camera-centered clipmaps. Requires `hiZ`; disabled by default.
+     */
+    readonly virtualShadows?: Readonly<VirtualShadowMapOptions> | false;
     /** Bloom contribution mixed into the final display transform. Defaults to 0.7. */
     readonly bloomStrength?: number;
     /** Exposure multiplier applied before the ACES display transform. Defaults to 1. */
@@ -11618,6 +10728,8 @@ interface ClusteredForwardPlusPipelineOptions {
      * This WebGPU path uses the complete 3D cluster light grid and submission-aware history.
      */
     readonly volumetricLighting?: Readonly<VolumetricLightingOptions> | false;
+    /** Optional bounded material/deformation topology manifest translated during async creation. */
+    readonly variantManifest?: Readonly<ClusteredMaterialVariantManifest>;
 }
 /** On-demand GPU counters plus current CPU database occupancy. */
 interface ClusteredForwardPlusDiagnostics {
@@ -11625,6 +10737,10 @@ interface ClusteredForwardPlusDiagnostics {
     readonly objectCount: number;
     /** Visible-layer meshes routed through the shared Forward compatibility fallback. */
     readonly fallbackObjectCount: number;
+    /** Alpha-blended PBR meshes shaded from the Clustered Forward+ light database. */
+    readonly clusteredTransparentObjectCount: number;
+    /** Non-bucket opaque PBR meshes using native clustered lighting with shared deformation. */
+    readonly clusteredDeformedObjectCount: number;
     /** Enabled supported lights uploaded to the current GPU light database. */
     readonly lightCount: number;
     /** Enabled supported lights rejected by the configured light capacity. */
@@ -11649,20 +10765,49 @@ interface ClusteredForwardPlusDiagnostics {
     readonly volumetricFroxelCount: number;
     /** Whether the latest submitted volumetric resolve consumed temporal history. */
     readonly volumetricHistoryUsed: boolean;
+    /** Eight-by-eight SSR trace tiles containing at least one eligible receiver. */
+    readonly screenSpaceReflectionActiveTileCount: number;
+    /** Eligible SSR receiver pixels classified by the latest submitted frame. */
+    readonly screenSpaceReflectionActivePixelCount: number;
+    /** Eligible SSR receiver pixels that produced a valid screen-space hit. */
+    readonly screenSpaceReflectionHitPixelCount: number;
+    /** Eligible SSR receiver pixels that missed or left the screen. */
+    readonly screenSpaceReflectionMissPixelCount: number;
+    /** SSR misses whose hierarchy crossing could not be validated precisely. */
+    readonly screenSpaceReflectionUncertainPixelCount: number;
+    /** SSR candidates rejected because the hit surface faced away from the ray. */
+    readonly screenSpaceReflectionBackfaceRejectedPixelCount: number;
+    /** SSR temporal pixels that consumed valid surface- or hit-domain history. */
+    readonly screenSpaceReflectionHistoryAcceptedPixelCount: number;
+    /** SSR temporal pixels that rejected every available history candidate. */
+    readonly screenSpaceReflectionHistoryRejectedPixelCount: number;
     /** Latest adapted exposure in EV stops, or zero when auto exposure is disabled. */
     readonly autoExposureEV: number;
     /** Latest histogram-derived target exposure in EV stops, or zero when disabled. */
     readonly autoExposureTargetEV: number;
+    /** Unique manifest variants translated before renderer creation completed. */
+    readonly warmedMaterialVariantCount: number;
+    /** Unique native variants admitted by the configured runtime budget. */
+    readonly activeMaterialVariantCount: number;
+    /** Runtime candidates rejected after the unique variant budget was exhausted. */
+    readonly materialVariantBudgetExceededCount: number;
+    /** Configured unique clustered scene-variant ceiling. */
+    readonly materialVariantBudget: number;
+    /** CPU translation wall time spent in asynchronous warmup. */
+    readonly materialVariantWarmupTimeMs: number;
+    /** Latest on-demand virtual-shadow counters, or null when virtual shadows are disabled. */
+    readonly virtualShadows: Readonly<VirtualShadowMapDiagnostics> | null;
 }
 /**
  * WebGPU-only high-end factory combining G0 GPU Scene/Hi-Z and L0 Clustered Forward+.
  *
  * Compatible registered bucket meshes bypass CPU frustum sorting and ordinary PreparedDraw
- * creation. The GPU-driven path intentionally accepts opaque, unskinned, indexed triangle PBR
- * buckets with scalar factors or common opaque PBR maps. Material surface evaluation and the BRDF
- * are shared with ordinary Forward PBR; the clustered variant replaces only light-list selection
- * and iteration. Unregistered meshes, runtime-incompatible bucket state, deformation,
- * transparency, and object-capacity overflow use the shared Forward path in the same frame.
+ * creation. Fixed indirect buckets accept opaque, unskinned, indexed triangle PBR geometry;
+ * eligible deformed, layered, and globally sorted transparent PBR meshes use the native direct
+ * storage-lighting lane. Material surface evaluation and the BRDF are shared with ordinary Forward
+ * PBR; clustered variants replace only light-list selection and iteration. Unregistered meshes,
+ * runtime-incompatible state, mixed compatibility-transparent queues, and object-capacity overflow
+ * use the shared Forward path in the same frame.
  * Invalid initial bucket declarations and unsupported devices still fail closed.
  */
 declare class ClusteredForwardPlusPipelineFactory implements RenderPipelineFactory {
@@ -11673,11 +10818,42 @@ declare class ClusteredForwardPlusPipelineFactory implements RenderPipelineFacto
     readonly requirements: Readonly<RenderPipelineRequirements>;
     constructor(options: Readonly<ClusteredForwardPlusPipelineOptions>);
     /** Create one independent renderer-local GPU Scene and clustered-lighting runtime. */
-    create(context: RenderPipelineCreateContext): RenderPipeline;
+    create(context: RenderPipelineCreateContext): Promise<RenderPipeline>;
     /** Read on-demand GPU counters when this factory is attached to exactly one live Renderer. */
     readDiagnostics(): Promise<Readonly<ClusteredForwardPlusDiagnostics>>;
 }
 
+/** Process-global symbol used by optional addons to attach renderer behavior across package copies. */
+declare const RENDER_NODE_EXTENSION: unique symbol;
+/** GPU graph contribution owned by an optional scene-node addon. */
+interface RenderNodeGPUExtension {
+    /** Whether this contribution has an opaque or alpha-masked phase. */
+    readonly hasOpaqueRenderers: boolean;
+    /** Whether simulation or raster needs the current sampled scene depth. */
+    readonly requiresSampledDepth: boolean;
+    /** Whether graph work must run even when the contribution is outside the camera. */
+    readonly hasPendingWork: boolean;
+    /** Test view visibility without issuing render commands. */
+    isVisible(camera: Camera): boolean;
+    /** Record one opaque or transparent contribution through the active Render Graph. */
+    record(context: RenderPipelineContext, color: RenderGraphTextureHandle, depth: RenderGraphTextureHandle | null, drawVisible: boolean, phase: 'opaque' | 'transparent'): void;
+    /** Commit staged state only after the enclosing frame submission succeeds. */
+    frameSubmitted(frameIndex: number): void;
+    /** Roll back staged state after recording or submission is discarded. */
+    frameDiscarded(frameIndex: number): void;
+}
+/** Optional render lifecycle implemented by addon-owned scene nodes. */
+interface RenderNodeExtension {
+    /** Allocate or recover renderer-local resources before node updates and graph recording. */
+    prepareRenderer?(renderer: RendererContract): void;
+    /** Refresh camera-dependent streams before scene collection. */
+    prepareView?(camera: Camera): void;
+    /** Active GPU contribution, or `null` when this node uses ordinary scene rendering only. */
+    readonly gpu: RenderNodeGPUExtension | null;
+}
+/** Read and validate an optional render-node extension without importing its addon package. */
+declare function getRenderNodeExtension(node: Node): RenderNodeExtension | null;
+
 /** One graph-buffer range consumed by a storage binding. */
 interface ComputeBufferBinding {
     /** Frame-scoped graph buffer handle. */
@@ -12050,8 +11226,15 @@ interface SceneStorageBufferBinding {
  * explicit: it does not automatically rewrite built-in Basic/PBR shader source.
  */
 interface SceneStorageShaderVariant {
-    /** Storage-aware shader used by every direct mesh in this renderer list. */
+    /** Default storage-aware shader and the canonical pass-global storage ABI. */
     readonly shader: StorageGraphicsShader;
+    /**
+     * Optional exact per-mesh variants applied without splitting the renderer list. This preserves
+     * global transparent sorting while allowing geometry/material topology to select its compiled
+     * shader. Every mapped shader must expose the same group-three readonly-storage ABI as
+     * the default shader.
+     */
+    readonly shaderByMesh?: ReadonlyMap<Mesh, StorageGraphicsShader>;
     /** Positional ranges matching the shader's sorted readonly-storage binding order. */
     readonly buffers: readonly Readonly<SceneStorageBufferBinding>[];
 }
@@ -12845,6 +12028,11 @@ declare const semantic: {
         isDependMesh: boolean;
         notSupportInstanced: boolean;
     };
+    MODELLAYERPARAMS: {
+        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): Uint32Array;
+        isDependMesh: boolean;
+        notSupportInstanced: boolean;
+    };
     VIEW: {
         get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
     };
@@ -15830,6 +15018,6 @@ declare const math: {
     nextPowerOfTwo(value: number): number;
 };
 
-export { AmbientLight, Animation, AnimationStates, AreaLight, AtmosphereWeatherState, AutoExposure, AxisHelper, AxisNetHelper, BUILTIN_UNIFORM_BLOCK_BINDING_COUNT, BasicLoader, BasicMaterial, Bloom, BoxGeometry, Cache, Camera, Camera2D, CameraHelper, ClusteredForwardPlusPipelineFactory, Color, ColorUber, ComputeKernel, ComputeRenderPass, ComputeSampler, ComputeShader, CubeTexture, CubeTextureLoader, DEFAULT_2D_LAYER, DEFAULT_MATERIAL_PIPELINE_STATE, DEFAULT_MATERIAL_TEXTURE_CHANNELS, DataTexture, DirectionalLight, Euler, EulerNotifier, EventDispatcher, Fog, ForwardRenderPipelineFactory, Frustum, FullscreenRenderPass, GLTFExtensions_d as GLTFExtensions, GLTFLoader, GLTFParser, GPUDrivenRenderPass, Geometry, GeometryData, GeometryMaterial, GroundTruthAmbientOcclusion, HDRLoader, HiloEvent, KTXLoader, LazyTexture, Light, LightManager, LoadCache, LoadQueue, LoadState, Loader, LogLevel, Logger, MATERIAL_TEXTURE_SLOT_COUNT, MaterialAttributeSemantic, MaterialBlendPreset, MaterialCompiler, MaterialDefinition, MaterialInstance, MaterialTextureSemantic, MaterialTextureSlot, MaterialUniformSemantic, Matrix3, Matrix4, Matrix4Notifier, Mesh, MeshPicker, MorphGeometry, Node, OrbitControls, OrthographicCamera, PARTICLE_AUTHORING_JSON_SCHEMA, PARTICLE_AUTHORING_SCHEMA, PARTICLE_AUTHORING_VERSION, PARTICLE_BAKE_VERSION, PARTICLE_DEFINITION_SCHEMA, PARTICLE_DEFINITION_VERSION, PARTICLE_PREVIEW_PROTOCOL_VERSION, PARTICLE_SIMULATION_CACHE_VERSION, PBRMaterial, PBRMaterialBuilder, ParticleAuthoringPreviewController, ParticleBudgetManager, ParticleCurve, ParticleEmitterDefinition, ParticleEventChannel, ParticleGradient, ParticleParameter, ParticleParameterSet, ParticleSystem, ParticleSystemDefinition, ParticleSystemPool, PerspectiveCamera, Plane, PlaneGeometry, PointLight, PostProcessRenderPipelineFactory, PresentRenderPass, Quaternion, QuaternionNotifier, Ray, RenderInfo, RenderPassParameterPool, Renderer, SCENE_STORAGE_BIND_GROUP, STATE_TYPES, SceneRenderPass, ScreenSpaceGlobalIllumination, Shader, ShaderMaterial, ShaderMaterialLoader, ShadowRenderPass, Skeleton, SkinnedMesh, SlicedSprite, Sphere, SphereGeometry, SphericalHarmonics3, SpotLight, Sprite, SpriteFrame, SpriteMaterial, Stage, Std140Layout, StorageGraphicsShader, StorageLayout, TemporalAA, Text2D, Texture, TextureCopyPass, TextureLoader, Ticker, Tween, UNIFORM_BLOCK_BINDINGS, UiButton, UniformBuffer, Vector2, Vector3, Vector3Notifier, Vector4, WebGLSupport, analyzeParticleStatelessEligibility, browser, collectionEntries, compileParticleAuthoringGraph, compileParticleSystemDefinition, constants, createEmptyGLTFRoot, createParticleAuthoringGraph, createStd140Layout, createStorageLayout, deserializeParticleSystemDefinition, detectBrowserFeatures, detectWebGLSupport, Hilo as engineConstants, getCollectionItem, getUniformBlockBinding, isArrayCollection, isGLTFRoot, log, math, parseParticleSystemDefinitionJSON, parseRadianceHDR, particleStatelessBlockingDiagnostics, registerUniformBlockBinding, resolveMaterialPassDefinition, resolveMaterialPassState, semantic, serializeParticleSystemDefinition, util_d as util, version, webgl2 as webgl2Constants, webgl as webglConstants, webglExtensions as webglExtensionConstants };
-export type { AccessorArray, AmbientLightParameters, AnimationClip, AnimationInterpolationType, AnimationParameters, AnimationStateHandler, AnimationStateType, AnimationStatesParameters, AnimationTimeRange, AreaLightInfo, AreaLightParameters, AtmosphereWeatherDebugView, AtmosphereWeatherOptions, AtmosphereWeatherQuality, AutoExposureDiagnostics, AutoExposureMeteringMode, AutoExposureOptions, AxisAlignedBox, AxisHelperParameters, AxisNetHelperParameters, BackEaseObject, BasicLightType, BasicLoadRequest, BasicLoaderResource, BasicMaterialParameters, BasicResource, BasicResourceType, BloomOptions, Bounds, BoxGeometryParameters, BrowserFeatures, BuiltInAnimationStateType, BuiltInMaterialTextureSlotName, Camera2DParameters, CameraDepthMode, CameraHelperParameters, CameraParameters, ClusteredForwardPlusDiagnostics, ClusteredForwardPlusPipelineOptions, ColorUberOptions, ComputeBufferBinding, ComputeDispatch, ComputeKernelDescriptor, ComputePipelineConstant, ComputeRenderPassParameters, ComputeSamplerAddressMode, ComputeSamplerDescriptor, ComputeSamplerFilterMode, ComputeShaderBinding, ComputeShaderDescriptor, ComputeStorageBufferAccess, ComputeStorageTextureFormat, ComputeStorageTextureViewDimension, ComputeTextureBinding, ComputeTextureSampleType, ComputeTextureViewDimension, ComputeUniformBufferBinding, CubeTextureImage, CubeTextureLoadRequest, CubeTextureParameters, CullingOptions, CullingResultsHandle, DataTextureParameters, DirectionalLightInfo, DirectionalLightParameters, DirectionalLightShadowOptions, DispatchEvent, DynamicResolutionDiagnostics, DynamicResolutionOptions, ElasticEaseObject, EulerOrder, EventListener, FogMode, FogParameters, ForwardRenderFeatureContext, ForwardRenderFeatureRequirements, ForwardRenderInjectionPoint, ForwardRenderPipelineFactoryOptions, ForwardRenderPipelineFeature, ForwardRenderPipelineFeatureRuntime, ForwardRenderPipelineResources, FullscreenRenderPassOptions, FullscreenRenderPassParameters, GLTFAccessor, GLTFAccessorResult, GLTFAccessorType, GLTFAnimation, GLTFAnimationChannel, GLTFAnimationClipsExtension, GLTFAnimationSampler, GLTFAnimationTarget, GLTFAnisotropyExtension, GLTFAsset, GLTFBoundingBoxExtension, GLTFBounds, GLTFBuffer, GLTFBufferView, GLTFBufferViewRuntime, GLTFCamera, GLTFClearcoatExtension, GLTFCollection, GLTFComponentType, GLTFExtensionHandler, GLTFExtensionHandlerRegistry, GLTFExtensionMap, GLTFExtensionMethodName, GLTFExtensionOptions, GLTFImage, GLTFIndex, GLTFIorExtension, GLTFIridescenceExtension, GLTFLoadRequest, GLTFMaterial, GLTFMaterialValue, GLTFMaterialsCommonExtension, GLTFMesh, GLTFModel, GLTFMorphTarget, GLTFNode, GLTFOrthographicCamera, GLTFPBRMetallicRoughness, GLTFPBRSpecularGlossinessExtension, GLTFParserParameters, GLTFPerspectiveCamera, GLTFPrimitive, GLTFProgram, GLTFProgressivePrimitiveState, GLTFProperty, GLTFPunctualLight, GLTFPunctualLightNodeExtension, GLTFPunctualLightsExtension, GLTFPunctualSpotLight, GLTFQuantizedAttributesExtension, GLTFResourceLoader, GLTFRoot, GLTFSampler, GLTFScene, GLTFShader, GLTFSkin, GLTFSparseAccessor, GLTFSparseIndices, GLTFSparseValues, GLTFTechnique, GLTFTechniqueBinding, GLTFTechniqueStates, GLTFTexture, GLTFTextureInfo, GLTFTextureTransformExtension, GLTFTransmissionExtension, GLTFVolumeExtension, GPUDrivenDraw, GPUDrivenRenderPassOptions, GPUDrivenRenderPassParameters, GPUDrivenVertexAttribute, GPUDrivenVertexBufferLayout, GPUDrivenVertexFormat, GPUSceneBucket, GPUSceneLOD, GeometryAttributeValue, GeometryComponentSize, GeometryDataComponentCallback, GeometryDataLike, GeometryDataParameters, GeometryDataTraverseCallback, GeometryMaterialParameters, GeometryParameters, GeometryVertexType, GroundTruthAmbientOcclusionOptions, HDRLoadRequest, ImageCrossOrigin, InstancedUniform, InterpolatedValue, InterpolationFunction, JsonPrimitive, JsonValue, KTXLoadRequest, KTXTextureOptions, LazyTextureParameters, LightGroupName, LightInfo, LightManagerParameters, LightParameters, LightShadowOptions, ListenerEntry, ListenerMap, LoadCacheFile, LoadQueueItem, LoadQueueSource, LoadStateValue, LoaderRequest, LoaderTextureOptions, LogLevelValue, MaterialAttributeSemanticName, MaterialBinding, MaterialBindingInfo, MaterialBindingMap, MaterialBlendComponent, MaterialBlendFactor, MaterialBlendOperation, MaterialBlendState, MaterialColorOrTextureInput, MaterialCompareFunction, MaterialCompileRequest, MaterialCompositing, MaterialCoverage, MaterialCullMode, MaterialDefinitionParameters, MaterialFamily, MaterialFragmentOutput, MaterialFrontFace, MaterialInstanceParameters, MaterialPassDefinition, MaterialPassFallback, MaterialPassRole, MaterialPipelineState, MaterialRenderingProfile, MaterialSemanticName, MaterialShaderModule, MaterialStencilFaceState, MaterialStencilOperation, MaterialStencilState, MaterialSurfaceDomain, MaterialTargetSignature, MaterialTexture, MaterialTextureChannel, MaterialTextureEncoding, MaterialTextureSemanticName, MaterialTextureSlotBinding, MaterialTextureSlotDefinition, MaterialTextureSlotInput, MaterialTextureValue, MaterialUniformSemanticName, MeshParameters, MeshPickerParameters, MorphGeometryParameters, MorphTargets, MutableArrayLike, MutableNumberArray, MutablePBRMaterialParameters, NetworkResourceType, NodeGetChildByCallback, NodeParameters, NodePointerEvent, NodeRaycastInfo, NodeTraverseCallback, NodeTraverseResult, NormalizedComputeWorkgroupSize, OrbitControlsOptions, OrthographicCameraParameters, PBRMaterialParameters, PBRMaterialTextureInput, ParticleAdvancedQualityPlan, ParticleAdvancedSurfaceDefinition, ParticleAnalyticCollider, ParticleAttractionModule, ParticleAttributeLayout, ParticleAttributeName, ParticleAuthoringCompileFailure, ParticleAuthoringCompileOptions, ParticleAuthoringCompileResult, ParticleAuthoringCompileSuccess, ParticleAuthoringDiagnostic, ParticleAuthoringEdge, ParticleAuthoringEmitterIR, ParticleAuthoringGraph, ParticleAuthoringIR, ParticleAuthoringNode, ParticleAuthoringNodeKind, ParticleAuthoringPort, ParticleAuthoringPreviewCommand, ParticleAuthoringPreviewCompileRequest, ParticleAuthoringPreviewControlRequest, ParticleAuthoringPreviewControllerOptions, ParticleAuthoringPreviewRequest, ParticleAuthoringPreviewResponse, ParticleAuthoringPreviewSeekRequest, ParticleAuthoringPreviewState, ParticleAuthoringPreviewStepRequest, ParticleAuthoringPreviewSystemFactory, ParticleAutomaticBounds, ParticleBakeTimelineOptions, ParticleBakedMeshEmitter, ParticleBoundsDefinition, ParticleBoxCollider, ParticleBoxShape, ParticleBudgetDecision, ParticleBudgetProfile, ParticleBudgetRequest, ParticleBurstDefinition, ParticleBySpeedModule, ParticleCameraModule, ParticleCapsuleCollider, ParticleCircleShape, ParticleCollisionModule, ParticleColor, ParticleColorBySpeedModule, ParticleColorOverLifetimeModule, ParticleColorSource, ParticleColorValue, ParticleCompilationEnvironment, ParticleCompiledEmitterPlan, ParticleCompiledPlan, ParticleCompositionMode, ParticleConeShape, ParticleConformSphereModule, ParticleCullingReaction, ParticleCurveInterpolation, ParticleCurveKeyframe, ParticleCurveLUT, ParticleCurveOptions, ParticleCurveWrapMode, ParticleCustomChannelModule, ParticleDefinitionDeserializationOptions, ParticleDefinitionJSONParameter, ParticleDefinitionJSONRecord, ParticleDefinitionJSONValue, ParticleDefinitionResource, ParticleDefinitionResourceKind, ParticleDefinitionSerializationOptions, ParticleDefinitionUpgrade, ParticleDragModule, ParticleDynamicBounds, ParticleEmissionDefinition, ParticleEmitterDefinitionInput, ParticleEventAggregate, ParticleEventChannelParameters, ParticleEventChannelPayload, ParticleEventChannelSchema, ParticleEventFieldType, ParticleEventFieldValue, ParticleEventOverflowPolicy, ParticleEventRecord, ParticleExecutionMode, ParticleFlipbook, ParticleFlipbookFrameContext, ParticleFlipbookOptions, ParticleForceModule, ParticleGradientKey, ParticleGradientLUT, ParticleInheritVelocityModule, ParticleInitializeDefinition, ParticleKillModule, ParticleKillVolumeModule, ParticleLifetimeByEmitterSpeedModule, ParticleLightingMode, ParticleLimitVelocityModule, ParticleLineShape, ParticleManualBounds, ParticleMeshAsset, ParticleMeshCache, ParticleMeshCacheOptions, ParticleMeshRendererDefinition, ParticleModule, ParticleNoiseModule, ParticleOverflowPolicy, ParticleParameterType, ParticleParameterValue, ParticlePlaneCollider, ParticlePointShape, ParticleRadialForceModule, ParticleRange, ParticleRendererDefinition, ParticleRibbonRendererDefinition, ParticleRotateAroundPointModule, ParticleScalarBySpeedModule, ParticleScalarOverLifetimeModule, ParticleScalarSource, ParticleScalarValue, ParticleSceneDepthCollisionModule, ParticleShapeBase, ParticleShapeDefinition, ParticleSimulationCache, ParticleSimulationSpace, ParticleSortMode, ParticleSphereCollider, ParticleSphereShape, ParticleSpriteAlignment, ParticleSpriteRendererDefinition, ParticleStatelessModuleMetadata, ParticleStatelessSupport, ParticleSubEmitterModule, ParticleSurfaceCoverage, ParticleSystemDefinitionInput, ParticleSystemDefinitionJSON, ParticleSystemEmitCommand, ParticleSystemParameters, ParticleSystemSimulateOptions, ParticleTextureSheetModule, ParticleTorusShape, ParticleTriggerModule, ParticleVector2, ParticleVector3, ParticleVector3Source, ParticleVector3Value, ParticleVector4, ParticleVectorFieldModule, ParticleVelocityModule, PerspectiveCameraParameters, PhysicalAtmosphereOptions, PlaneGeometryParameters, Point2, Point3, PointLightInfo, PointLightParameters, PointLightShadowOptions, PointShadowCameraParameters, PostProcessRenderPipelineOptions, PreparedMaterialVariant, ProgramBindingInfo, RGPassTimestampKind, RadianceHDRImage, RayCamera, RayParameters, RenderColorEncoding, RenderGraphBufferHandle, RenderGraphBufferReadUse, RenderGraphBufferWriteUse, RenderGraphFramePlan, RenderGraphGPUTimelineStatus, RenderGraphPassHandle, RenderGraphPassTimelineSnapshot, RenderGraphResourceLifetimeSnapshot, RenderGraphTextureAccessHandle, RenderGraphTextureHandle, RenderGraphTextureViewHandle, RenderGraphTimelineSnapshot, RenderPassParameterFactory, RenderPassParameterReset, RenderPipeline, RenderPipelineBufferDescriptor, RenderPipelineCapabilities, RenderPipelineCapabilityName, RenderPipelineColorAttachment, RenderPipelineContext, RenderPipelineCreateContext, RenderPipelineDepthStencilAttachment, RenderPipelineExtent, RenderPipelineFactory, RenderPipelineHistoryTextureDescriptor, RenderPipelineHistoryTextureResources, RenderPipelineLimits, RenderPipelineOutput, RenderPipelineOutputColorAttachment, RenderPipelineOutputDepthStencilAttachment, RenderPipelineOutputResources, RenderPipelinePersistentTargetDescriptor, RenderPipelinePersistentTextureUsage, RenderPipelineRequirements, RenderPipelineShadowResources, RenderPipelineTargetResources, RenderPipelineTextureAspect, RenderPipelineTextureDescriptor, RenderPipelineTextureDimension, RenderPipelineTextureFormat, RenderPipelineTextureRequirement, RenderPipelineTextureUse, RenderPipelineTextureViewDescriptor, RenderPipelineTextureViewDimension, RenderTarget, RenderTargetColor, RenderTargetColorAttachmentOptions, RenderTargetColorAttachmentReadback, RenderTargetColorFormat, RenderTargetCompareFunction, RenderTargetDepthStencilAttachmentOptions, RenderTargetDepthStencilFormat, RenderTargetLoadOp, RenderTargetParameters, RenderTargetPresentationOptions, RenderTargetReadColorAttachmentOptions, RenderTargetSampleCount, RenderTargetSelectionOptions, RenderTargetStoreOp, RendererAdapterPowerPreference, RendererAutoOptions, RendererBackend, RendererCommonOptions, RendererContextPowerPreference, RendererContract, RendererCreateOptions, RendererExplicitOptions, RendererFeatureName, RendererFrame, RendererFrameCallback, RendererListDescriptor, RendererListHandle, RendererListQueue, RendererListSorting, RendererOptions, RendererOptionsMap, RendererRenderingProfile, RendererResourceDiagnostics, RendererResourceManager, RendererScene, RendererSupportOptions, RendererViewport, RendererWebGL2Options, RendererWebGPUOptions, ResizableTextureImage, Resource, ResourceLoader, ResourceLoaderConstructor, ResourceRequestOptions, SceneRenderPassParameters, SceneStorageBufferBinding, SceneStorageShaderVariant, ScreenSpaceGlobalIlluminationOptions, ScreenSpaceReflectionsOptions, ScriptableRenderCommands, ScriptableRenderGraph, ScriptableRenderPass, ScriptableRenderPassBuilder, ScriptableRenderPassContext, ScriptableRenderPrepareContext, SemanticMaterial, SemanticMesh, SemanticRenderer, ShaderDefineValue, ShaderMaterialLoadRequest, ShaderMaterialParameters, ShaderMaterialRoleSource, ShaderMaterialTextureSlot, ShaderOptions, ShaderParameters, ShaderPrecision, ShaderPrecisionProvider, ShaderReadBinding, ShaderRenderer, ShaderTextureSampleType, ShaderTextureViewDimension, ShadowCameraParameters, ShadowCastingLightParameters, ShadowRenderPassParameters, Size, SkeletonParameters, SkinnedMeshParameters, SlicedSpriteInsets, SlicedSpriteParameters, SphereGeometryParameters, SpotLightInfo, SpotLightParameters, SpriteFrameParameters, SpriteFrameUpdateOptions, SpriteFramesUpdateOptions, SpriteMaterialParameters, SpriteParameters, StageBackend, StageBackendParameters, StageCommonParameters, StageParameters, StagePointerEvent, Std140ArrayValue, Std140FieldDefinition, Std140FieldLayout, Std140FieldValue, Std140MatrixType, Std140ScalarType, Std140Schema, Std140Type, Std140Value, Std140Values, Std140VectorType, StorageArrayDefinition, StorageBuffer, StorageBufferDescriptor, StorageBufferRange, StorageBufferReadback, StorageBufferRecoveryPolicy, StorageBufferUsage, StorageFieldLayout, StorageGraphicsShaderDescriptor, StorageMatrixType, StoragePrimitiveType, StoragePrimitiveValue, StorageScalarType, StorageSchema, StorageStructDefinition, StorageType, StorageValue, StorageValues, StorageVectorType, StorageWriteResult, SubDataUpdate, TemporalAAOptions, Text2DParameters, Text2DStyle, TextureBinding, TextureCompressionFormat, TextureCopyPassParameters, TextureCubeFace, TextureImageSource, TextureLoadRequest, TextureMipmap, TextureParameters, TexturePixelData, TextureSource, TextureSubImage, TextureUVChannel, TextureUpdateSnapshot, Tickable, ToneMappingMode, Triangle, TweenCompleteCallback, TweenEaseCollection, TweenEaseFunction, TweenEaseNoneObject, TweenEaseObject, TweenParameters, TweenProperties, TweenStartCallback, TweenUpdateCallback, TypedArray$1 as TypedArray, TypedArrayConstructor$1 as TypedArrayConstructor, UV, UiButtonFrames, UiButtonParameters, UiButtonState, UniformBufferDirtyRange, UniformBufferRange, VolumetricBoxFogVolume, VolumetricCloudOptions, VolumetricFogVolume, VolumetricLightingDebugView, VolumetricLightingOptions, VolumetricLightingQuality, VolumetricSphereFogVolume, XYZObject };
+export { AmbientLight, Animation, AnimationStates, AreaLight, AtmosphereWeatherState, AutoExposure, AxisHelper, AxisNetHelper, BUILTIN_UNIFORM_BLOCK_BINDING_COUNT, BasicLoader, BasicMaterial, Bloom, BoxGeometry, Cache, Camera, Camera2D, CameraHelper, ClusteredForwardPlusPipelineFactory, Color, ColorUber, ComputeKernel, ComputeRenderPass, ComputeSampler, ComputeShader, CubeTexture, CubeTextureLoader, DEFAULT_2D_LAYER, DEFAULT_MATERIAL_PIPELINE_STATE, DEFAULT_MATERIAL_TEXTURE_CHANNELS, DataTexture, DirectionalLight, Euler, EulerNotifier, EventDispatcher, Fog, ForwardRenderPipelineFactory, Frustum, FullscreenRenderPass, GLTFExtensions_d as GLTFExtensions, GLTFLoader, GLTFParser, GPUDrivenRenderPass, Geometry, GeometryData, GeometryMaterial, GroundTruthAmbientOcclusion, HDRLoader, HiloEvent, KTXLoader, LazyTexture, Light, LightManager, LoadCache, LoadQueue, LoadState, Loader, LogLevel, Logger, MATERIAL_TEXTURE_SLOT_COUNT, MaterialAttributeSemantic, MaterialBlendPreset, MaterialCompiler, MaterialDefinition, MaterialInstance, MaterialTextureSemantic, MaterialTextureSlot, MaterialUniformSemantic, Matrix3, Matrix4, Matrix4Notifier, Mesh, MeshPicker, MorphGeometry, Node, OrbitControls, OrthographicCamera, PBRMaterial, PBRMaterialBuilder, PerspectiveCamera, Plane, PlaneGeometry, PointLight, PostProcessRenderPipelineFactory, PresentRenderPass, Quaternion, QuaternionNotifier, RENDER_NODE_EXTENSION, Ray, RenderInfo, RenderPassParameterPool, Renderer, SCENE_STORAGE_BIND_GROUP, STAGE_SYSTEM_API_VERSION, STATE_TYPES, SceneRenderPass, ScreenSpaceGlobalIllumination, Shader, ShaderMaterial, ShaderMaterialLoader, ShadowRenderPass, Skeleton, SkinnedMesh, SlicedSprite, Sphere, SphereGeometry, SphericalHarmonics3, SpotLight, Sprite, SpriteFrame, SpriteMaterial, Stage, StageSystemRegistry, StageSystemService, Std140Layout, StorageGraphicsShader, StorageLayout, TRIANGLES, TemporalAA, Text2D, Texture, TextureCopyPass, TextureLoader, Ticker, Tween, UNIFORM_BLOCK_BINDINGS, UiButton, UniformBuffer, Vector2, Vector3, Vector3Notifier, Vector4, WebGLSupport, browser, collectionEntries, constants, createEmptyGLTFRoot, createStageSystemService, createStd140Layout, createStorageGraphicsShaderFromPortable, createStorageLayout, detectBrowserFeatures, detectWebGLSupport, Hilo as engineConstants, getCollectionItem, getRenderNodeExtension, getUniformBlockBinding, isArrayCollection, isGLTFRoot, log, math, parseRadianceHDR, registerUniformBlockBinding, resolveMaterialPassDefinition, resolveMaterialPassState, semantic, util_d as util, version, webgl2 as webgl2Constants, webgl as webglConstants, webglExtensions as webglExtensionConstants };
+export type { AccessorArray, AmbientLightParameters, AnimationClip, AnimationInterpolationType, AnimationParameters, AnimationStateHandler, AnimationStateType, AnimationStatesParameters, AnimationTimeRange, AreaLightInfo, AreaLightParameters, AtmosphereWeatherDebugView, AtmosphereWeatherOptions, AtmosphereWeatherQuality, AutoExposureDiagnostics, AutoExposureMeteringMode, AutoExposureOptions, AxisAlignedBox, AxisHelperParameters, AxisNetHelperParameters, BackEaseObject, BasicLightType, BasicLoadRequest, BasicLoaderResource, BasicMaterialParameters, BasicResource, BasicResourceType, BloomOptions, Bounds, BoxGeometryParameters, BrowserFeatures, BuiltInAnimationStateType, BuiltInMaterialTextureSlotName, Camera2DParameters, CameraDepthMode, CameraHelperParameters, CameraParameters, ClusteredForwardPlusDiagnostics, ClusteredForwardPlusPipelineOptions, ClusteredMaterialVariantManifest, ClusteredMaterialVariantManifestEntry, ColorUberOptions, ComputeBufferBinding, ComputeDispatch, ComputeKernelDescriptor, ComputePipelineConstant, ComputeRenderPassParameters, ComputeSamplerAddressMode, ComputeSamplerDescriptor, ComputeSamplerFilterMode, ComputeShaderBinding, ComputeShaderDescriptor, ComputeStorageBufferAccess, ComputeStorageTextureFormat, ComputeStorageTextureViewDimension, ComputeTextureBinding, ComputeTextureSampleType, ComputeTextureViewDimension, ComputeUniformBufferBinding, CubeTextureImage, CubeTextureLoadRequest, CubeTextureParameters, CullingOptions, CullingResultsHandle, DataTextureParameters, DirectionalLightInfo, DirectionalLightParameters, DirectionalLightShadowOptions, DispatchEvent, DynamicResolutionDiagnostics, DynamicResolutionOptions, ElasticEaseObject, EulerOrder, EventListener, FogMode, FogParameters, ForwardRenderFeatureContext, ForwardRenderFeatureRequirements, ForwardRenderInjectionPoint, ForwardRenderPipelineFactoryOptions, ForwardRenderPipelineFeature, ForwardRenderPipelineFeatureRuntime, ForwardRenderPipelineResources, FullscreenRenderPassOptions, FullscreenRenderPassParameters, GLTFAccessor, GLTFAccessorResult, GLTFAccessorType, GLTFAnimation, GLTFAnimationChannel, GLTFAnimationClipsExtension, GLTFAnimationSampler, GLTFAnimationTarget, GLTFAnisotropyExtension, GLTFAsset, GLTFBoundingBoxExtension, GLTFBounds, GLTFBuffer, GLTFBufferView, GLTFBufferViewRuntime, GLTFCamera, GLTFClearcoatExtension, GLTFCollection, GLTFComponentType, GLTFExtensionHandler, GLTFExtensionHandlerRegistry, GLTFExtensionMap, GLTFExtensionMethodName, GLTFExtensionOptions, GLTFImage, GLTFIndex, GLTFIorExtension, GLTFIridescenceExtension, GLTFLoadRequest, GLTFMaterial, GLTFMaterialValue, GLTFMaterialsCommonExtension, GLTFMesh, GLTFModel, GLTFMorphTarget, GLTFNode, GLTFOrthographicCamera, GLTFPBRMetallicRoughness, GLTFPBRSpecularGlossinessExtension, GLTFParserParameters, GLTFPerspectiveCamera, GLTFPrimitive, GLTFProgram, GLTFProgressivePrimitiveState, GLTFProperty, GLTFPunctualLight, GLTFPunctualLightNodeExtension, GLTFPunctualLightsExtension, GLTFPunctualSpotLight, GLTFQuantizedAttributesExtension, GLTFResourceLoader, GLTFRoot, GLTFSampler, GLTFScene, GLTFShader, GLTFSkin, GLTFSparseAccessor, GLTFSparseIndices, GLTFSparseValues, GLTFTechnique, GLTFTechniqueBinding, GLTFTechniqueStates, GLTFTexture, GLTFTextureInfo, GLTFTextureTransformExtension, GLTFTransmissionExtension, GLTFVolumeExtension, GPUDrivenDraw, GPUDrivenRenderPassOptions, GPUDrivenRenderPassParameters, GPUDrivenVertexAttribute, GPUDrivenVertexBufferLayout, GPUDrivenVertexFormat, GPUSceneBucket, GPUSceneLOD, GeometryAttributeValue, GeometryComponentSize, GeometryDataComponentCallback, GeometryDataLike, GeometryDataParameters, GeometryDataTraverseCallback, GeometryMaterialParameters, GeometryParameters, GeometryVertexType, GroundTruthAmbientOcclusionNormalSource, GroundTruthAmbientOcclusionOptions, GroundTruthAmbientOcclusionQuality, HDRLoadRequest, ImageCrossOrigin, InstancedUniform, InterpolatedValue, InterpolationFunction, JsonPrimitive, JsonValue, KTXLoadRequest, KTXTextureOptions, LazyTextureParameters, LightGroupName, LightInfo, LightManagerParameters, LightParameters, LightShadowOptions, ListenerEntry, ListenerMap, LoadCacheFile, LoadQueueItem, LoadQueueSource, LoadStateValue, LoaderRequest, LoaderTextureOptions, LogLevelValue, MaterialAttributeSemanticName, MaterialBinding, MaterialBindingInfo, MaterialBindingMap, MaterialBlendComponent, MaterialBlendFactor, MaterialBlendOperation, MaterialBlendState, MaterialColorOrTextureInput, MaterialCompareFunction, MaterialCompileRequest, MaterialCompositing, MaterialCoverage, MaterialCullMode, MaterialDefinitionParameters, MaterialFamily, MaterialFragmentOutput, MaterialFrontFace, MaterialInstanceParameters, MaterialPassDefinition, MaterialPassFallback, MaterialPassRole, MaterialPipelineState, MaterialRenderingProfile, MaterialSemanticName, MaterialShaderModule, MaterialStencilFaceState, MaterialStencilOperation, MaterialStencilState, MaterialSurfaceDomain, MaterialTargetSignature, MaterialTexture, MaterialTextureChannel, MaterialTextureEncoding, MaterialTextureSemanticName, MaterialTextureSlotBinding, MaterialTextureSlotDefinition, MaterialTextureSlotInput, MaterialTextureValue, MaterialUniformSemanticName, MeshParameters, MeshPickerParameters, MorphGeometryParameters, MorphTargets, MutableArrayLike, MutableNumberArray, MutablePBRMaterialParameters, NetworkResourceType, NodeGetChildByCallback, NodeParameters, NodePointerEvent, NodeRaycastInfo, NodeTraverseCallback, NodeTraverseResult, NormalizedComputeWorkgroupSize, OrbitControlsOptions, OrthographicCameraParameters, PBRMaterialParameters, PBRMaterialTextureInput, PerspectiveCameraParameters, PhysicalAtmosphereOptions, PlaneGeometryParameters, Point2, Point3, PointLightInfo, PointLightParameters, PointLightShadowOptions, PointShadowCameraParameters, PostProcessRenderPipelineOptions, PreparedMaterialVariant, ProgramBindingInfo, RGPassTimestampKind, RadianceHDRImage, RayCamera, RayParameters, RenderColorEncoding, RenderGraphBufferHandle, RenderGraphBufferReadUse, RenderGraphBufferWriteUse, RenderGraphFramePlan, RenderGraphGPUTimelineStatus, RenderGraphPassHandle, RenderGraphPassTimelineSnapshot, RenderGraphResourceLifetimeSnapshot, RenderGraphTextureAccessHandle, RenderGraphTextureHandle, RenderGraphTextureViewHandle, RenderGraphTimelineSnapshot, RenderNodeExtension, RenderNodeGPUExtension, RenderPassParameterFactory, RenderPassParameterReset, RenderPipeline, RenderPipelineBufferDescriptor, RenderPipelineCapabilities, RenderPipelineCapabilityName, RenderPipelineColorAttachment, RenderPipelineContext, RenderPipelineCreateContext, RenderPipelineDepthStencilAttachment, RenderPipelineExtent, RenderPipelineFactory, RenderPipelineHistoryTextureDescriptor, RenderPipelineHistoryTextureResources, RenderPipelineLimits, RenderPipelineOutput, RenderPipelineOutputColorAttachment, RenderPipelineOutputDepthStencilAttachment, RenderPipelineOutputResources, RenderPipelinePersistentTargetDescriptor, RenderPipelinePersistentTextureUsage, RenderPipelineRequirements, RenderPipelineShadowOptions, RenderPipelineShadowPageRegion, RenderPipelineShadowResources, RenderPipelineShadowSlice, RenderPipelineTargetResources, RenderPipelineTextureAspect, RenderPipelineTextureDescriptor, RenderPipelineTextureDimension, RenderPipelineTextureFormat, RenderPipelineTextureRequirement, RenderPipelineTextureUse, RenderPipelineTextureViewDescriptor, RenderPipelineTextureViewDimension, RenderTarget, RenderTargetColor, RenderTargetColorAttachmentOptions, RenderTargetColorAttachmentReadback, RenderTargetColorFormat, RenderTargetCompareFunction, RenderTargetDepthStencilAttachmentOptions, RenderTargetDepthStencilFormat, RenderTargetLoadOp, RenderTargetParameters, RenderTargetPresentationOptions, RenderTargetReadColorAttachmentOptions, RenderTargetSampleCount, RenderTargetSelectionOptions, RenderTargetStoreOp, RendererAdapterPowerPreference, RendererAutoOptions, RendererBackend, RendererCommonOptions, RendererContextPowerPreference, RendererContract, RendererCreateOptions, RendererExplicitOptions, RendererFeatureName, RendererFrame, RendererFrameCallback, RendererListDescriptor, RendererListHandle, RendererListQueue, RendererListSorting, RendererOptions, RendererOptionsMap, RendererRenderingProfile, RendererResourceDiagnostics, RendererResourceManager, RendererScene, RendererShadowUpdateMode, RendererSupportOptions, RendererViewport, RendererWebGL2Options, RendererWebGPUOptions, ResizableTextureImage, Resource, ResourceLoader, ResourceLoaderConstructor, ResourceRequestOptions, SceneRenderPassParameters, SceneStorageBufferBinding, SceneStorageShaderVariant, ScreenSpaceGlobalIlluminationOptions, ScreenSpaceReflectionsOptions, ScriptableRenderCommands, ScriptableRenderGraph, ScriptableRenderPass, ScriptableRenderPassBuilder, ScriptableRenderPassContext, ScriptableRenderPrepareContext, SemanticMaterial, SemanticMesh, SemanticRenderer, ShaderDefineValue, ShaderMaterialLoadRequest, ShaderMaterialParameters, ShaderMaterialRoleSource, ShaderMaterialTextureSlot, ShaderOptions, ShaderParameters, ShaderPrecision, ShaderPrecisionProvider, ShaderReadBinding, ShaderRenderer, ShaderTextureSampleType, ShaderTextureViewDimension, ShadowCameraParameters, ShadowCastingLightParameters, ShadowRenderPassParameters, Size, SkeletonParameters, SkinnedMeshParameters, SlicedSpriteInsets, SlicedSpriteParameters, SphereGeometryParameters, SpotLightCookie, SpotLightIESProfile, SpotLightInfo, SpotLightParameters, SpriteFrameParameters, SpriteFrameUpdateOptions, SpriteFramesUpdateOptions, SpriteMaterialParameters, SpriteParameters, StageBackend, StageBackendParameters, StageCommonParameters, StageParameters, StagePointerEvent, StageSystem, StageSystemDescriptor, StageSystemRuntime, StageSystemSetupContext, Std140ArrayValue, Std140FieldDefinition, Std140FieldLayout, Std140FieldValue, Std140MatrixType, Std140ScalarType, Std140Schema, Std140Type, Std140Value, Std140Values, Std140VectorType, StorageArrayDefinition, StorageBuffer, StorageBufferDescriptor, StorageBufferRange, StorageBufferReadback, StorageBufferRecoveryPolicy, StorageBufferUsage, StorageFieldLayout, StorageGraphicsShaderDescriptor, StorageMatrixType, StoragePrimitiveType, StoragePrimitiveValue, StorageScalarType, StorageSchema, StorageStructDefinition, StorageType, StorageValue, StorageValues, StorageVectorType, StorageWriteResult, SubDataUpdate, TemporalAAOptions, Text2DParameters, Text2DStyle, TextureBinding, TextureCompressionFormat, TextureCopyPassParameters, TextureCubeFace, TextureImageSource, TextureLoadRequest, TextureMipmap, TextureParameters, TexturePixelData, TextureSource, TextureSubImage, TextureUVChannel, TextureUpdateSnapshot, Tickable, ToneMappingMode, Triangle, TweenCompleteCallback, TweenEaseCollection, TweenEaseFunction, TweenEaseNoneObject, TweenEaseObject, TweenParameters, TweenProperties, TweenStartCallback, TweenUpdateCallback, TypedArray$1 as TypedArray, TypedArrayConstructor$1 as TypedArrayConstructor, UV, UiButtonFrames, UiButtonParameters, UiButtonState, UniformBufferDirtyRange, UniformBufferRange, VirtualShadowMapDiagnostics, VirtualShadowMapOptions, VolumetricBoxFogVolume, VolumetricCloudOptions, VolumetricFogVolume, VolumetricLightingDebugView, VolumetricLightingOptions, VolumetricLightingQuality, VolumetricSphereFogVolume, XYZObject };
 //# sourceMappingURL=Hilo3d.d.ts.map