@babylonjs/lite 0.1.1

package/index.d.ts

@@ -0,0 +1,4611 @@
+/** Add an agent to the crowd. Returns the agent index. */
+export declare function addAgent(crowd: NavCrowd, position: Vec3, params: AgentParameters): number;
+
+/** Attaches `group` to `manager` so it is ticked each update, creating its backing animation task on first use.
+ *  @param manager - Animation manager that will own and drive the group.
+ *  @param group - Animation group to attach.
+ *  @throws If the group is already attached to a different manager. */
+export declare function addAnimationGroup(manager: AnimationManager, group: AnimationGroup): void;
+
+/** Attaches each group in `groups` to `manager` via {@link addAnimationGroup}. */
+export declare function addAnimationGroups(manager: AnimationManager, groups: readonly AnimationGroup[]): void;
+
+/** Attaches `task` to `manager` and marks it active.
+ *  @throws If the task is already attached to a different manager. */
+export declare function addAnimationTask(manager: AnimationManager, task: AnimationTask): void;
+
+/**
+ * Adds an axis-locked billboard sprite system to the scene so it is rendered each frame.
+ * @param scene - Scene that will own and draw the system.
+ * @param system - Axis-locked billboard system to register.
+ */
+export declare function addAxisLockedBillboardSystem(scene: SceneContext, system: AxisLockedBillboardSpriteSystem): void;
+
+/**
+ * Adds a billboard sprite to the system and returns a stable handle to it.
+ * @param system - Billboard system to add the sprite to.
+ * @param init - Initial sprite properties.
+ * @returns A handle that stays valid as sprites are added and removed.
+ */
+export declare function addBillboardSprite(system: BillboardSpriteSystem, init: BillboardSpriteInit): BillboardSpriteHandle;
+
+/**
+ * Appends a billboard sprite to the system and returns its instance index.
+ * @param system - Billboard system to add to.
+ * @param props - Sprite properties; `position` and `sizeWorld` are required.
+ * @returns The new sprite's instance index.
+ * @throws If `position` or `sizeWorld` is missing.
+ */
+export declare function addBillboardSpriteIndex(system: BillboardSpriteSystem, props: BillboardSpriteInit): number;
+
+/**
+ * Add a box obstacle to a tile-cache navmesh. The navmesh must have been
+ * built with `maxObstacles > 0`. The tile cache is fully updated before
+ * returning (matching BJS Addons default behavior).
+ *
+ * @param halfExtents - box half-size on each axis
+ * @param angle - rotation around the Y axis, in radians
+ */
+export declare function addBoxObstacle(plugin: NavigationPlugin, position: Vec3, halfExtents: Vec3, angle: number): ObstacleHandle | null;
+
+/**
+ * Add a cylinder obstacle to a tile-cache navmesh.
+ *
+ * @param radius - cylinder radius
+ * @param height - cylinder height
+ */
+export declare function addCylinderObstacle(plugin: NavigationPlugin, position: Vec3, radius: number, height: number): ObstacleHandle | null;
+
+/**
+ * Add a depth-hosted Sprite2D layer to a SceneContext via the scene's optional
+ * renderable extension hook. Pure HUD layers (`depth: "none"`) are rendered by
+ * `createSpriteRenderer + registerSpriteRenderer` instead.
+ */
+export declare function addDepthHostedSpriteLayer(scene: SceneContext, layer: Sprite2DLayer): void;
+
+/**
+ * Adds a camera-facing billboard sprite system to the scene so it is rendered each frame.
+ * @param scene - Scene that will own and draw the system.
+ * @param system - Facing billboard system to register.
+ */
+export declare function addFacingBillboardSystem(scene: SceneContext, system: FacingBillboardSpriteSystem): void;
+
+/** Add one or more render-target dependencies to the pass. Idempotent
+ *  (Set semantics). Mirrors BJS `FrameGraphRenderPass.addDependencies`,
+ *  promoted onto the base `Pass` because every future pass type
+ *  (compute / copy / object-list) needs the same surface. */
+export declare function addPassDependencies(pass: Pass, deps: RenderTarget | readonly RenderTarget[]): void;
+
+/** Create a `RenderPass`, wire it to the task currently recording, and return
+ *  it. Must be called from inside `Task.record()` so the FG can associate the
+ *  new pass with the right task (mirrors BJS `frameGraph.addRenderPass`).
+ *
+ *  Configure the returned pass with `setRenderPassRenderTarget`,
+ *  `setRenderPassExecuteFunc`, etc. before the FG finishes building. */
+export declare function addRenderPass(target: FrameGraph | SceneContext, name: string): RenderPass;
+
+/**
+ * Adds a sprite to the layer and returns a stable handle to it.
+ * @param layer - Sprite layer to add the sprite to.
+ * @param props - Initial sprite properties.
+ * @returns A handle that stays valid as sprites are added and removed.
+ */
+export declare function addSprite2D(layer: Sprite2DLayer, props: Sprite2DProps): Sprite2DHandle;
+
+/** Add one sprite. Returns its index. Grows capacity as needed. */
+export declare function addSprite2DIndex(layer: Sprite2DLayer, props: Sprite2DProps): number;
+
+/** Add an animation to a manager, transferring ownership if it already belongs to another manager. */
+export declare function addSpriteAnimation(manager: SpriteAnimationManager, animation: SpriteFrameAnimation): void;
+
+/**
+ * Attaches a sprite animation manager to a shared animation manager so it ticks with it.
+ * @param manager - Animation manager that will drive the sprite manager.
+ * @param spriteManager - Sprite animation manager to attach.
+ * @throws If the sprite manager is already running or attached elsewhere.
+ */
+export declare function addSpriteAnimationManager(manager: AnimationManager, spriteManager: SpriteAnimationManager): void;
+
+/** Add a pure-2D layer to the renderer. No-op if the layer is already present. */
+export declare function addSpriteRendererLayer(sr: SpriteRenderer, layer: Sprite2DLayer): void;
+
+/** Add a task at the END of execute order. Accepts the scene's frame graph directly,
+ *  or a SceneContext (the scene's default frame graph is used). */
+export declare function addTask(target: FrameGraph | SceneContext, task: Task): void;
+
+/** Insert a task at the START of user execute order. Built-in system tasks that must
+ *  precede all user work, such as the shadow adapter, keep their leading slot. */
+export declare function addTaskAtStart(target: FrameGraph | SceneContext, task: Task): void;
+
+/** Insert a task BEFORE another task in execute order. Accepts a FrameGraph or a SceneContext. */
+export declare function addTaskBefore(target: FrameGraph | SceneContext, task: Task, before: Task): void;
+
+/** Add one instance. Returns its index. Grows capacity as needed. */
+export declare function addThinInstance(mesh: Mesh, matrix: Mat4): number;
+
+/**
+ * Adds an entity to the scene, dispatching on its type. Asset containers are unpacked and
+ * each contained entity added recursively; meshes, lights, cameras, transform nodes, and
+ * shadow generators are registered in their respective scene collections.
+ * @param scene - The owning scene (pillar 4b: entities never reference the scene themselves).
+ * @param entity - The entity (or asset container) to add.
+ */
+export declare function addToScene(scene: SceneContext, entity: Mesh | LightBase | Camera | ShadowGenerator | TransformNode | AssetContainer): void;
+
+/** Request the agent to move toward a world target (constrained by navmesh). */
+export declare function agentGoto(crowd: NavCrowd, index: number, destination: Vec3): void;
+
+/** Crowd agent parameters. */
+export declare interface AgentParameters {
+    radius: number;
+    height: number;
+    maxAcceleration: number;
+    maxSpeed: number;
+    collisionQueryRange: number;
+    pathOptimizationRange: number;
+    separationWeight: number;
+    updateFlags?: number;
+    obstacleAvoidanceType?: number;
+    queryFilterType?: number;
+    reachRadius?: number;
+}
+
+/** A post-process task that combines a left-eye and right-eye image into a red/cyan anaglyph 3D image. */
+export declare interface AnaglyphPostProcessTask extends PostProcessTask {
+    leftTexture: RenderTarget;
+}
+
+/** Configuration for `createAnaglyphPostProcessTask`; `leftTexture` is the left-eye image combined with the source (right eye). */
+export declare interface AnaglyphPostProcessTaskConfig extends Omit<PostProcessTaskConfig, "_shader"> {
+    leftTexture: RenderTarget;
+}
+
+/** Minimal structural view of a scene node's animatable transform. Lets the
+ *  animation controller apply plain glTF node-TRS channels (translation/rotation/
+ *  scale) to scene nodes without importing the scene layer. `SceneNode` is
+ *  structurally compatible with this interface. */
+declare interface AnimatedNodeTarget {
+    readonly position: {
+        set(x: number, y: number, z: number): void;
+    };
+    readonly rotationQuaternion: {
+        set(x: number, y: number, z: number, w: number): void;
+    };
+    readonly scaling: {
+        set(x: number, y: number, z: number): void;
+    };
+}
+
+/** Options for {@link setAnimationAdditive}, selecting the reference pose subtracted from an additive animation. */
+export declare interface AnimationAdditiveOptions {
+    readonly referenceFrame?: number;
+    readonly referenceTime?: number;
+}
+
+/** Single animation channel — targets one node property, or an arbitrary
+ *  KHR_animation_pointer target resolved at load time to a writer function. */
+declare interface AnimationChannel {
+    readonly samplerIdx: number;
+    /** For standard channels: glTF node index. For `PATH_POINTER`: unused (-1). */
+    readonly nodeIdx: number;
+    readonly path: TargetPath;
+    /** PATH_POINTER only: invoked per-frame with the interpolated sampler output.
+     *  The writer is responsible for applying the value to the runtime target
+     *  (node.visible, material factor, camera fov, light color, ...). */
+    readonly pointerWriter?: (output: Float32Array, offset: number) => void;
+    /** PATH_POINTER only: number of floats per keyframe (1, 3, 4, ...). */
+    readonly pointerArity?: number;
+    /** PATH_POINTER only: true when LINEAR interpolation should use quaternion slerp. */
+    readonly pointerQuaternion?: boolean;
+}
+
+/** One animation clip (may animate many nodes). */
+export declare interface AnimationClip {
+    readonly name: string;
+    readonly channels: readonly AnimationChannel[];
+    readonly samplers: readonly AnimationSampler[];
+    /** Total duration in seconds (max of all sampler input times). */
+    readonly duration: number;
+    /** Frame rate used by AnimationGroup goToFrame(); defaults to 60. */
+    readonly frameRate?: number;
+}
+
+/** Drives playback of a skeletal/morph animation clip, advancing time and uploading bone matrices each tick. */
+export declare interface AnimationController {
+    /** Advance animation by deltaMs and update bone textures. */
+    tick(deltaMs: number, engine?: EngineContext): void;
+    /** Current playback time in seconds. */
+    time: number;
+    /** True if playing. */
+    playing: boolean;
+    /** Playback speed multiplier (default 1). */
+    speedRatio: number;
+    /** Whether animation loops (default true). */
+    loop: boolean;
+
+/** User-facing animation group — one per animation clip. Pure state. */
+export declare interface AnimationGroup {
+    /** Name of this animation. */
+    readonly name: string;
+    /** Duration in seconds. */
+    readonly duration: number;
+    /** Frame rate used by goToFrame(). */
+    readonly frameRate?: number;
+    /** True if currently playing. */
+    isPlaying: boolean;
+    /** Current playback time in seconds. */
+    currentFrame: number;
+    /** Playback speed multiplier (default 1). */
+    speedRatio: number;
+    /** Whether animation loops (default true). */
+    loopAnimation: boolean;
+    /** Weighted contribution used by AnimationManager mixing (default 1). */
+    weight: number;
+
+/** A single keyframe on a property animation track. Supply exactly one of `time` (seconds) or `frame`. */
+export declare interface AnimationKeyframe {
+    readonly time?: number;
+    readonly frame?: number;
+    readonly value: AnimationKeyframeValue;
+}
+
+/** A keyframe value: a single scalar or a fixed-length tuple of components (e.g. a vector or quaternion). */
+export declare type AnimationKeyframeValue = number | readonly number[];
+
+/** Owns a set of {@link AnimationTask}s and ticks them, either manually or via its own requestAnimationFrame loop. */
+export declare interface AnimationManager {
+    animations: AnimationTask[];
+    fixedDeltaMs: number;
+    running: boolean;
+    readonly engine?: EngineContext;
+    /** Called after each autonomous tick with the step (in ms) that was applied. */
+    readonly onUpdate?: (deltaMs: number) => void;
+
+/** Options for {@link createAnimationManager}. */
+export declare interface AnimationManagerOptions {
+    readonly engine?: EngineContext;
+    readonly fixedDeltaMs?: number;
+    /** Called after each autonomous tick with the step (in ms) that was applied. */
+    readonly onUpdate?: (deltaMs: number) => void;
+}
+
+/** Parsed keyframe sampler — times + values + interpolation. */
+declare interface AnimationSampler {
+    /** Keyframe timestamps in seconds (monotonically increasing). */
+    readonly input: Float32Array;
+    /** Keyframe output values (vec3/quat/scalar packed sequentially).
+     *  For CUBICSPLINE: [inTangent, value, outTangent] per keyframe. */
+    readonly output: Float32Array;
+    readonly interpolation: InterpMode;
+}
+
+/** A unit of per-frame animation work owned by an {@link AnimationManager}. */
+export declare interface AnimationTask {
    active: boolean;
+
+/** Handler that drives all tasks of a given category in one pass; returns true if it handled that category this tick. */
+export declare type AnimationTaskCategoryHandler = (manager: AnimationManager, deltaMs: number) => boolean;
+
+/** Options for {@link createAnimationTask}. */
+export declare interface AnimationTaskOptions {
+    readonly category?: string;
+    /** Called when the task is removed from its manager, allowing it to release any owned resources. */
+    readonly dispose?: (manager: AnimationManager) => void;
+}
+
+/** Callback invoked each tick to advance a single {@link AnimationTask} by `deltaMs` milliseconds. */
+export declare type AnimationTaskUpdate = (manager: AnimationManager, deltaMs: number, task: AnimationTask) => void;
+
+/** Anisotropy layer properties. Maps to BJS PBRMaterial.anisotropy sub-object.
+ *  Stretches specular reflections along the tangent direction. */
+export declare interface AnisotropyProps {
+    /** Whether anisotropy is active. Default false. */
+    isEnabled: boolean;
+    /** Anisotropy strength (0=isotropic, 1=fully anisotropic). Default 1.0. */
+    intensity?: number;
+    /** Anisotropy direction in tangent space (u, v). Default [1, 0]. */
+    direction?: [number, number];
+}
+
+declare type AnyMaterial = StandardMaterialProps | PbrMaterialProps;
+
+/** ArcRotateCamera — orbits around a target point.
+ *  Uses Babylon.js convention: left-handed, alpha=rotation around Y, beta=elevation.
+ *  Plain data + methods. Does NOT know about the scene.
+ *
+ *  Push-based dirty tracking: alpha/beta/radius use Object.defineProperty,
+ *  target uses ObservableVec3. Changes call wm.markLocalDirty() immediately.
+ *
+ *  Inertia follows the Babylon.js model: input handlers accumulate per-frame
+ *  offsets (inertialAlphaOffset, etc.) which are applied and exponentially
+ *  decayed each frame by the controls module. */
+export declare interface ArcRotateCamera extends Camera, IWorldMatrixProvider, IParentable {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target: Vec3;
+    fov: number;
+    nearPlane: number;
+    farPlane: number;
+    viewport?: NormalizedViewport;
+    children: SceneNode[];
+    /** Inertia coefficient for rotation and zoom (0 = instant stop, 0.9 = default, 1 = no decay). */
+    inertia: number;
+    /** Inertia coefficient for panning (0 = instant stop, 0.9 = default). */
+    panningInertia: number;
+    /** Per-frame inertial offsets — accumulated by input, applied & decayed each frame. */
+    inertialAlphaOffset: number;
+    inertialBetaOffset: number;
+    inertialRadiusOffset: number;
+    inertialPanningX: number;
+    inertialPanningY: number;
+    parent: IWorldMatrixProvider | null;
+    readonly worldMatrix: Mat4;
+    readonly worldMatrixVersion: number;
+}
+
+/**
+ * Result returned by loadGltf / loadBabylon.
+ * Pass directly to addToScene() — it handles all fields automatically.
+ *
+ * - glTF: entities = [root TransformNode], animationGroups = loaded clips
+ * - .babylon: entities = root SceneNodes (Mesh/TransformNode) + LightBase, clearColor from file
+ */
+export declare interface AssetContainer {
+    /** Scene entities. glTF: [root TransformNode]. .babylon: root nodes + lights. */
+    entities: Array<SceneNode | LightBase>;
+    /** Animation groups from the file. addToScene() registers them with the scene-owned AnimationManager by default. */
+    animationGroups?: AnimationGroup[];
+    /** Scene background color declared in the file. addToScene() applies it to scene.clearColor. */
+    clearColor?: GPUColorDict;
+    /** Camera parsed from the file. addToScene() sets it as scene.camera when present. */
+    camera?: Camera;
+    /** KHR_materials_variants data. Use selectVariant() / getVariantNames() to interact. */
+    materialVariants?: MaterialVariantData;
+    /** KHR_xmp_json_ld metadata. `packets` are the JSON-LD packets declared at the
+     *  document level; `assetPacket` is the packet referenced by `asset` (if any). */
+    xmpMetadata?: {
+        packets: unknown[];
+        assetPacket?: unknown;
+    };
+}
+
+/**
+ * Attach orbit/zoom/pan controls to an ArcRotateCamera.
+ * Matches Babylon.js ArcRotateCameraPointersInput behavior with inertia:
+ * - Left-drag: rotate (alpha/beta) with momentum
+ * - Right-drag: pan (shift target) with momentum
+ * - Wheel: zoom (radius) with momentum
+ * - Pinch: zoom (touch, direct — no inertia)
+ *
+ * Input handlers accumulate into the camera's inertial offset properties.
+ * Inertia is applied each frame via scene._beforeRender (single RAF loop).
+ *
+ * Camera stays plain data — this function reads/writes its properties.
+ * Returns a cleanup function to remove all listeners and the beforeRender hook.
+ */
+export declare function attachControl(camera: ArcRotateCamera, canvas: HTMLCanvasElement, scene?: SceneContext): () => void;
+
+/**
+ * Attach keyboard + mouse controls to a FreeCamera.
+ * Matches Babylon.js FreeCamera input behavior:
+ * - Mouse drag or pointer-lock: look around (yaw/pitch)
+ * - Arrow keys / WASD: move forward/back/strafe
+ * - PageUp/PageDown or Space/Shift: move up/down
+ * - Inertia: movement decays smoothly (camera.inertia, default 0.9)
+ * - Frame-rate independent: uses deltaTime from render loop
+ *
+ * Camera stays plain data — this function reads/writes its properties.
+ * Returns a cleanup function to remove all listeners and the beforeRender hook.
+ */
+export declare function attachFreeControl(camera: FreeCamera, canvas: HTMLCanvasElement, scene?: SceneContext): () => void;
+
+/**
+ * Attaches a manager to a sprite renderer's update hooks so its animations advance each frame.
+ * @param renderer - Sprite renderer whose update loop drives the manager.
+ * @param manager - Sprite animation manager to attach.
+ * @returns A binding that detaches the manager when disposed.
+ * @throws If the manager is already running or attached elsewhere.
+ */
+export declare function attachSpriteAnimationsToRenderer(renderer: SpriteRenderer, manager: SpriteAnimationManager): SpriteAnimationBinding;
+
+/**
+ * Attaches a manager to a scene's before-render hooks so its animations advance each frame.
+ * @param scene - Scene whose render loop drives the manager.
+ * @param manager - Sprite animation manager to attach.
+ * @returns A binding that detaches the manager when disposed.
+ * @throws If the manager is already running or attached elsewhere.
+ */
+export declare function attachSpriteAnimationsToScene(scene: SceneContext, manager: SpriteAnimationManager): SpriteAnimationBinding;
+
+/** A billboard sprite system that rotates only around a fixed world axis. */
+export declare type AxisLockedBillboardSpriteSystem = BillboardSpriteSystem<"axis-locked">;
+
+/**
+ * Bakes the mesh's current world matrix into its splat vertices, then resets the mesh's
+ * position, rotation, and scaling to identity so the visual result is unchanged.
+ * @param mesh - Gaussian Splatting mesh to modify in place.
+ */
+export declare function bakeCurrentTransformIntoVertices(mesh: GaussianSplattingMesh): void;
+
+/**
+ * Bakes a transform matrix directly into a mesh's splat vertices, rewriting each splat's
+ * position, scale, and orientation so the mesh renders identically with an identity transform.
+ * @param mesh - Gaussian Splatting mesh to modify in place.
+ * @param transform - World-space transform to bake into the splat data.
+ */
+export declare function bakeTransformIntoVertices(mesh: GaussianSplattingMesh, transform: Mat4): void;
+
+/**
+ * Additive blending for world-space billboards. The billboard's RGB, scaled by its own alpha, is
+ * added to the framebuffer (no depth write, like the other transparent modes), so overlapping
+ * billboards stack and brighten — world-space embers, sparks, muzzle flashes, and light shafts.
+ */
+export declare const billboardBlendAdditive: BillboardBlendDescriptor;
+
+/** Straight-alpha "over" blending (the default) for transparent billboards. */
+export declare const billboardBlendAlpha: BillboardBlendDescriptor;
+
+/**
+ * Alpha-test cutout: no color blend; fragments below `alphaCutoff` are discarded and surviving
+ * fragments write depth, so cutout billboards occlude correctly like opaque geometry.
+ */
+export declare const billboardBlendCutout: BillboardBlendDescriptor;
+
+/**
+ * A billboard-system blend descriptor. Pass one of the exported `billboardBlend*` values to
+ * `createFacingBillboardSystem` / `createAxisLockedBillboardSystem` via `{ blendMode }`. The
+ * fields are internal plumbing; treat the value as opaque.
+ */
+export declare interface BillboardBlendDescriptor {
+
+/**
+ * Blend mode for a billboard sprite system — a pure-data descriptor value. Import one of
+ * `billboardBlendAlpha` (default), `billboardBlendPremultiplied`, or `billboardBlendCutout`
+ * and pass it as `BillboardSpriteSystemOptions.blendMode`. (Type alias of
+ * {@link BillboardBlendDescriptor}.)
+ */
+export declare type BillboardBlendMode = BillboardBlendDescriptor;
+
+/** Premultiplied-alpha "over" blending; per-system opacity scales RGB and A together. */
+export declare const billboardBlendPremultiplied: BillboardBlendDescriptor;
+
+/** Opaque custom-shader descriptor produced by {@link createBillboardCustomShader}. */
+export declare interface BillboardCustomShader {
+
+/** Options for {@link createBillboardCustomShader}. */
+export declare interface BillboardCustomShaderOptions {
+    /** WGSL fragment body. See the module docs for the in-scope identifiers. */
+    readonly fragment: string;
+    /** Extra textures, in binding order. Each contributes a `texture_2d` + `sampler`. */
+    readonly extraTextures?: readonly BillboardCustomTexture[];
+}
+
+/** One extra texture bound after the atlas (group 1, bindings 3, 5, 7, …). */
+export declare type BillboardCustomTexture = CustomShaderTexture;
+
+/** Depth/blend pipeline path used by a billboard system: alpha-blended `transparent` or alpha-tested `cutout`. */
+export declare type BillboardDepthMode = "transparent" | "cutout";
+
+/** How a billboard orients itself: `facing` always faces the camera, `axis-locked` rotates only around a fixed axis. */
+export declare type BillboardOrientation = "facing" | "axis-locked";
+
+/** Stable identity for a single billboard sprite that survives swap-remove reindexing. */
+export declare interface BillboardSpriteHandle {
    readonly system: BillboardSpriteSystem;
+    readonly id: number;
+}
+
+/** Initial properties for a single billboard sprite. */
+export declare interface BillboardSpriteInit {
+    position: [number, number, number];
+    sizeWorld: [number, number];
+    frame?: number;
+    rotation?: number;
+    pivot?: [number, number];
+    color?: [number, number, number, number];
+    flipX?: boolean;
+    flipY?: boolean;
+    visible?: boolean;
+}
+
+declare interface BillboardSpriteSystem<TOrientation extends BillboardOrientation = BillboardOrientation> {
    readonly atlas: SpriteAtlas;
+    readonly blendMode: BillboardBlendMode;
+    alphaCutoff: number;
+    opacity: number;
+    visible: boolean;
+    readonly order: number;
+    readonly count: number;
    /**
+     * Per-system custom-shader params (`fx.params`); set via `setBillboardShaderParams`.
+     * **Absent** on plain systems (only allocated for custom-shader systems, or lazily by the setter).
+     */
+    shaderParams?: [number, number, number, number];
+}
+
+/** Optional configuration for a billboard sprite system. */
+export declare interface BillboardSpriteSystemOptions {
+    capacity?: number;
+    blendMode?: BillboardBlendMode;
+    alphaCutoff?: number;
+    opacity?: number;
+    visible?: boolean;
+    order?: number;
+    /** Optional opt-in custom fragment shader (from `createBillboardCustomShader`). */
+    customShader?: BillboardCustomShader;
+}
+
+declare interface BindingDecl {
+
+/** A post-process task that desaturates the image toward grayscale by `degree`. */
+export declare interface BlackAndWhitePostProcessTask extends PostProcessTask {
+    degree: number;
+}
+
+/** Configuration for `createBlackAndWhitePostProcessTask`; `degree` is the desaturation strength (0 = color, 1 = full grayscale). */
+export declare interface BlackAndWhitePostProcessTaskConfig extends Omit<PostProcessTaskConfig, "_shader"> {
+    degree?: number;
+}
+
+/** A block emitter — pure functions, no per-instance state. */
+declare interface BlockEmitter {
+    /** Class name this emitter handles (e.g. "InputBlock"). */
+    readonly className: string;
+    /** Which shader stage this block produces into. Defaults to "fragment". */
+    readonly stage?: Stage;
+    /** Terminal "side-effect" block that has no outputs the graph reads (e.g.
+     *  DiscardBlock). emitGraph force-emits these after the root walk so they
+     *  participate even without a downstream consumer. */
+    readonly sideEffect?: boolean;
+    /** Emit the value of `outputName` for `block`, returning a typed WGSL expression. */
+    emit(block: NodeBlock, outputName: string, stage: Stage, state: NodeBuildState, ctx: NodeEmitContext): NodeExpr;
+}
+
+/** A composite post-process task that extracts highlights, blurs them, and merges the glow back over the source image. */
+export declare interface BloomPostProcessTask extends Task, PostProcessTaskSettings {
+    readonly name: string;
+    sourceTexture: RenderTarget;
+    targetTexture: RenderTarget | null;
+    outputTexture: RenderTarget;
+    weight: number;
+    kernel: number;
+    threshold: number;
+    exposure: number;
+    readonly bloomScale: number;
+    /** Recompute and upload the uniforms of all sub-passes (extract, blur X/Y, merge) from current settings. */
+    updateUniforms(): void;
+}
+
+/** Configuration for `createBloomPostProcessTask`: highlight `threshold`/`exposure`, blur `kernel`, merge `weight`, and `bloomScale`. */
+export declare interface BloomPostProcessTaskConfig extends PostProcessTaskSettings {
+    weight?: number;
+    kernel?: number;
+    threshold?: number;
+    exposure?: number;
+    bloomScale?: number;
+}
+
+/** A separable Gaussian blur post-process pass along a single `direction`. */
+export declare interface BlurPostProcessTask extends PostProcessTask {
+    direction: PostProcessVec2;
+    kernel: number;
+}
+
+/** Configuration for `createBlurPostProcessTask`; `direction` is the blur axis and `kernel` the sample-window size in pixels. */
+export declare interface BlurPostProcessTaskConfig extends Omit<PostProcessTaskConfig, "_shader"> {
+    direction?: PostProcessVec2;
+    kernel?: number;
+}
+
+/** Minimal camera contract — any camera that can provide view/projection matrices.
+ *  Both ArcRotateCamera and FreeCamera implement this interface.
+ *  Pure state, no scene knowledge (pillar 4b). */
+export declare interface Camera {
+    fov: number;
+    nearPlane: number;
+    farPlane: number;
+    viewport?: NormalizedViewport;
+    children: SceneNode[];
+    readonly worldMatrix: Mat4;
+    readonly worldMatrixVersion: number;
+
+/** Cap mode: close both ends of the tube/extrusion. */
+export declare const CAP_ALL = 3;
+
+/** Cap mode: close only the end of the tube/extrusion. */
+export declare const CAP_END = 2;
+
+/** Cap mode: no caps on either end of the tube/extrusion. */
+export declare const CAP_NONE = 0;
+
+/** Cap mode: close only the start of the tube/extrusion. */
+export declare const CAP_START = 1;
+
+/** A post-process task that offsets the red/green/blue channels to simulate lens chromatic aberration. */
+export declare interface ChromaticAberrationPostProcessTask extends PostProcessTask {
+    aberrationAmount: number;
+    direction: PostProcessVec2_2;
+    radialIntensity: number;
+    centerPosition: PostProcessVec2_2;
+}
+
+/** Configuration for `createChromaticAberrationPostProcessTask`: shift `aberrationAmount`, `direction`, `radialIntensity`, and `centerPosition`. */
+export declare interface ChromaticAberrationPostProcessTaskConfig extends Omit<PostProcessTaskConfig, "_shader"> {
+    aberrationAmount?: number;
+    direction?: PostProcessVec2_2;
+    radialIntensity?: number;
+    centerPosition?: PostProcessVec2_2;
+}
+
+/** Removes and disposes every task attached to `manager`. */
+export declare function clearAnimationManager(manager: AnimationManager): void;
+
+/**
+ * Removes every sprite from the system, resetting its count to zero.
+ * @param system - Billboard system to clear.
+ */
+export declare function clearBillboardSprites(system: BillboardSpriteSystem): void;
+
+/** Clearcoat layer properties. Maps to BJS PBRMaterial.clearCoat sub-object. */
+export declare interface ClearCoatProps {
+    /** Whether clearcoat is active. Default false. */
+    isEnabled?: boolean;
+    /** Clearcoat layer intensity (0=off, 1=full). Default 1.0. */
+    intensity?: number;
+    /** Clearcoat layer roughness. Default 0.0 (perfectly smooth). */
+    roughness?: number;
+    /** Index of refraction of the clearcoat layer. Default 1.5. */
+    indexOfRefraction?: number;
+    /** Optional clearcoat intensity texture (R channel). Multiplies `intensity`. */
+    texture?: Texture2D;
+    /** Optional clearcoat roughness texture (G channel). Multiplies `roughness`. */
+    roughnessTexture?: Texture2D;
+    /** Optional clearcoat normal map (tangent-space). Used to perturb the coat
+     *  layer normal independently of the base layer. */
+    bumpTexture?: Texture2D;
+    /** Clearcoat normal texture scale (glTF normalTexture.scale). Default 1.0. */
+    bumpTextureScale?: number;
+    /** Whether to remap base F0 across the clearcoat interface (CLEARCOAT_REMAP_F0).
+     *  Matches BJS PBRClearCoatConfiguration.remapF0OnInterfaceChange.
+     *  Default true. glTF loader sets this to false per KHR_materials_clearcoat. */
+    useF0Remap?: boolean;
+}
+
+/** Clear all sprites from a layer while preserving allocated capacity. */
+export declare function clearSprite2DLayer(layer: Sprite2DLayer): void;
+
+/**
+ * Removes every animation owned by the manager, leaving it empty.
+ * @param manager - Manager to clear.
+ */
+export declare function clearSpriteAnimations(manager: SpriteAnimationManager): void;
+
+/** A clipping plane expressed as the coefficients `[a, b, c, d]` of `a·x + b·y + c·z + d`. */
+export declare type ClipPlane = readonly [number, number, number, number];
+
+/** Deep-clone a SceneNode tree. Meshes are shallow-cloned (shared GPU buffers).
+ *  Lights, cameras, and other non-mesh/non-TN children are shallow-cloned. */
+export declare function cloneTransformNode(src: SceneNode): SceneNode;
+
+export declare interface ClusteredLightContainer {
+    readonly kind: "clusteredLightContainer";
+    pointLights: ClusteredPointLight[];
+    horizontalTiles: number;
+    verticalTiles: number;
+    zSlices: number;
+
+export declare interface ClusteredLightContainerOptions {
+    horizontalTiles?: number;
+    verticalTiles?: number;
+    zSlices?: number;
+}
+
+export declare interface ClusteredPointLight {
+    position: [number, number, number];
+    diffuse: [number, number, number];
+    range: number;
+    intensity: number;
+}
+
+export declare interface ClusteredPointLightOptions {
+    position: [number, number, number];
+    diffuse: [number, number, number];
+    range?: number;
+    intensity?: number;
+}
+
+/** Compute a path between two world positions, snapped to the navmesh. */
+export declare function computePath(plugin: NavigationPlugin, start: Vec3, end: Vec3): Vec3[];
+
+/**
+ * Create a post-process task that merges a left-eye texture with the source (right eye) into a red/cyan anaglyph.
+ * @param config - Source/target settings and the left-eye `leftTexture`.
+ * @param engine - The owning engine.
+ * @param scene - Optional owning scene. Omit for scene-less standalone frame graphs.
+ * @returns The anaglyph post-process task.
+ */
+export declare function createAnaglyphPostProcessTask(config: AnaglyphPostProcessTaskConfig, engine: EngineContext, scene?: SceneContext): AnaglyphPostProcessTask;
+
+/**
+ * Create a skeleton animation controller from parsed glTF animation data.
+ * Returns a tick function that advances the animation and uploads bone matrices.
+ */
+export declare function createAnimationController(clip: AnimationClip, nodes: readonly NodeRest[], skeletons: readonly SkeletonBinding[], morphBindings: readonly MorphBinding[], nodeTargets?: readonly (AnimatedNodeTarget | undefined)[], excludedNodeIndices?: ReadonlySet<number>): AnimationController;
+
+/** Create AnimationGroup(s) from parsed glTF animation data.
+ *  Returns one group per animation clip. */
+export declare function createAnimationGroups(animData: GltfAnimationData): AnimationGroup[];
+
+/** Creates an animation manager with no tasks attached.
+ *  @param options - Optional engine, fixed timestep, and update callback.
+ *  @returns The new manager. */
+export declare function createAnimationManager(options?: AnimationManagerOptions): AnimationManager;
+
+/** Creates an animation task that invokes `update` each tick.
+ *  @param update - Callback that advances the task by the frame delta.
+ *  @param options - Optional category and dispose hook.
+ *  @returns The new, active animation task. */
+export declare function createAnimationTask(update: AnimationTaskUpdate, options?: AnimationTaskOptions): AnimationTask;
+
+/** Create a bare ArcRotateCamera with given params. Pure data, no scene knowledge. */
+export declare function createArcRotateCamera(alpha: number, beta: number, radius: number, target: Vec3): ArcRotateCamera;
+
+/**
+ * Creates a billboard sprite system whose quads rotate only around a fixed world axis.
+ * @param atlas - Sprite atlas supplying frames.
+ * @param axis - Lock axis; normalized internally and must be non-zero and finite.
+ * @param opts - Optional capacity, blend, and appearance settings.
+ * @returns The new axis-locked billboard system.
+ * @throws If `axis` has non-finite components or is the zero vector.
+ */
+export declare function createAxisLockedBillboardSystem(atlas: SpriteAtlas, axis: readonly [number, number, number], opts?: BillboardSpriteSystemOptions): AxisLockedBillboardSpriteSystem;
+
+/**
+ * Build a custom-shader descriptor to pass as `customShader` when creating a billboard system.
+ * The descriptor is opaque; the pipeline consumes it lazily.
+ */
+export declare function createBillboardCustomShader(options: BillboardCustomShaderOptions): BillboardCustomShader;
+
+/**
+ * Create a post-process task that blends the image toward grayscale.
+ * @param config - Source/target settings and desaturation `degree`.
+ * @param engine - The owning engine.
+ * @param scene - Optional owning scene. Omit for scene-less standalone frame graphs.
+ * @returns The black-and-white post-process task.
+ */
+export declare function createBlackAndWhitePostProcessTask(config: BlackAndWhitePostProcessTaskConfig, engine: EngineContext, scene?: SceneContext): BlackAndWhitePostProcessTask;
+
+/**
+ * Create a bloom post-process task by chaining highlight extraction, separable blur, and a merge pass.
+ * @param config - Bloom parameters and source/target settings.
+ * @param engine - The owning engine.
+ * @param scene - Optional owning scene. Omit for scene-less standalone frame graphs.
+ * @returns The bloom post-process task.
+ */
+export declare function createBloomPostProcessTask(config: BloomPostProcessTaskConfig, engine: EngineContext, scene?: SceneContext): BloomPostProcessTask;
+
+/**
+ * Create a separable Gaussian blur post-process task. Apply twice (horizontal then vertical) for a full 2D blur.
+ * @param config - Blur direction, kernel size, and source/target settings.
+ * @param engine - The owning engine.
+ * @param scene - Optional owning scene. Omit for scene-less standalone frame graphs.
+ * @returns The blur post-process task.
+ */
+export declare function createBlurPostProcessTask(config: BlurPostProcessTaskConfig, engine: EngineContext, scene?: SceneContext): BlurPostProcessTask;
+
+/** Create a box mesh. Caller must assign material. */
+export declare function createBox(engine: EngineContext, size?: number): Mesh;
+
+/**
+ * Create a post-process task that simulates chromatic aberration by shifting color channels outward from a center point.
+ * @param config - Aberration parameters and source/target settings.
+ * @param engine - The owning engine.
+ * @param scene - Optional owning scene. Omit for scene-less standalone frame graphs.
+ * @returns The chromatic-aberration post-process task.
+ */
+export declare function createChromaticAberrationPostProcessTask(config: ChromaticAberrationPostProcessTaskConfig, engine: EngineContext, scene?: SceneContext): ChromaticAberrationPostProcessTask;
+
+/**
+ * Builds a {@link Csg2Solid} from a mesh's CPU geometry, baking its world transform.
+ * @param mesh - Source mesh; must retain CPU positions, normals, and indices.
+ * @param materialSlot - Material slot index (0 to 65535) tagged onto the solid's triangles.
+ * @returns A CSG2 solid; call {@link disposeCsg2} when finished to free WASM memory.
+ */
+export declare function createCsg2FromMesh(mesh: Mesh, materialSlot?: number): Csg2Solid;
+
+/**
+ * Builds a {@link CsgSolid} from a mesh's CPU geometry, baking its world transform.
+ * @param mesh - Source mesh; must retain CPU positions, normals, and indices.
+ * @param materialSlot - Material slot index tagged onto every generated polygon.
+ * @returns A CSG solid usable with {@link csgUnion}, {@link csgSubtract}, and {@link csgIntersect}.
+ */
+export declare function createCsgFromMesh(mesh: Mesh, materialSlot?: number): CsgSolid;
+
+/** Create a cylinder (or cone / truncated cone / prism) mesh. Caller must assign material. */
+export declare function createCylinder(engine: EngineContext, options?: CylinderOptions): Mesh;
+
+/**
+ * Extract debug visualization geometry from the generated navmesh.
+ * Faces are detached (each triangle gets its own 3 vertices) and per-vertex
+ * normals are set to the face normal — yielding flat shading without the need
+ * for a separate normal-computation pass in callers.
+ * Returns positions, normals, indices, and a hash of the positions for
+ * cross-engine parity checks.
+ */
+export declare function createDebugNavMeshGeometry(plugin: NavigationPlugin): {
+    positions: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    positionsHash: number;
+};
+
+/** Create an ArcRotateCamera framed to fit all loaded meshes, assign it to scene.
+ *  Only the scene knows its contents — auto-framing logic lives here.
+ *  Matches Babylon.js createDefaultCameraOrLight(true, true, true). */
+export declare function createDefaultCamera(scene: SceneContext): ArcRotateCamera;
+
+/**
+ * Creates a directional light shining along `direction` (a parallel light source, like the sun).
+ * @param direction - World-space direction the light travels along.
+ * @param intensity - Scalar multiplier applied to the light's diffuse and specular contribution.
+ * @returns Plain `DirectionalLight` data to be added to a scene via `addToScene`.
+ */
+export declare function createDirectionalLight(direction: [number, number, number], intensity?: number): DirectionalLight;
+
+/** Create a disc (or ring / pie slice via `arc`). Caller must assign material. */
+export declare function createDisc(engine: EngineContext, options?: DiscOptions): Mesh;
+
+/**
+ * Create an `EffectRenderer` that draws `effect` as a fullscreen pass to the
+ * swapchain each frame. The renderer owns a swapchain `RenderTarget` and
+ * implements `RenderingContext` directly — no `SceneContext` is needed.
+ *
+ * Call `registerEffectRenderer` to start rendering, `unregisterEffectRenderer`
+ * to pause, and `disposeEffectRenderer` to free GPU resources.
+ */
+export declare function createEffectRenderer(engine: EngineContext, effect: EffectWrapper, options?: EffectRendererOptions): EffectRenderer;
+
+/**
+ * Create a frame-graph task that draws an effect as a fullscreen pass into `config.target`.
+ * @param config - The effect, target, and clear settings.
+ * @param engine - The owning engine.
+ * @param scene - Optional owning scene. Omit for scene-less standalone frame graphs.
+ * @returns The render task to add to a frame graph.
+ */
+export declare function createEffectRenderTask(config: EffectRenderTaskConfig, engine: EngineContext, scene?: SceneContext): EffectRenderTask;
+
+/**
+ * Create an `EffectWrapper` for the given engine, allocating uniform buffers and
+ * texture slots from `options.bindings`.
+ * @param engine - The engine that owns the GPU resources.
+ * @param options - Shader source and binding layout for the effect.
+ * @returns The new effect wrapper.
+ */
+export declare function createEffectWrapper(engine: EngineContext, options: EffectWrapperOptions): EffectWrapper;
+
+/** Create the Babylon Lite engine. Acquires GPU adapter + device, configures swapchain.
+ *  Accepts either a DOM canvas (main thread) or an `OffscreenCanvas` (e.g. transferred to
+ *  a Web Worker) — see {@link RenderCanvas}. */
+export declare function createEngine(canvas: RenderCanvas, options?: EngineOptions): Promise<EngineContext>;
+
+/**
+ * Creates an exponential shadow map (ESM) shadow generator for a directional light,
+ * including the depth, blur, and final ESM textures plus the per-frame render task hooks.
+ * @param engine - The engine providing the GPU device.
+ * @param _light - The directional light that casts the shadows.
+ * @param cfg - Optional shadow-map, blur, and projection configuration.
+ * @returns A `ShadowGenerator` wired to the directional ESM render path.
+ */
+export declare function createEsmDirectionalShadowGenerator(engine: EngineContext, _light: DirectionalLight, cfg?: EsmDirectionalShadowGeneratorConfig): ShadowGenerator;
+
+/**
+ * Create a post-process task that isolates bright highlights above a luminance threshold (used as the first stage of bloom).
+ * @param config - Threshold/exposure parameters and source/target settings.
+ * @param engine - The owning engine.
+ * @param scene - Optional owning scene. Omit for scene-less standalone frame graphs.
+ * @returns The extract-highlights post-process task.
+ */
+export declare function createExtractHighlightsPostProcessTask(config: ExtractHighlightsPostProcessTaskConfig, engine: EngineContext, scene?: SceneContext): ExtractHighlightsPostProcessTask;
+
+/** Create an extruded shape (2D shape swept along a path). Caller must assign material. */
+export declare function createExtrudeShape(engine: EngineContext, options: ExtrudeShapeOptions): Mesh;
+
+/**
+ * Creates a camera-facing billboard sprite system backed by the given atlas.
+ * @param atlas - Sprite atlas supplying frames.
+ * @param opts - Optional capacity, blend, and appearance settings.
+ * @returns The new facing billboard system.
+ */
+export declare function createFacingBillboardSystem(atlas: SpriteAtlas, opts?: BillboardSpriteSystemOptions): FacingBillboardSpriteSystem;
+
+/** Create a scene-less frame-graph context for fullscreen effects and post-process chains. */
+export declare function createFrameGraphContext(engine: EngineContext, options?: FrameGraphContextOptions): FrameGraphContext;
+
+/** Create a FreeCamera at the given position looking at target. Pure data, no scene knowledge. */
+export declare function createFreeCamera(position: Vec3, target: Vec3): FreeCamera;
+
+/** Create a GPU picker bound to the given scene. */
+export declare function createGpuPicker(scene: SceneContext): GpuPicker;
+
+/**
+ * Create a Babylon.js-equivalent `GridMaterial`: an unlit, procedural object-space
+ * grid built on top of {@link createShaderMaterial}. The grid math runs entirely in
+ * object space — the vertex stage forwards object-space position and normal, and the
+ * fragment stage derives per-axis line contributions weighted by the normal.
+ *
+ * @param options - Grid appearance and blend options.
+ * @returns A configured {@link ShaderMaterial}.
+ */
+export declare function createGridMaterial(options?: GridMaterialOptions): ShaderMaterial;
+
+/**
+ * Build a `SpriteAtlas` from a uniform grid over an existing texture. All
+ * cells share the supplied pivot. Frames are emitted row-major (top-left
+ * first). No name lookup map is populated because grid cells have no names.
+ */
+export declare function createGridSpriteAtlas(texture: Texture2D, options: GridAtlasOptions): SpriteAtlas;
+
+/** Create a flat ground mesh. Caller must assign material. */
+export declare function createGround(engine: EngineContext, options?: GroundOptions): Mesh;
+
+/** Create a ground mesh from a heightmap URL. Caller must assign material. */
+export declare function createGroundFromHeightMap(engine: EngineContext, url: string, options: GroundOptions): Promise<Mesh>;
+
+/**
+ * Create a Havok physics world and register per-frame stepping on the scene.
+ *
+ * The caller is responsible for loading the WASM binary externally:
+ * ```ts
+ *   import HavokPhysics from "@babylonjs/havok";
+ *   const hknp = await HavokPhysics({ locateFile: () => "/HavokPhysics.wasm" });
+ *   const world = createHavokWorld(scene, hknp);
+ * ```
+ */
+export declare function createHavokWorld(scene: SceneContext, hknp: any, gravity?: Vec3): PhysicsWorld;
+
+/** Create a hemispheric light. Returns plain data — caller adds to scene.
+ *  Matches Babylon.js HemisphericLight behavior. */
+export declare function createHemisphericLight(direction?: [number, number, number], intensity?: number): HemisphericLight;
+
+/**
+ * Create a frame-graph task that applies the scene's image-processing settings
+ * (exposure, contrast, tone mapping) to a color source and draws it to the swapchain.
+ * @param config - The color source to process.
+ * @param engine - The owning engine.
+ * @param scene - The scene whose `imageProcessing` settings drive the effect.
+ * @returns The task to add to the frame graph.
+ */
+export declare function createImageProcessingTask(config: ImageProcessingTaskConfig, engine: EngineContext, scene: SceneContext): Task;
+
+/** Create a linear-depth ShaderMaterial that writes `(d, d, d, 1)` per fragment.
+ *  The depth is computed from the view-space z, normalized by the supplied
+ *  near/far range (or 0.03/15 by default).  Override per material via the
+ *  `nearFar` custom uniform. */
+export declare function createLinearDepthMaterial(options?: LinearDepthMaterialOptions): ShaderMaterial;
+
+/** Create a material view that references source state and overrides render features exactly. */
+export declare function createMaterialView(source: Material, renderFeatures: MaterialRenderFeatures): MaterialView;
+
+/**
+ * Triangulates a {@link Csg2Solid} into one mesh per material slot.
+ * @param materials - Materials indexed by the material slots assigned during construction.
+ * @param name - Base name; each sub-mesh is suffixed with its slot index.
+ * @returns One mesh per distinct material slot, each assigned its corresponding material.
+ */
+export declare function createMeshesFromCsg2(engine: EngineContext, solid: Csg2Solid, materials: readonly Material[], name?: string): Mesh[];
+
+/**
+ * Triangulates a {@link CsgSolid} into a single renderable mesh.
+ * @param name - Name for the created mesh.
+ */
+export declare function createMeshFromCsg(engine: EngineContext, solid: CsgSolid, name?: string): Mesh;
+
+/**
+ * Triangulates a {@link Csg2Solid} into a single renderable mesh.
+ * @param name - Name for the created mesh.
+ */
+export declare function createMeshFromCsg2(engine: EngineContext, solid: Csg2Solid, name?: string): Mesh;
+
+/** Create a Mesh from raw geometry data + GPU device.
+ *  No material is assigned — the caller must set mesh.material before adding to scene. */
+export declare function createMeshFromData(engine: EngineContext, name: string, positions: Float32Array, normals: Float32Array, indices: Uint32Array, uvs?: Float32Array, uvs2?: Float32Array, tangents?: Float32Array, colors?: Float32Array): Mesh;
+
+/** Create morph target GPU data from parsed glTF targets.
+ *  @param engine       - Engine context (provides GPU device)
+ *  @param targets      - Array of `{positions, normals}` deltas per target
+ *  @param vertexCount  - Number of vertices in the base mesh
+ *  @param morphWeights - Initial morph weights (one per target, may be null)
+ */
+export declare function createMorphTargets(engine: EngineContext, targets: {
+    positions: Float32Array;
+    normals: Float32Array | null;
+}[], vertexCount: number, morphWeights: number[] | null): MorphTargetData;
+
+/**
+ * Create a crowd attached to the navmesh. The crowd is NOT auto-updated;
+ * call `updateNavCrowd(crowd, dt)` each frame for full determinism.
+ */
+export declare function createNavCrowd(plugin: NavigationPlugin, maxAgents: number, maxAgentRadius: number): NavCrowd;
+
+/**
+ * Create a navigation plugin. Loads the Recast wasm internally on first call;
+ * subsequent calls reuse the loaded module.
+ *
+ * Pass `locateFile` to serve the wasm from a public path instead of bundling
+ * it inline — same pattern as `HavokPhysics({ locateFile: () => "/HavokPhysics.wasm" })`.
+ *
+ * @example
+ * ```ts
+ *   const nav = await createNavigationPluginAsync({ locateFile: () => "/recast-navigation.wasm" });
+ * ```
+ */
+export declare function createNavigationPluginAsync(options?: {
+    locateFile?: (url: string) => string;
+}): Promise<NavigationPlugin>;
+
+/**
+ * Build a navmesh from one or more meshes. Each mesh's CPU positions are
+ * transformed by its worldMatrix (matching BJS GetPositionsAndIndices), merged
+ * into a single stream, and index winding is reversed (left-handed convention)
+ * unless `doNotReverseIndices` is set.
+ *
+ * - Solo navmesh by default.
+ * - If `maxObstacles > 0`, builds a tile-cache navmesh so obstacles can be
+ *   added/removed dynamically.
+ * - Off-mesh connections can be supplied for either solo or tile-cache.
+ */
+export declare function createNavMesh(plugin: NavigationPlugin, meshes: Mesh[], params: NavMeshParameters): void;
+
+/** Create a no-color view over a NodeMaterial source. */
+export declare function createNodeNoColorMaterialView(source: NodeMaterial): MaterialView;
+
+/** Create a PbrMaterialProps with optional overrides. */
+export declare function createPbrMaterial(props?: Partial<PbrMaterialProps>): PbrMaterialProps;
+
+/** Create a no-color view over a PBR source material.
+ *  The view references the source; material state is never copied. */
+export declare function createPbrNoColorMaterialView(source: PbrMaterialProps): MaterialView;
+
+/**
+ * Creates a PCF (percentage-closer filtering) shadow generator for a directional light,
+ * using an orthographic projection auto-fit to the caster meshes' world AABBs.
+ * @param engine - The engine providing the GPU device.
+ * @param _light - The directional light that casts the shadows.
+ * @param cfg - Optional shadow-map and projection configuration.
+ * @returns A `ShadowGenerator` wired to the directional PCF render path.
+ */
+export declare function createPcfDirectionalShadowGenerator(engine: EngineContext, _light: DirectionalLight, cfg?: PcfDirectionalShadowGeneratorConfig): ShadowGenerator;
+
+/**
+ * Creates a PCF (percentage-closer filtering) shadow generator for a spot light, using a
+ * perspective projection derived from the light's cone angle.
+ * @param engine - The engine providing the GPU device.
+ * @param _light - The spot light that casts the shadows.
+ * @param cfg - Optional shadow-map and projection configuration.
+ * @returns A `ShadowGenerator` wired to the spot-light PCF render path.
+ */
+export declare function createPcfSpotlightShadowGenerator(engine: EngineContext, _light: SpotLight, cfg?: PcfSpotlightShadowGeneratorConfig): ShadowGenerator;
+
+/**
+ * Create a physics aggregate: body + shape + material wired together.
+ * `mass === 0` → STATIC, `mass > 0` → DYNAMIC.
+ * Shape geometry is auto-sized from the mesh bounding box when not specified.
+ */
+export declare function createPhysicsAggregate(world: PhysicsWorld, node: Mesh, type: PhysicsShapeType, options: PhysicsAggregateOptions): PhysicsAggregate;
+
+/**
+ * Creates a rigid body bound to a scene node, adds it to the world, and seeds it with the node's transform.
+ * @param world - The physics world.
+ * @param node - The scene node the body follows / drives.
+ * @param motionType - Whether the body is static, animated (kinematic), or dynamic.
+ * @param startsAsleep - When true, the body is added in a sleeping state.
+ * @returns The created physics body handle.
+ */
+export declare function createPhysicsBody(world: PhysicsWorld, node: SceneNode, motionType: PhysicsMotionType, startsAsleep?: boolean): PhysicsBody;
+
+/**
+ * Creates a collision shape (sphere, box, capsule, or cylinder) from the given options.
+ * @param world - The physics world.
+ * @param options - The shape type and its geometry parameters.
+ * @returns The created shape handle.
+ */
+export declare function createPhysicsShape(world: PhysicsWorld, options: PhysicsShapeOptions): PhysicsShape;
+
+/** Create a plane (unit quad facing -Z). Caller must assign material. */
+export declare function createPlane(engine: EngineContext, options?: PlaneOptions): Mesh;
+
+/**
+ * Creates a point light that emits in all directions from `position` with distance falloff.
+ * @param position - World-space position of the light.
+ * @param intensity - Scalar multiplier applied to the light's diffuse and specular contribution.
+ * @returns Plain `PointLight` data to be added to a scene via `addToScene`.
+ */
+export declare function createPointLight(position: [number, number, number], intensity?: number): PointLight;
+
+/** Create a polyhedron (15 presets). Caller must assign material. */
+export declare function createPolyhedron(engine: EngineContext, options?: PolyhedronOptions): Mesh;
+
+/**
+ * Creates a Gaussian Splatting mesh with `splatCount` placeholder splats and attaches
+ * it to the scene's render pipeline. Useful for procedurally filling splat data later.
+ * @param scene - Scene that owns and renders the mesh.
+ * @param name - Mesh name.
+ * @param splatCount - Number of splats to allocate.
+ * @param fragments - Optional custom shader fragments for the splat material.
+ * @returns The created, scene-attached Gaussian Splatting mesh.
+ */
+export declare function createProceduralGaussianSplattingMesh(scene: SceneContext, name: string, splatCount: number, fragments?: readonly GsShaderFragment[]): GaussianSplattingMesh;
+
+/** Compiles a set of track definitions into a reusable {@link PropertyAnimationClip}.
+ *  @param name - Clip name.
+ *  @param tracks - One or more track definitions; their keyframes are sorted and baked into samplers.
+ *  @param options - Optional default frame rate.
+ *  @returns The compiled clip, with its duration set to the longest track.
+ *  @throws If no tracks are provided. */
+export declare function createPropertyAnimationClip(name: string, tracks: readonly PropertyAnimationTrackOptions[], options?: PropertyAnimationClipOptions): PropertyAnimationClip;
+
+/** Binds `clip` to `target`'s properties, creates a playing animation group, and attaches it to `manager`.
+ *  @param manager - Animation manager that drives the resulting group.
+ *  @param target - Object whose properties (resolved by each track's dotted path) are animated.
+ *  @param clip - Compiled clip to play.
+ *  @param options - Optional looping, speed, and play-range overrides.
+ *  @returns The started animation group.
+ *  @throws If the resolved play range does not have `toTime` greater than `fromTime`. */
+export declare function createPropertyAnimationGroup(manager: AnimationManager, target: object, clip: PropertyAnimationClip, options?: CreatePropertyAnimationGroupOptions): AnimationGroup;
+
+/** Options for {@link createPropertyAnimationGroup}, controlling looping, speed, and play range. */
+export declare interface CreatePropertyAnimationGroupOptions {
+    readonly loop?: boolean;
+    readonly speedRatio?: number;
+    readonly fromFrame?: number;
+    readonly toFrame?: number;
+    readonly fromTime?: number;
+    readonly toTime?: number;
+}
+
+/** Create a render target descriptor (GPU textures allocated by `buildRenderTarget`). */
+export declare function createRenderTarget(descriptor: RenderTargetDescriptor): RenderTarget;
+
+/** Eagerly allocate a render target's GPU textures and return a sampled-texture
+ *  view of the color attachment, or the depth attachment for depth-only targets.
+ *  Marks the RT so `buildRenderTarget` won't realloc.
+ *
+ *  The descriptor's size MUST be fixed (not `"canvas"`) because the canvas size
+ *  may change before the frame graph builds, which would invalidate the eagerly-
+ *  created texture handle that downstream bind groups have already captured. */
+export declare function createRenderTargetTexture(engine: EngineContext, descriptor: RenderTargetDescriptor): {
+    rt: RenderTarget;
+    texture: Texture2D;
+};
+
+/** Create a render pass task. GPU resources (target textures + descriptor)
+ *  are not allocated until `record()` runs (via `frameGraph.build()`).
+ *
+ *  Swapchain-targeted tasks acquire the swap view per-frame at execute time. */
+export declare function createRenderTask(config: RenderTaskConfig, engine: EngineContext, scene: SceneContext): RenderTask;
+
+/** Create a ribbon from an array of parallel Vec3 paths. Caller must assign material. */
+export declare function createRibbon(engine: EngineContext, options: RibbonOptions): Mesh;
+
+/** Create an empty scene context bound to the given engine. */
+export declare function createSceneContext(engine: EngineContext, options?: SceneContextOptions): SceneContext;
+
+/** Create a ShaderMaterial from WGSL sources and declarations, validating
+ *  attributes, uniforms, samplers, and defines.
+ *  @param options - Sources, attributes, uniforms, samplers, defines, and render state.
+ *  @returns The constructed `ShaderMaterial`. */
+export declare function createShaderMaterial(options: ShaderMaterialOptions): ShaderMaterial;
+
+/** Create a 1×1 solid-color `Texture2D` from straight RGBA components in [0, 1].
+ *  @param engine - Engine context.
+ *  @param r - Red channel (0–1).
+ *  @param g - Green channel (0–1).
+ *  @param b - Blue channel (0–1).
+ *  @param a - Alpha channel (0–1). Default 1.0.
+ *  @returns A bilinear-sampled `Texture2D` backed by a tiny GPU texture. */
+export declare function createSolidTexture2D(engine: EngineContext, r: number, g: number, b: number, a?: number): Texture2D;
+
+/** Create a sphere mesh. Caller must assign material. */
+export declare function createSphere(engine: EngineContext, options?: SphereOptions): Mesh;
+
+/** Generate UV sphere geometry matching Babylon's CreateSphere exactly.
+ *  Babylon uses: totalZ = 2 + segments rows, totalY = 2 * totalZ columns.
+ *  Default: 32 segments → 35×69 = 2415 vertices. */
+export declare function createSphereData(options?: SphereOptions): SphereMeshData;
+
+/**
+ * Creates a spot light: a cone of light from `position` aimed along `direction`.
+ * @param position - World-space position of the light.
+ * @param direction - World-space direction the cone points along.
+ * @param angle - Full cone angle in radians.
+ * @param exponent - Falloff exponent; higher values produce a sharper edge.
+ * @param intensity - Scalar multiplier applied to the light's diffuse and specular contribution.
+ * @returns Plain `SpotLight` data to be added to a scene via `addToScene`.
+ */
+export declare function createSpotLight(position: [number, number, number], direction: [number, number, number], angle: number, exponent: number, intensity?: number): SpotLight;
+
+/**
+ * Create a custom fragment shader for a sprite layer. Pass the result as the `customShader`
+ * option of `createSprite2DLayer`. See the module-level docs for the WGSL contract.
+ */
+export declare function createSprite2DCustomShader(options: Sprite2DCustomShaderOptions): Sprite2DCustomShader;
+
+/** Create a new (empty) `Sprite2DLayer` backed by `atlas`. */
+export declare function createSprite2DLayer(atlas: SpriteAtlas, opts?: Sprite2DLayerOptions): Sprite2DLayer;
+
+/**
+ * Creates an empty sprite animation manager.
+ * @param options - Optional fixed time step and per-tick update callback.
+ * @returns The new manager.
+ */
+export declare function createSpriteAnimationManager(options?: SpriteAnimationManagerOptions): SpriteAnimationManager;
+
+/**
+ * Pack `sources` into a single `SpriteAtlas`. Shelf-packs in input order: each
+ * frame is placed left-to-right on the current shelf, wrapping to a new shelf
+ * (row) when it would overflow `maxWidthPx`. The texture is sized exactly to the
+ * packed content.
+ */
+export declare function createSpriteAtlasFromFrames(engine: EngineContext, sources: readonly SpriteAtlasFrameSource[], options?: SpriteAtlasPackOptions): SpriteAtlas;
+
+/**
+ * Creates a sprite frame animation and immediately shows its first frame.
+ * @param target - Sprite the animation drives.
+ * @param from - First frame index of the range.
+ * @param to - Last frame index of the range; may be less than `from` to play in reverse.
+ * @param loop - When `true`, the animation restarts after reaching `to`.
+ * @param delayMs - Delay in milliseconds between frame steps.
+ * @param options - Optional end callback and removal behaviour.
+ * @returns The new animation, not yet attached to any manager.
+ * @throws If `from` or `to` is not finite.
+ */
+export declare function createSpriteFrameAnimation(target: SpriteAnimationTarget, from: number, to: number, loop: boolean, delayMs: number, options?: PlaySpriteAnimationOptions): SpriteFrameAnimation;
+
+/** Create a `SpriteRenderer` for `engine`, pre-warming pipelines for the layers' blend modes. */
+export declare function createSpriteRenderer(engine: EngineContext, opts: SpriteRendererOptions): SpriteRenderer;
+
+/** Create StandardMaterial with Babylon defaults. */
+export declare function createStandardMaterial(): StandardMaterialProps;
+
+/** Create a no-color view over a Standard source material.
+ *  The view references the source; material state is never copied. */
+export declare function createStandardNoColorMaterialView(source: StandardMaterialProps): MaterialView;
+
+/**
+ * Create a `Texture2D` from a tightly-packed RGBA8 byte buffer.
+ *
+ * @param engine - Engine context.
+ * @param data - `width * height * 4` bytes, row-major, top-to-bottom, straight alpha.
+ * @param width - Texture width in pixels (\>= 1).
+ * @param height - Texture height in pixels (\>= 1).
+ * @param options - Sampler / format overrides.
+ */
+export declare function createTexture2DFromPixels(engine: EngineContext, data: Uint8Array, width: number, height: number, options?: PixelsTexture2DOptions): Texture2D;
+
+/** Create a torus mesh. Caller must assign material. */
+export declare function createTorus(engine: EngineContext, options?: TorusOptions): Mesh;
+
+/** Create a TransformNode (SceneNode) with TRS values and lazy world matrix.
+ *  Parameters: name, position (px,py,pz), rotation quaternion (qx,qy,qz,qw), scaling (sx,sy,sz). */
+export declare function createTransformNode(name: string, px?: number, py?: number, pz?: number, qx?: number, qy?: number, qz?: number, qw?: number, sx?: number, sy?: number, sz?: number): TransformNode;
+
+/** Create a tube (circular cross-section swept along a path). Caller must assign material. */
+export declare function createTube(engine: EngineContext, options: TubeOptions): Mesh;
+
+/**
+ * Create a frame-graph task that draws a uniform-only effect as a fullscreen pass into `config.target`.
+ * @param config - The effect, target, and clear settings.
+ * @param engine - The owning engine.
+ * @param scene - Optional owning scene. Omit for scene-less standalone frame graphs.
+ * @returns The render task to add to a frame graph.
+ */
+export declare function createUniformEffectRenderTask(config: UniformEffectRenderTaskConfig, engine: EngineContext, scene?: SceneContext): UniformEffectRenderTask;
+
+/**
+ * Create a lightweight fullscreen effect with exactly one uniform buffer at binding 0.
+ * @param engine - The engine that owns the GPU resources.
+ * @param options - Shader source and uniform-buffer byte length.
+ * @returns The new uniform effect wrapper.
+ */
+export declare function createUniformEffectWrapper(engine: EngineContext, options: UniformEffectWrapperOptions): UniformEffectWrapper;
+
+/** Cross-fades from `fromGroup` to `toGroup`, fading the first to weight 0 and the second to `options.toWeight` (default 1). */
+export declare function crossFadeAnimationGroups(manager: AnimationManager, fromGroup: AnimationGroup, toGroup: AnimationGroup, options: CrossFadeAnimationGroupsOptions): void;
+
+/** Options for {@link crossFadeAnimationGroups}. */
+export declare interface CrossFadeAnimationGroupsOptions {
+    readonly durationMs: number;
+    readonly toWeight?: number;
+}
+
+/** Returns the boolean union (`a` ∪ `b`) of two solids as a new solid. */
+export declare function csg2Add(a: Csg2Solid, b: Csg2Solid): Csg2Solid;
+
+/** Returns the boolean intersection (`a` ∩ `b`) of two solids as a new solid. */
+export declare function csg2Intersect(a: Csg2Solid, b: Csg2Solid): Csg2Solid;
+
+/** A manifold-3d backed CSG solid for high-precision boolean mesh operations. */
+export declare interface Csg2Solid {
+    readonly [csg2SolidBrand]: true;
+
+declare const csg2SolidBrand: unique symbol;
+
+/** Returns the boolean difference (`a` − `b`) of two solids as a new solid. */
+export declare function csg2Subtract(a: Csg2Solid, b: Csg2Solid): Csg2Solid;
+
+/**
+ * Returns the boolean intersection (`a` ∩ `b`) of two solids.
+ * @returns A new solid; inputs are not modified.
+ */
+export declare function csgIntersect(a: CsgSolid, b: CsgSolid): CsgSolid;
+
+/** An immutable BSP-based CSG solid (set of polygons) for boolean mesh operations. */
+export declare interface CsgSolid {
+    readonly [csgSolidBrand]: true;
+
+declare const csgSolidBrand: unique symbol;
+
+/**
+ * Returns the boolean difference (`a` − `b`) of two solids.
+ * @returns A new solid; inputs are not modified.
+ */
+export declare function csgSubtract(a: CsgSolid, b: CsgSolid): CsgSolid;
+
+/**
+ * Returns the boolean union (`a` ∪ `b`) of two solids.
+ * @returns A new solid; inputs are not modified.
+ */
+export declare function csgUnion(a: CsgSolid, b: CsgSolid): CsgSolid;
+
+/** One extra texture bound after the atlas. In WGSL it becomes `<name>Tex` + `<name>Samp`. */
+export declare interface CustomShaderTexture {
+    /** Identifier used in WGSL: becomes `<name>Tex` (texture) and `<name>Samp` (sampler). */
+    readonly name: string;
+    readonly texture: Texture2D;
+}
+
+/** Options for `createCylinderData`. Subset of Babylon's CreateCylinder. */
+export declare interface CylinderOptions {
+    height?: number;
+    diameter?: number;
+    diameterTop?: number;
+    diameterBottom?: number;
+    tessellation?: number;
+    subdivisions?: number;
+}
+
+export declare interface DirectionalLight extends LightBase {
+    readonly lightType: "directional";
+    direction: ObservableVec3;
+    position: ObservableVec3;
+    diffuse: [number, number, number];
+    specular: [number, number, number];
+    intensity: number;
+}
+
+/** Options for `createDiscData`. Subset of Babylon's CreateDisc. */
+export declare interface DiscOptions {
+    radius?: number;
+    tessellation?: number;
+    /** Fraction of circumference (`0 < arc ≤ 1`). Default 1 (full disc). */
+    arc?: number;
+}
+
+/** Frees the WASM memory backing a solid. The solid must not be used afterwards. */
+export declare function disposeCsg2(solid: Csg2Solid): void;
+
+/** Unregister and free all GPU resources owned by the renderer. */
+export declare function disposeEffectRenderer(er: EffectRenderer): void;
+
+/** Destroy the uniform buffers and clear the cached pipelines, bind groups, and slots owned by the effect wrapper. */
+export declare function disposeEffectWrapper(wrapper: EffectWrapper): void;
+
+/** Release all engine-owned GPU resources (device + swapchain). Rendering contexts
+ *  own their own GPU resources (frame graphs, render targets) and dispose them
+ *  separately. */
+export declare function disposeEngine(engine: EngineContext): void;
+
+/** Unregister and dispose all GPU resources owned by the standalone frame graph. */
+export declare function disposeFrameGraphContext(ctx: FrameGraphContext): void;
+
+/**
+ * Removes and releases all bodies, then releases the native world. Call once when tearing down physics.
+ * @param world - The physics world to dispose.
+ */
+export declare function disposePhysics(world: PhysicsWorld): void;
+
+/** Dispose GPU resources owned by this picker. */
+export declare function disposePicker(picker: GpuPicker): void;
+
+/** Release all GPU resources owned by this scene. */
+export declare function disposeScene(scene: SceneContext): void;
+
+/**
+ * Detaches a binding created by {@link attachSpriteAnimationsToScene} or
+ * {@link attachSpriteAnimationsToRenderer}. Safe to call more than once.
+ * @param binding - Binding to dispose.
+ */
+export declare function disposeSpriteAnimationBinding(binding: SpriteAnimationBinding): void;
+
+/**
+ * Destroy all GPU resources owned by the renderer, unregister it from the engine, and clear `layers`.
+ * Idempotent. To tie disposal to a scene, call
+ * `onSceneDispose(scene, () => disposeSpriteRenderer(sr))` after `registerSpriteRenderer` —
+ * see the `SpriteRenderer` doc-comment.
+ */
+export declare function disposeSpriteRenderer(sr: SpriteRenderer): void;
+
+/** Destroy the uniform buffer and clear cached GPU objects owned by the uniform effect wrapper. */
+export declare function disposeUniformEffectWrapper(wrapper: UniformEffectWrapper): void;
+
+/**
+ * A per-pass draw binding produced by `Renderable.bind(engine, target)`.
+ *
+ * Target-specific GPU state (resolved pipeline(s), sceneBG, etc.) is captured in the
+ * `draw` closure so the binding itself has no material-specific payload. The same
+ * `Renderable` can be bound multiple times (once per pass it participates in) with
+ * a separate `DrawBinding` each time.
+ */
+export declare interface DrawBinding {
+    /** Back-reference for sort/eviction (order, mesh identity). */
+    readonly renderable: Renderable;
+    /** Pipeline used by this binding. The render pass task owns setPipeline()
+     *  and dedups consecutive bindings with the same pipeline. */
+    readonly pipeline: GPURenderPipeline;
+    /** Issue draw commands for this renderable into `pass`. The render pass task has
+     *  already set the scene bind group (group 0) and `pass.setPipeline(pipeline)` if
+     *  it changed. The closure handles per-mesh / per-material bind groups,
+     *  vertex/index buffers, and drawIndexed. Returns the number of GPU draw calls. */
+    draw(pass: GPURenderPassEncoder | GPURenderBundleEncoder, engine: EngineContext): number;
+    /** Update dirty per-pass state before draw. Called once per frame per binding.
+     *  Per-mesh state (e.g. world matrix) shared across bindings should be
+     *  version-guarded to avoid redundant writes. Render task transparent sorting
+     *  runs after these updates, so renderables may refresh `_worldCenter` here. */
+    update?(context: DrawUpdateContext): void;
+
+/** Dynamic per-pass data available before a binding draws. */
+export declare interface DrawUpdateContext {
+    readonly targetWidth: number;
+    readonly targetHeight: number;
+
+/** Kind of GPU binding an effect exposes: a uniform buffer, a sampled texture, or a sampler. */
+export declare type EffectBindingKind = "uniform" | "texture" | "sampler";
+
+/** Describes a single bind-group entry (binding slot, kind, and type details) for an effect wrapper. */
+export declare interface EffectBindingLayout {
+    name?: string;
+    binding: number;
+    kind: EffectBindingKind;
+    visibility?: GPUShaderStageFlags;
+    uniformByteLength?: number;
+    textureSampleType?: GPUTextureSampleType;
+    samplerType?: GPUSamplerBindingType;
+    textureBinding?: string | number;
+}
+
+/**
+ * `EffectRenderer` — a fullscreen-effect `RenderingContext` that draws
+ * directly to the swapchain without a `SceneContext` or frame-graph task.
+ * Use `registerEffectRenderer` / `unregisterEffectRenderer` to attach it to
+ * an engine, then call `startEngine` as usual.
+ *
+ * For offscreen render-to-texture workflows (effect result consumed by a
+ * scene material) continue to use `createEffectRenderTask` inside a scene
+ * frame graph.
+ */
+export declare interface EffectRenderer extends RenderingContext_2 {
+    readonly name: string;
+}
+
+/** Options for `createEffectRenderer`. */
+export declare interface EffectRendererOptions {
+    /** Label for GPU resources. Defaults to the effect's own name. */
+    name?: string;
+    /** Whether to clear the swapchain before drawing. Defaults to `true`. */
+    clear?: boolean;
+    /** Clear colour. Defaults to opaque black. */
+    clearColor?: GPUColorDict;
+    /**
+     * Per-frame callback invoked just before the effect is drawn, receiving the
+     * frame delta in milliseconds. Use it to update uniforms (e.g. time, animation
+     * state). This is the effect-path equivalent of a scene's `onBeforeRender`.
+     */
+    update?: (deltaMs: number) => void;
+}
+
+/** A frame-graph task that renders an `EffectWrapper` as a fullscreen pass into an offscreen `RenderTarget`. */
+export declare interface EffectRenderTask extends Task {
+    readonly name: string;
+
+/** Configuration for `createEffectRenderTask`: the effect to draw, its render target, and optional clear state. */
+export declare interface EffectRenderTaskConfig {
+    name: string;
+    effect: EffectWrapper;
+    target: RenderTarget;
+    clear?: boolean;
+    clearColor?: GPUColorDict;
+}
+
+/** A reusable fullscreen effect: owns its shader module, bind-group layout, pipelines, and uniform/texture slots. */
+export declare interface EffectWrapper {
+    readonly name: string;
+    readonly options: EffectWrapperOptions;
+}
+
+/** Configuration for `createEffectWrapper`: the fullscreen fragment shader plus optional vertex shader, bindings, and blend state. */
+export declare interface EffectWrapperOptions {
+    name?: string;
+    fragmentWGSL: string;
+    vertexWGSL?: string;
+    bindings?: EffectBindingLayout[];
+    blend?: GPUBlendState;
+}
+
+/** Enable advanced animation blending for a manager. Kept opt-in so manual-only weights do not pay for skeletal mixing code. */
+export declare function enableAnimationBlending(manager: AnimationManager): void;
+
+/**
+ * Enable detailed picking on a GPU picker.
+ * When enabled, pickAsync() will compute faceId, bu, bv
+ * by performing CPU ray-triangle intersection on the identified mesh.
+ * Requires meshes to have _cpuPositions and _cpuIndices set.
+ */
+export declare function enableDetailedPicking(picker: GpuPicker): void;
+
+/** Enable automatic dirty tracking on a PBR or Standard material.
+ *  After calling this, any UBO-backed property mutation marks the source material UBO dirty. */
+export declare function enableMaterialTracking(material: Material & {
+    specularPower?: unknown;
+}): Promise<void>;
+
+/** Enables weighted property-animation blending on `manager` by registering its category handler. */
+export declare function enablePropertyAnimationBlending(manager: AnimationManager): void;
+
+/** Enable or disable GPU frustum culling for an existing thin-instanced mesh.
+ *
+ * Call this after `setThinInstances()`/`addThinInstance()` and before `registerScene()`.
+ * The render system keeps the feature opt-in so non-culled thin-instance scenes do not
+ * fetch the compute-culling module or allocate compacted visible-instance buffers.
+ */
+export declare function enableThinInstanceGpuCulling(mesh: Mesh, enabled?: boolean): void;
+
+/** CPU helper matching BJS `GaussianSplattingGpuPickingMaterialPlugin.EncodeIdToColor`. */
+export declare function encodeIdToColor(id: number): [number, number, number];
+
+/** Handle to the WebGPU engine — pure state, no attached methods. */
+export declare interface EngineContext {
+    readonly canvas: RenderCanvas;
+    readonly msaaSamples: number;
+    /** Preferred GPU texture format for the swapchain. Use as the `colorFormat`
+     *  for offscreen RTs that are sampled by main-pass materials. */
+    readonly format: GPUTextureFormat;
+    /** Number of GPU draw calls in the last rendered frame. */
+    drawCallCount: number;
+    /** Clamps the effective device pixel ratio used for the swapchain backing store.
+     *  The backing store is sized at `min(devicePixelRatio, maxDevicePixelRatio) * cssPixels`.
+     *  `maxDevicePixelRatio = 1` renders at native CSS-pixel resolution (no DPR upscaling);
+     *  the default `Infinity` is unclamped (full devicePixelRatio). Mutable at runtime — set
+     *  before the next `resizeEngine` to take effect (mirrors `setHardwareScalingRatio`). */
+    maxDevicePixelRatio: number;
+
+/**
+ * Options for `createEngine`.
+ * - `msaaSamples`: number of MSAA samples to use for the main render pass.
+ *   WebGPU only permits `1` (no MSAA) or `4` (4x MSAA) per the spec
+ *   (2x is not a valid WebGPU sample count). Defaults to `4`.
+ */
+export declare interface EngineOptions {
+    msaaSamples?: 1 | 4;
+    /**
+     * WebGPU canvas alpha mode. Use "premultiplied" to enable canvas transparency (clear color
+     * with `alpha < 1` will let HTML content underneath show through). Defaults to "opaque".
+     */
+    alphaMode?: GPUCanvasAlphaMode;
+    /**
+     * Clamps the effective device pixel ratio used for the swapchain backing store.
+     * The backing store is sized at `min(devicePixelRatio, maxDevicePixelRatio) * cssPixels`.
+     * `maxDevicePixelRatio: 1` renders at native CSS-pixel resolution (no DPR upscaling) —
+     * useful on high-DPI/iOS devices where `devicePixelRatio` is ~3. Defaults to unclamped
+     * (full devicePixelRatio). Equivalent to Babylon.js `setHardwareScalingRatio`.
+     */
+    maxDevicePixelRatio?: number;
+}
+
+/** GPU-resident environment textures. */
+export declare interface EnvironmentTextures {
+    specularCube: GPUTexture;
+    specularCubeView: GPUTextureView;
+    brdfLut: GPUTexture;
+    brdfLutView: GPUTextureView;
+    cubeSampler: GPUSampler;
+    brdfSampler: GPUSampler;
+    irradianceSH: Float32Array;
+    /** Pre-scaled SH coefficients for shader, 36 floats in stride-4 layout:
+     *  [L00.rgb, 0, L1_1.rgb, 0, L10.rgb, 0, L11.rgb, 0, L2_2.rgb, 0,
+     *   L2_1.rgb, 0, L20.rgb, 0, L21.rgb, 0, L22.rgb, 0] */
+    sphericalHarmonics: Float32Array;
+    /** LOD generation scale for specular IBL sampling. Default 0.8 (matches BJS BaseTexture). */
+    lodGenerationScale: number;
+}
+
+/** Configuration for a directional-light ESM shadow generator: map size, depth scale, blur kernel, darkness, and ortho projection bounds. */
+export declare interface EsmDirectionalShadowGeneratorConfig {
+    mapSize?: number;
+    depthScale?: number;
+    bias?: number;
+    /** Kernel blur sample region in pixels. Matches Babylon.js ShadowGenerator.blurKernel. Default 1. */
+    blurKernel?: number;
+    blurScale?: number;
+    darkness?: number;
+    frustumEdgeFalloff?: number;
+    /** Ortho projection min Z — typically camera.nearPlane. Default 1. */
+    orthoMinZ?: number;
+    /** Ortho projection max Z — typically camera.farPlane. Default 10000. */
+    orthoMaxZ?: number;
+    /** Force the shadow map to be regenerated every frame. Default false. */
+    forceRefreshEveryFrame?: boolean;
+}
+
+/** Bidirectional Euler XYZ view over a quaternion.
+ *  Reads decompose the current quaternion on the fly; writes convert Euler→quat atomically. */
+declare interface EulerProxy {
+    x: number;
+    y: number;
+    z: number;
+    set(x: number, y: number, z: number): void;
+}
+
+/** A post-process task that keeps only pixels whose luminance exceeds `threshold` and zeroes the rest. */
+export declare interface ExtractHighlightsPostProcessTask extends PostProcessTask {
+    threshold: number;
+    exposure: number;
+}
+
+/** Configuration for `createExtractHighlightsPostProcessTask`: luminance `threshold` and `exposure` applied before thresholding. */
+export declare interface ExtractHighlightsPostProcessTaskConfig extends Omit<PostProcessTaskConfig, "_shader"> {
+    threshold?: number;
+    exposure?: number;
+}
+
+/** Options for `createExtrudeShapeData`: a 2D `shape` swept along a 3D `path`. */
+export declare interface ExtrudeShapeOptions {
+    shape: Vec3[];
+    path: Vec3[];
+    scale?: number;
+    rotation?: number;
+    cap?: number;
+}
+
+/** A camera-facing billboard sprite system. */
+export declare type FacingBillboardSpriteSystem = BillboardSpriteSystem<"facing">;
+
+/** Animates `group`'s blend weight toward `options.to` over `options.durationMs`, enabling blending on `manager`.
+ *  @throws If `to`/`from` are outside `[0, 1]` or the duration is not a finite positive number. */
+export declare function fadeAnimationWeight(manager: AnimationManager, group: AnimationGroup, options: FadeAnimationWeightOptions): void;
+
+/** Options for {@link fadeAnimationWeight}. */
+export declare interface FadeAnimationWeightOptions {
+    readonly to: number;
+    readonly durationMs: number;
+    readonly from?: number;
+}
+
+/** Return any random point on the navmesh. */
+export declare function findRandomPoint(plugin: NavigationPlugin): Vec3;
+
+/**
+ * Return a random point on the navmesh inside a circle of `radius` around `position`.
+ * Determinism: seeded by Recast's internal RNG; call `setNavigationRandomSeed`
+ * to make results reproducible across runs.
+ */
+export declare function findRandomPointAroundCircle(plugin: NavigationPlugin, position: Vec3, radius: number): Vec3;
+
+/** Mark thin instance data dirty after direct array manipulation. */
+export declare function flushThinInstances(mesh: Mesh): void;
+
+/** Fog configuration — plain data. */
+export declare interface FogConfig {
+    mode: 0 | 1 | 2 | 3;
+    density: number;
+    start: number;
+    end: number;
+    color: [number, number, number];
+}
+
+/** The frame graph — an ordered list of tasks. */
+export declare interface FrameGraph {
    /** Build (or rebuild) every task in execute order. */
+    build(): void;
+    /** Execute every task's recorded passes. Returns total draw calls. */
+    execute(): number;
+    /** Free all GPU resources owned by the frame graph. */
+    dispose(): void;
+}
+
+/** A scene-less rendering context driven directly by a FrameGraph. */
+export declare interface FrameGraphContext extends RenderingContext_2 {
+    readonly name: string;
+    readonly engine: EngineContext;
+    readonly frameGraph: FrameGraph;
+    clearColor: GPUColorDict;
+}
+
+/** Options for a standalone frame-graph rendering context. */
+export declare interface FrameGraphContextOptions {
+    /** Label used for diagnostics and GPU resource naming. */
+    name?: string;
+    /** Context clear color metadata; individual tasks still control their own render-target clears. */
+    clearColor?: GPUColorDict;
+    /** Per-frame callback invoked before the frame graph executes; use it to update uniforms or other task inputs. */
+    update?: (deltaMs: number) => void;
+}
+
+/** FreeCamera — positioned in world space, looking at a target point.
+ *  Matches Babylon.js FreeCamera: position + target, left-handed.
+ *  Plain data + methods. Does NOT know about the scene.
+ *
+ *  Push-based dirty tracking: position and target use ObservableVec3,
+ *  _yaw/_pitch use Object.defineProperty. */
+export declare interface FreeCamera extends Camera, IWorldMatrixProvider, IParentable {
+    position: ObservableVec3;
+    target: ObservableVec3;
+    /** Movement speed. Default 2.0 (matches BJS). */
+    speed: number;
+    /** Mouse rotation sensitivity (higher = less sensitive). Default 2000 (matches BJS). */
+    angularSensitivity: number;
+    /** Inertia damping factor (0 = instant stop, 0.9 = smooth). Default 0.9 (matches BJS). */
+    inertia: number;
+    parent: IWorldMatrixProvider | null;
+    readonly worldMatrix: Mat4;
+    readonly worldMatrixVersion: number;
+
+/** Public Gaussian-splatting mesh handle.  `_kind` is a brand so consumers can
+ *  narrow on it; the renderable is wired up by `loadSplat()` directly. */
+export declare interface GaussianSplattingMesh extends SceneNode {
    /** Number of splats in the cloud. */
+    readonly vertexCount: number;
+    /** RGBA32F texture dimensions used for centers/covA/covB/colors. */
+    readonly textureWidth: number;
+    readonly textureHeight: number;
+    /** World-space AABB across all splat centres (for camera framing). */
+    boundMin: [number, number, number];
+    boundMax: [number, number, number];
+    /** Spherical-harmonics degree (0 means no view-dependent SH). Set at load
+     *  time and immutable afterwards — `updateData` rejects a degree change. */
+    readonly shDegree: number;
    /** Resolves on the first sort completion. The lab scene awaits this
+     *  before flagging `dataset.ready`. */
+    readonly firstSortReady: Promise<void>;
    /** Raw 32-byte/splat row buffer. Mirrors BJS `splatsData` (with
+     *  `keepInRam:true`) — exposed for inspection + `updateData` round-trips. */
+    readonly splatsData: ArrayBuffer;
+    /** Replace the splat data in place. Re-uploads centres / covariance /
+     *  colour textures, re-posts positions to the sort worker, and updates the
+     *  AABB. Vertex count must match the original buffer. Mirrors BJS
+     *  `GaussianSplattingMesh.updateData(buffer, _sh, opts)`. */
+    updateData(splatBuffer: ArrayBuffer): void;
+}
+
+/** Get the current world position of an agent. */
+export declare function getAgentPosition(crowd: NavCrowd, index: number): Vec3;
+
+/** Get the current world-space velocity of an agent. */
+export declare function getAgentVelocity(crowd: NavCrowd, index: number): Vec3;
+
+/** Returns the animation groups currently attached to `manager`, or an empty array if none. */
+export declare function getAnimationGroups(manager: AnimationManager): readonly AnimationGroup[];
+
+/**
+ * Resolves the current instance index of the sprite referenced by `handle`.
+ * @param handle - Handle of the sprite to resolve.
+ * @returns The current instance index in the system's buffers.
+ * @throws If the handle has already been removed.
+ */
+export declare function getBillboardSpriteHandleIndex(handle: BillboardSpriteHandle): number;
+
+/** Get the world-space position of a camera. */
+export declare function getCameraPosition(camera: Camera): Vec3;
+
+/** Snap a position to the closest point on the navmesh. */
+export declare function getClosestPoint(plugin: NavigationPlugin, position: Vec3): Vec3;
+
+/** Returns the render-target aspect ratio adjusted for the camera's normalized viewport, or the raw ratio if none. */
+export declare function getEffectiveAspectRatio(camera: Camera | null | undefined, targetWidth: number, targetHeight: number): number;
+
+/** Get the scene's frame graph. Always non-null — created in `createSceneContext`. */
+export declare function getFrameGraph(scene: SceneContext): FrameGraph;
+
+/** Get the current seed used by Recast's randomized queries. */
+export declare function getNavigationRandomSeed(plugin: NavigationPlugin): number;
+
+/**
+ * Returns the world's current gravity vector.
+ * @param world - The physics world.
+ * @returns Gravity acceleration in m/s².
+ */
+export declare function getPhysicsGravity(world: PhysicsWorld): Vec3;
+
+/**
+ * Returns the world's fixed simulation timestep in seconds.
+ * @param world - The physics world.
+ * @returns The timestep in seconds.
+ */
+export declare function getPhysicsTimestep(world: PhysicsWorld): number;
+
+/**
+ * Returns the world's current maximum linear and angular speed limits.
+ * @param world - The physics world.
+ * @returns The `maxLinear` and `maxAngular` speed limits.
+ */
+export declare function getPhysicsVelocityLimits(world: PhysicsWorld): {
+    maxLinear: number;
+    maxAngular: number;
+};
+
+/**
+ * Get the interpolated normal at the picked point.
+ * Requires detailed picking (`faceId >= 0`) and mesh._cpuNormals.
+ * @param useWorldCoordinates - if true, transform normal by world matrix (default: false)
+ */
+export declare function getPickedNormal(info: PickingInfo, useWorldCoordinates?: boolean): [number, number, number] | null;
+
+/**
+ * Get the interpolated UV coordinates at the picked point.
+ * Requires detailed picking (`faceId >= 0`) and mesh._cpuUvs.
+ */
+export declare function getPickedUV(info: PickingInfo): [number, number] | null;
+
+/** Compute the projection matrix for a camera. Cached per worldMatrixVersion + aspect. */
+export declare function getProjectionMatrix(camera: Camera, aspectRatio: number): Mat4;
+
+/**
+ * Resolves the current instance index of the sprite referenced by `handle`.
+ * @param handle - Handle of the sprite to resolve.
+ * @returns The current instance index in the layer's buffers.
+ * @throws If the handle has already been removed.
+ */
+export declare function getSprite2DHandleIndex(handle: Sprite2DHandle): number;
+
+/**
+ * Get available variant names from a loaded glTF asset.
+ * Returns an empty array if the asset has no material variants.
+ */
+export declare function getVariantNames(container: AssetContainer): readonly string[];
+
+/** Compute the view matrix for a camera. Cached per worldMatrixVersion. */
+export declare function getViewMatrix(camera: Camera): Mat4;
+
+/** Compute the view-projection matrix for a camera. Cached per worldMatrixVersion + aspect. */
+export declare function getViewProjectionMatrix(camera: Camera, aspectRatio: number): Mat4;
+
+/** Everything the animation system needs, parsed from a glTF file. */
+export declare interface GltfAnimationData {
+    readonly clips: readonly AnimationClip[];
+    readonly nodes: readonly NodeRest[];
+    readonly skeletons: readonly SkeletonBinding[];
+    readonly morphBindings: readonly MorphBinding[];
+    /** Scene-node targets indexed by glTF node index. Used to write plain node-TRS
+     *  channels (non-skeletal node animation) back onto the live scene graph so the
+     *  affected meshes — and their descendants — actually move. */
+    readonly nodeTargets: readonly (AnimatedNodeTarget | undefined)[];
+    /** Node indices excluded from node-TRS writeback: skin joints (driven by the
+     *  skeleton path) plus skinned-mesh nodes and all their ancestors (their bone
+     *  matrices bake an `invMeshWorld` captured at load, so moving them at runtime
+     *  would double-transform the skinned vertices). */
+    readonly excludedNodeIndices: ReadonlySet<number>;
+}
+
+/** Seek to a specific frame, apply the pose, and pause. */
+export declare function goToFrame(group: AnimationGroup, frame: number, engine?: EngineContext): void;
+
+/** GPU-based picker — pure state. Use pickAsync() and disposePicker() standalone functions. */
+export declare interface GpuPicker {
+
+/** Options for `createGridSpriteAtlas`. */
+export declare interface GridAtlasOptions {
+    cellWidthPx: number;
+    cellHeightPx: number;
+    /** Defaults to `floor(textureWidth / cellWidthPx)`. */
+    columns?: number;
+    /** Defaults to `floor(textureHeight / cellHeightPx)`. */
+    rows?: number;
+    marginPx?: number;
+    spacingPx?: number;
+    /** Default `[0.5, 0.5]`. */
+    pivot?: readonly [number, number];
+    premultipliedAlpha?: boolean;
+}
+
+/**
+ * Options for {@link createGridMaterial}. Mirrors Babylon.js `GridMaterial`:
+ * an unlit, procedural object-space grid. All fields are optional and fall back
+ * to the Babylon defaults.
+ */
+export declare interface GridMaterialOptions {
+    readonly name?: string;
+    /** Background color between the lines. Default black `[0,0,0]`. */
+    readonly mainColor?: GridVec3;
+    /** Color of the grid lines. Default teal `[0,0.5,0.5]`. */
+    readonly lineColor?: GridVec3;
+    /** Spacing of the grid in object-space units. Default `1`. */
+    readonly gridRatio?: number;
+    /** Object-space offset added before computing the grid. Default `[0,0,0]`. */
+    readonly gridOffset?: GridVec3;
+    /** Every Nth line is a major line. Rounded with `Math.round`. Default `10`. */
+    readonly majorUnitFrequency?: number;
+    /** Visibility of the minor (non-major) lines, `0..1`. Default `0.33`. */
+    readonly minorUnitVisibility?: number;
+    /** Opacity of the grid outside of the lines. `<1` enables the transparent path. Default `1`. */
+    readonly opacity?: number;
+    /** Cosine-based antialiasing of the lines. Default `true`. */
+    readonly antialias?: boolean;
+    /** Premultiply rgb by alpha (transparent path only). Default `false`. */
+    readonly preMultiplyAlpha?: boolean;
+    /** Combine axes with `max` instead of additive sum. Default `false`. */
+    readonly useMaxLine?: boolean;
+    /** Optional opacity texture; its `.a` channel multiplies the final opacity. */
+    readonly opacityTexture?: Texture2D;
+    /** Per-material visibility multiplier applied to the final alpha. Default `1`. */
+    readonly visibility?: number;
+    /** Cull back faces. Default `true`. */
+    readonly backFaceCulling?: boolean;
+}
+
+/** A 3-component color/vector expressed as a readonly tuple. */
+export declare type GridVec3 = readonly [number, number, number];
+
+/** Options for `createFlatGroundData` and {@link createGroundFromHeightMap}. */
+export declare interface GroundOptions {
+    width?: number;
+    height?: number;
+    subdivisions?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    /** UV scale factor [uScale, vScale]. Multiplies generated UVs for texture tiling. Default [1, 1]. */
+    uvScale?: [number, number];
+}
+
+/** Alpha-blended depth variant (BJS `depthRenderer.alphaBlendedDepth = true`).
+ *  Splat fragments emit `(d, d, d, gaussianAlpha)` so the existing GS pipeline's
+ *  ALPHA_COMBINE blend accumulates a soft-edged grayscale depth visualisation,
+ *  matching BJS `V80DRL#19`. */
+export declare const gsAlphaBlendedDepthFragment: GsShaderFragment;
+
+/** Names of the four WGSL slots a `GsShaderFragment` may inject into the
+ *  Gaussian-splat fragment shader. Markers in the WGSL source look like
+ *  `\/*GS_FRAGMENT_MAIN_END*\/` — valid comments when no plugin is present. */
+export declare type GsFragmentSlot = "GS_FRAGMENT_DEFINITIONS" | "GS_FRAGMENT_MAIN_BEGIN" | "GS_FRAGMENT_BEFORE_FRAGCOLOR" | "GS_FRAGMENT_MAIN_END";
+
+/** Lite port of `GaussianSplattingGpuPickingMaterialPlugin`'s non-compound path:
+ *  declare a `picking` UBO at `@group(2) @binding(0)` (allocated by the picking
+ *  pipeline) and override the fragment colour with the per-mesh pick id. */
+export declare const gsGpuPickingFragment: GsShaderFragment;
+
+/** Force-depth-write variant (BJS `forceDepthWriteTransparentMeshes = true`).
+ *  Matches BJS's `gaussianSplattingDepth.fragment.fx` default (no `ALPHA_BLENDED_DEPTH`)
+ *  branch exactly:
+ *
+ * ```
+ *      // base WGSL has `let A = -dot(in.vPos, in.vPos);` and `in.vColor.a = splat.color.a * material.alpha`
+ *      if (A < -in.vColor.a) { discard; }                  // ↔ if dot(vPos,vPos) > vColor.a
+ *      finalColor = vec4(linearDepth, linearDepth, linearDepth, 1.0);
+ * ```
+ *
+ *  Per-splat α is used as a *squared-radius* threshold in the splat-local 2D
+ *  quad coordinate (`vPos ∈ [-1,1]²`), so each splat clips to a disc of
+ *  radius √α inside its quad. No gaussian falloff in the depth pass —
+ *  surviving fragments all write `opacity = 1.0` (the EWA core is not
+ *  used here; that's the `gsAlphaBlendedDepthFragment` regime). */
+export declare const gsLinearDepthFragment: GsShaderFragment;
+
+/** Data-only descriptor of a GS shader plugin. Lite equivalent of a BJS
+ *  `MaterialPluginBase`: snippets get spliced into the four GS fragment slots. */
+export declare interface GsShaderFragment {
+    readonly id: string;
+    readonly fragmentSlots?: Partial<Record<GsFragmentSlot, string>>;
+    readonly helperFunctions?: string;
+}
+
+declare interface HdrLoadOptions {
+    /** Cubemap face size in pixels. Default 256. */
+    faceSize?: number;
+    /** When true, render the HDR cubemap as the skybox background. */
+    useCubemapSkybox?: boolean;
+    /** When true, skip the ground plane. */
+    skipGround?: boolean;
+    /** Skybox size matching BJS createDefaultEnvironment skyboxSize option. */
+    skyboxSize?: number;
+}
+
+export declare interface HemisphericLight extends LightBase {
+    readonly lightType: "hemispheric";
+    direction: ObservableVec3;
+    intensity: number;
+    diffuseColor: [number, number, number];
+    specularColor: [number, number, number];
+    groundColor: [number, number, number];
+}
+
+/** Image processing configuration. */
+export declare interface ImageProcessingConfig {
+    exposure: number;
+    contrast: number;
+    toneMappingEnabled: boolean;
+    /** "standard" (BJS TONEMAPPING_STANDARD, default) or "aces" (BJS TONEMAPPING_ACES). */
+    toneMappingType?: "standard" | "aces";
+}
+
+/** Source of the color image to post-process: a texture, a render target, or a getter returning one (resolved each record). */
+export declare type ImageProcessingSource = Texture2D | RenderTarget | (() => Texture2D | RenderTarget | null | undefined);
+
+/** Configuration for `createImageProcessingTask`: the color source to apply exposure/contrast/tone-mapping to. */
+export declare interface ImageProcessingTaskConfig {
+    name?: string;
+    source: ImageProcessingSource;
+}
+
+/** Loads the manifold-3d WASM runtime. Must be awaited once before any CSG2 operation. */
+export declare function initializeCsg2Async(): Promise<void>;
+
+declare type InterpMode = 0 | 1 | 2;
+
+/** Any object that can be attached to a parent in the scene hierarchy.
+ *  When parent is null, position/rotation/scaling are in world space. */
+export declare interface IParentable {
+    parent: IWorldMatrixProvider | null;
+}
+
+/** Iridescence thin-film properties. Maps to BJS PBRMaterial.iridescence and KHR_materials_iridescence. */
+declare interface IridescenceProps {
+    /** Whether iridescence is active. Default false. */
+    isEnabled?: boolean;
+    /** Iridescence blend intensity (0=off, 1=full). Default 1.0 for native PBR; glTF default is supplied by the loader. */
+    intensity?: number;
+    /** Thin-film index of refraction. Default 1.3. */
+    indexOfRefraction?: number;
+    /** Minimum film thickness in nanometres. Default 100. */
+    minimumThickness?: number;
+    /** Maximum film thickness in nanometres. Default 400. */
+    maximumThickness?: number;
+    /** Optional intensity texture; R channel multiplies intensity. */
+    texture?: Texture2D;
+    /** Optional thickness texture; G channel lerps minimum→maximum thickness. */
+    thicknessTexture?: Texture2D;
+}
+
+/**
+ * Returns `true` if the sprite referenced by `handle` is still present in its system.
+ * @param handle - Handle to test.
+ */
+export declare function isBillboardSpriteHandleAlive(handle: BillboardSpriteHandle): boolean;
+
+/** Returns whether the manifold-3d runtime has finished loading and CSG2 is usable. */
+export declare function isCsg2Ready(): boolean;
+
+/**
+ * Returns `true` if the sprite referenced by `handle` is still present in its layer.
+ * @param handle - Handle to test.
+ */
+export declare function isSprite2DHandleAlive(handle: Sprite2DHandle): boolean;
+
+/** Any object that provides a world-space transformation matrix.
+ *  Implementations compute lazily on property access (getter). */
+export declare interface IWorldMatrixProvider {
+    /** World-space 4×4 column-major matrix. May trigger lazy recomputation. */
+    readonly worldMatrix: Mat4;
+    /** Monotonically increasing counter — bumped each time worldMatrix recomputes.
+     *  Children snapshot this value to detect when their parent has changed. */
+    readonly worldMatrixVersion: number;
+}
+
+/** Shared base for all light types.
+ *  Provides pipeline integration callbacks so render pipelines are light-agnostic. */
+export declare interface LightBase extends IWorldMatrixProvider, IParentable {
+    readonly lightType: string;
+    children: SceneNode[];
+    /** Mesh IDs excluded from this light. If set, these meshes are NOT lit by this light. */
+    excludedMeshIds?: ReadonlySet<string>;
+    /** If non-empty, ONLY these mesh IDs are lit by this light. Takes priority over excludedMeshIds. */
+    includedOnlyMeshIds?: ReadonlySet<string>;
+    /** Shadow generator attached to this light. Set this to make the light cast shadows. */
+    shadowGenerator?: ShadowGenerator;
+    parent: IWorldMatrixProvider | null;
+    readonly worldMatrix: Mat4;
+    readonly worldMatrixVersion: number;
+
+/** Options for `createLinearDepthMaterial()`. */
+export declare interface LinearDepthMaterialOptions {
+    /** Camera near plane (defaults to 0.03 to match the source playground). */
+    near?: number;
+    /** Camera far plane (defaults to 15 to match the source playground). */
+    far?: number;
+    /** Optional material name. */
+    name?: string;
+}
+
+/** Options for `loadSpriteAtlas`. PR 1 supports the `gridSize` path only. */
+export declare interface LoadAtlasOptions {
+    /** Grid cell size `[w, h]` in pixels. Required in PR 1. */
+    gridSize?: readonly [number, number];
+    /** Reserved for future PR — TexturePacker-style JSON. Throws if used in PR 1. */
+    metadataUrl?: string;
+    sampling?: SpriteSampling;
+    /** Marks the atlas as carrying premultiplied RGBA so the renderer picks the
+     *  premultiplied blend pipeline (`srcFactor: ONE`). Default `false` — matches
+     *  the bits PNG decoding produces. Set together with `premultiplyOnLoad: true`
+     *  for mathematically correct soft edges. Setting this `true` without
+     *  `premultiplyOnLoad: true` is only correct if the source image is *already*
+     *  premultiplied on disk (e.g. produced by a build step). */
+    premultipliedAlpha?: boolean;
+    /** Tell the texture loader to premultiply alpha at decode time
+     *  (`createImageBitmap({ premultiplyAlpha: "premultiply" })`). Default `false`.
+     *  Pair with `premultipliedAlpha: true` for the premultiplied blend pipeline. */
+    premultiplyOnLoad?: boolean;
+    textureOptions?: Texture2DOptions;
+}
+
+/**
+ * Load a .babylon scene file and return a AssetContainer.
+ * Pass the result to addToScene() to populate the scene.
+ *
+ * @param engine - The engine (provides GPU device)
+ * @param url - URL to the .babylon file
+ * @param opts - Optional loader configuration
+ */
+export declare function loadBabylon(engine: EngineContext, url: string, opts?: LoadBabylonOptions): Promise<AssetContainer>;
+
+declare interface LoadBabylonOptions {
+    /** Maximum number of meshes to load. Default: all. */
+    maxMeshes?: number;
+    /** Whether to load textures. Default: true. */
+    loadTextures?: boolean;
+    /** Whether to parse the camera from the file. Default: true. */
+    loadCamera?: boolean;
+}
+
+/**
+ * Load a Basis Universal (.basis) texture, transcode it to the best GPU-supported
+ * compressed format, and upload to a WebGPU texture.
+ *
+ * @param engine - The engine context.
+ * @param url    - URL of the .basis file.
+ * @param opts   - Sampler/address/filter options. `mipMaps` is ignored — basis
+ *                 mips are used as-is. `invertY` is ignored — basis data is
+ *                 already oriented for sampling.
+ * @returns A Texture2D.
+ */
+export declare function loadBasisTexture2D(engine: EngineContext, url: string, opts?: Texture2DOptions): Promise<Texture2D>;
+
+/**
+ * Load a Babylon.js .env environment file and upload cubemap + BRDF LUT to GPU.
+ * BRDF LUT is decoded from a pre-baked RGBD PNG (matching BJS's embedded
+ * environmentBRDFTexture) for pixel-perfect parity.
+ */
+export declare function loadEnvironment(scene: SceneContext, url: string, options: {
+    groundTextureUrl?: string;
+    skipSkybox?: boolean;
+    skipGround?: boolean;
+    /**
+     * URL for the skybox texture. Extension determines loading strategy:
+     * - `.dds`: loads a DDS cube skybox (e.g. BJS CDN backgroundSkybox.dds). Tree-shaken when unused.
+     * - `.env`: reuses the already-loaded specular cubemap as an HDR skybox (like BJS `createDefaultSkybox`).
+     * Omit for the default flat-color background. Use `skipSkybox` to disable skybox entirely.
+     */
+    skyboxUrl?: string;
+    /** Skybox size matching BJS createDefaultEnvironment skyboxSize option (default 20). */
+    skyboxSize?: number;
+    brdfUrl: string;
+}): Promise<EnvironmentTextures>;
+
+/**
+ * Load a .glb or .gltf file, parse it, and upload mesh + material data to GPU.
+ * Supports both binary GLB and separate .gltf + .bin + image files.
+ * Registers a deferred PBR renderable builder.
+ * Automatically parses glTF animations if present.
+ *
+ * Returns a AssetContainer. Pass it to addToScene() which adds the hierarchy,
+ * registers animation ticks, and applies any scene-level settings.
+ */
+export declare function loadGltf(engine: EngineContext, url: string): Promise<AssetContainer>;
+
+/**
+ * Loads a Radiance `.hdr` (RGBE) equirectangular panorama and builds GPU-ready IBL textures
+ * (prefiltered specular cubemap, BRDF LUT, and irradiance spherical harmonics), then attaches
+ * them to the scene and queues optional skybox/ground background renderables.
+ * @param scene - The scene to receive the environment textures and background renderables.
+ * @param url - URL of the `.hdr` file to fetch.
+ * @param options - Optional face size, skybox, and ground settings.
+ * @returns The assembled environment textures (also stored on the scene).
+ */
+export declare function loadHdrEnvironment(scene: SceneContext, url: string, options?: HdrLoadOptions): Promise<EnvironmentTextures>;
+
+/**
+ * Load a texture with KTX compressed format auto-selection and fallback.
+ *
+ * Tries each suffix in priority order, picks the first whose compressed format
+ * the GPU supports, fetches and parses the KTX1 file, and uploads it as a
+ * compressed GPU texture. Falls back to the base URL (loaded as a regular image)
+ * if no suffix is supported or loading fails.
+ *
+ * @param engine   - The engine context (device must have compressed texture features enabled).
+ * @param baseUrl  - The fallback image URL (e.g. "textures/grid.png").
+ * @param suffixes - KTX suffixes to try in priority order (e.g. ["-astc.ktx", "-dxt.ktx", "-etc2.ktx"]).
+ * @param opts     - Texture options (sampler, address mode, etc.). `mipMaps` is ignored — KTX mips are used as-is.
+ * @returns A Texture2D (same interface whether compressed or fallback).
+ */
+export declare function loadKtxTexture2D(engine: EngineContext, baseUrl: string, suffixes: string[], opts?: Texture2DOptions): Promise<Texture2D>;
+
+/** Load a skybox cube texture and register it on the scene.
+ *  The auto-builder will create the pipeline and render it.
+ *
+ *  @param scene   - Scene to register the skybox in
+ *  @param baseUrl - Base URL for cube faces (e.g., 'textures/skybox')
+ *  @param ext     - File extension (e.g., '.jpg', '.png')
+ *  @param size    - Box size (default 100, matches Babylon)
+ */
+export declare function loadSkybox(scene: SceneContext, baseUrl: string, ext: string, size?: number): Promise<void>;
+
+/** Fetch + parse a `.sog` archive and attach the resulting splat cloud to `scene`.
+ *
+ *  The returned mesh has `rotation.x = Math.PI` set on the scene node, matching
+ *  the BJS reference convention. SOG / PlayCanvas / SuperSplat assets are
+ *  authored "Y-down", and BJS compensates with `mesh.rotation.x = Math.PI`
+ *  at scene-graph time. */
+export declare function loadSOG(scene: SceneContext, url: string): Promise<GaussianSplattingMesh>;
+
+/** Fetch + parse a Gaussian-splat asset and attach it to `scene`. */
+export declare function loadSplat(scene: SceneContext, url: string, fragments?: readonly GsShaderFragment[]): Promise<GaussianSplattingMesh>;
+
+/**
+ * Load a sprite atlas from an image URL. PR 1 supports only the
+ * `gridSize` path: the texture is fetched as a non-Y-flipped image
+ * (so atlas UVs map top-down with `(0,0)` at the image top-left) and
+ * partitioned into a grid via `createGridSpriteAtlas`.
+ */
+export declare function loadSpriteAtlas(engine: EngineContext, textureUrl: string, options?: LoadAtlasOptions): Promise<SpriteAtlas>;
+
+/** Fetch + parse a `.spz` asset and attach the splat cloud to `scene`.
+ *
+ *  The returned mesh has `rotation.x = Math.PI` set on the scene node, matching
+ *  the BJS reference convention. SPZ assets are authored "Y-down", and BJS
+ *  compensates with `mesh.rotation.x = Math.PI` at scene-graph time. */
+export declare function loadSPZ(scene: SceneContext, url: string): Promise<GaussianSplattingMesh>;
+
+/** Load an image from `url` into a GPU `Texture2D`, generating mipmaps by default.
+ *  Results are cached per device by URL + options, so repeated calls with the
+ *  same arguments share one texture promise.
+ *  @param engine - Engine context.
+ *  @param url - Image URL to fetch and decode.
+ *  @param opts - Sampler, format, and decode overrides.
+ *  @returns A promise resolving to the uploaded `Texture2D`. */
+export declare function loadTexture2D(engine: EngineContext, url: string, opts?: Texture2DOptions): Promise<Texture2D>;
+
+/** Mark a material source (or one of its views) as needing UBO re-upload.
+ *  The source owns a monotonic version so multiple renderables/views can observe
+ *  the same mutation independently without racing on a single cleared boolean. */
+export declare function markMaterialUboDirty(materialOrView: Material): void;
+
+/** 4x4 column-major matrix stored as a flat Float32Array (16 elements).
+ *  Layout matches WebGPU/WGSL mat4x4<f32> memory order. */
+declare type Mat4 = Float32Array & {
+    readonly __brand: "Mat4";
+};
+
+/** Compose TRS (translation * rotation * scale) into a single Mat4. */
+export declare function mat4Compose(tx: number, ty: number, tz: number, qx: number, qy: number, qz: number, qw: number, sx: number, sy: number, sz: number): Mat4;
+
+/** Create a new identity Mat4. */
+export declare function mat4Identity(): Mat4;
+
+/** Create a scaling matrix. */
+export declare function mat4Scale(x: number, y: number, z: number): Mat4;
+
+/** Create a translation matrix. */
+export declare function mat4Translation(x: number, y: number, z: number): Mat4;
+
+/** Base material interface — the polymorphic anchor shared by every concrete
+ *  material kind (Standard, PBR, Shader, Node). Concrete materials add their own
+ *  user-facing properties while the shared `_buildGroup` hook lets the renderer
+ *  dispatch every material through a common path. */
+export declare interface Material {
    /** Optional human-readable name. Populated by loaders from the source asset
+     *  (e.g. the glTF material name) so callers can look a material up by name. */
+    name?: string;
+
+/** Exact material render-feature override used by MaterialView.
+ *  Feature bits are interpreted by each concrete material family. */
+export declare interface MaterialRenderFeatures {
+    features: number;
+    features2?: number;
+}
+
+/**
+ * Full variant data for a loaded glTF asset.
+ * Populated by loadGltf() when KHR_materials_variants is present.
+ *
+ * Note: variant data holds direct references to Mesh objects from the load.
+ * Cloned hierarchies (via cloneTransformNode) are NOT variant-aware.
+ */
+export declare interface MaterialVariantData {
+    /** Ordered list of available variant names. */
+    readonly names: readonly string[];
+    /** Per-variant mesh→material mappings. Key = variant name. */
+    readonly variants: Readonly<Record<string, readonly VariantMeshEntry[]>>;
+    /** Original (default) materials for all variant-participating meshes. */
+    readonly originals: readonly VariantMeshEntry[];
+}
+
+/** A lightweight render view over an editable source material.
+ *  The view is also a Material: it inherits material state from {@link source}
+ *  through the prototype chain and owns only render-feature bits. Keeping views
+ *  material-compatible lets ordinary render paths read properties normally, so
+ *  scenes that never create views do not retain view-specific unwrap branches. */
+export declare interface MaterialView extends Material {
+    readonly source: Material;
+
+/** Maximum number of scene lights packed into the shared lights UBO.
+ *  Babylon.js defaults to 4 lights per material; Babylon Lite's cap is scene-wide
+ *  because all materials index the same group-0 lights buffer. Raise via
+ *  `setMaxLights(n)` before creating any scene / loading any asset that needs
+ *  more lights (e.g. the glTF loader auto-raises this when an asset declares
+ *  more KHR_lights_punctual lights than the current cap). */
+export declare let MAX_LIGHTS: number;
+
+/** A renderable mesh — plain data with transform, material, and GPU geometry.
+ *  Works with both standard and PBR pipelines; routing is based on material type.
+ *  Extends SceneNode for the full TRS + parent + children hierarchy. */
+export declare interface Mesh extends SceneNode {
+    /** Unique ID from source file (e.g. .babylon). Used for light include/exclude filtering. */
+    id?: string;
+    material: Material;
+    receiveShadows: boolean;
+    /** World-space bounding box (set by loaders for camera framing). */
+    boundMin?: [number, number, number];
+    boundMax?: [number, number, number];
+    /** Skeleton GPU data (skeletal animation). Type-only — no module dependency. */
+    skeleton?: SkeletonData | null;
+    /** Morph target GPU data. Type-only — no module dependency. */
+    morphTargets?: MorphTargetData | null;
+    /** User-controlled render order. Lower = drawn first within phase.
+     *  Only affects ordering within the opaque or transparent phase. */
+    renderOrder?: number;
+    /** Thin instance data (CPU-side). GPU buffer managed by render system. */
+    thinInstances?: ThinInstanceData | null;
+
+/** Opaque GPU geometry handle (user never touches these). */
+export declare interface MeshGPU {
+    readonly positionBuffer: GPUBuffer;
+    readonly normalBuffer: GPUBuffer;
+    readonly tangentBuffer?: GPUBuffer | null;
+    readonly uvBuffer: GPUBuffer;
+    readonly uv2Buffer?: GPUBuffer | null;
+    readonly colorBuffer?: GPUBuffer | null;
+    readonly hasUv?: boolean;
+    readonly hasUv2?: boolean;
+    readonly hasTangent?: boolean;
+    readonly hasColor?: boolean;
+    readonly indexBuffer: GPUBuffer;
+    readonly indexCount: number;
+    readonly indexFormat: GPUIndexFormat;
+
+/** Connects a morph-target mesh to its GPU weight buffer for per-frame updates. */
+declare interface MorphBinding {
+    /** Node index that owns the morph targets. */
+    readonly nodeIdx: number;
+    /** GPU uniform buffer written each frame with current weights. */
+    readonly weightsBuffer: GPUBuffer;
+    /** CPU mirror of the first four current weights, used by deformation-aware picking. */
+    readonly weights: Float32Array;
+    /** Number of morph targets (max 4 supported). */
+    readonly targetCount: number;
+    readonly runtimeMorphTargets?: MorphTargetData;
+}
+
+/** Morph target GPU data — delta texture + weights UBO.
+ *  Created by createMorphTargets() in morph/create-morph-targets.ts.
+ *  Attached to mesh.morphTargets. */
+export declare interface MorphTargetData {
+    readonly texture: GPUTexture;
+    readonly count: number;
+    readonly weightsBuffer: GPUBuffer;
+    readonly targets: readonly {
+        positions: Float32Array;
+        normals: Float32Array | null;
+    }[];
+    readonly weights: Float32Array<ArrayBuffer>;
+}
+
+/** Pure-state handle for a crowd. */
+export declare interface NavCrowd {
+
+/** Pure-state handle for the navigation plugin. */
+export declare interface NavigationPlugin {
+
+/** NavMesh build parameters (Recast solo / tiled / tile-cache navmesh config). */
+export declare interface NavMeshParameters {
+    cs?: number;
+    ch?: number;
+    walkableSlopeAngle?: number;
+    walkableHeight?: number;
+    walkableClimb?: number;
+    walkableRadius?: number;
+    maxEdgeLen?: number;
+    maxSimplificationError?: number;
+    minRegionArea?: number;
+    mergeRegionArea?: number;
+    maxVertsPerPoly?: number;
+    detailSampleDist?: number;
+    detailSampleMaxError?: number;
+    /** Skip reversing winding when extracting positions (right-handed input). */
+    doNotReverseIndices?: boolean;
+    /** Tile size for tiled / tile-cache navmesh. Recommended 32-64 for tile cache. */
+    tileSize?: number;
+    /**
+     * Maximum number of obstacles. If `> 0` the navmesh is built with a tile cache
+     * so obstacles can be added/removed dynamically.
+     */
+    maxObstacles?: number;
+    /** Expected layers per tile for tile-cache navmesh. Default 1. */
+    expectedLayersPerTile?: number;
+    /** Off-mesh connection segments (teleports) baked into the navmesh. */
+    offMeshConnections?: OffMeshConnection[];
+    /** Keep intermediates for debug visualization. */
+    keepIntermediates?: boolean;
+}
+
+/** Parsed block in the graph. */
+declare interface NodeBlock {
+    readonly id: number;
+    /** BJS class name (e.g. "InputBlock", "TransformBlock", "FragmentOutputBlock"). */
+    readonly className: string;
+    /** Author-provided block name. */
+    readonly name: string;
+    /** Inputs by name. */
+    readonly inputs: ReadonlyMap<string, NodeConnection>;
+    /** Output names (type is resolved by the emitter). */
+    readonly outputs: ReadonlySet<string>;
+    /** Original serialized JSON for emitters that need extra fields (mode, value, etc.). */
+    readonly serialized: Readonly<Record<string, unknown>>;
+}
+
+/** Build state threaded through every emit call. */
+declare interface NodeBuildState {
+    readonly vertex: StageState;
+    readonly fragment: StageState;
+    readonly vertexAttributes: VertexAttribute[];
+    readonly varyings: Varying[];
+    readonly nodeUboFields: UboField[];
+    readonly bindings: BindingDecl[];
+    readonly textures: NodeTextureBinding[];
+    /** PBRMetallicRoughnessBlock helper bodies are large, so the block records
+     *  feature-specific helper requests here and node-material resolves them
+     *  through dynamic imports after graph emission. */
+    readonly pbrMrHelperRequests: NodePbrMrHelperRequest[];
+    /** Active LoopBlock storage variables keyed by `${stage}|${blockId}` while
+     *  the loop body is being emitted. StorageReadBlock/StorageWriteBlock use
+     *  this to route their loopID object connection to the mutable WGSL var. */
+    readonly loopVariables: Map<string, NodeLoopVariable>;
+    /** Monotonic counter for SSA temp names, shared across stages. */
+    nextTemp: number;
+    /** Set by any block that references the scene lights UBO (LightBlock,
+     *  LightInformationBlock, …). The pipeline builder allocates a binding +
+     *  struct decls + BGL entry when true. */
+    usesLightsUbo: boolean;
+    /** Set by ScreenSizeBlock. The pipeline exposes the current canvas size via
+     *  spare base scene-UBO scalars (no extra bindings / no per-graph UBO size change). */
+    usesScreenSize: boolean;
+    /** Set by FragDepthBlock. The pipeline switches the fragment return type
+     *  from a bare color to a `color+@builtin(frag_depth)` output struct. */
+    usesFragDepth: boolean;
+    usesClipPlanes: boolean;
+    usesMeshAttributeExists: boolean;
+    /** Set by MorphTargetsBlock. The pipeline allocates two vertex-only
+     *  bindings (morph texture + morph UBO), declares the struct, and adds
+     *  a `@builtin(vertex_index)` param to vs_main. */
+    usesMorphTargets: boolean;
+    /** Set by parseNodeMaterialFromSnippet when shadowGenerators are supplied.
+     *  The pipeline allocates shadow bindings (texture + sampler + UBO) per
+     *  shadow-casting light, emits light-space varyings in vs_main, and injects
+     *  a `nme_computeShadowFactors` helper that LightBlock calls before the
+     *  lighting loop. Zero entries = no bindings, no WGSL — invisible to scenes
+     *  without shadows. */
+    shadowLights: {
+        lightIndex: number;
+        shadowType: "esm" | "pcf";
+    }[];
+    /** Set by ReflectionBlock or any block that needs scene env textures
+     *  (specular cube + BRDF LUT + SH irradiance). The pipeline allocates
+     *  4 group-1 bindings (env_iblTexture/sampler + env_brdfLUT/sampler) and
+     *  reads SH coefficients + envRotationY + lodGenerationScale from the
+     *  canonical frame-graph scene UBO. Materials without env
+     *  pay zero — empty default. */
+    usesEnv: boolean;
+    /** Set by ClearCoatBlock; tells PBRMetallicRoughnessBlock to walk into
+     *  the connected ClearCoatBlock and emit the clear-coat layer code path
+     *  (extra GGX layer + Fresnel modulation of the base specular). */
+    usesClearcoat: boolean;
+    /** Set by SheenBlock; tells PBRMetallicRoughnessBlock to add the Charlie
+     *  NDF + Ashikhmin visibility sheen layer (cloth/velvet look). */
+    usesSheen: boolean;
+    /** Set by AnisotropyBlock; reserved for future anisotropic GGX path.
+     *  Currently used only to validate marker plumbing in scene 70 — at
+     *  intensity=0 the BJS anisotropic path reduces to standard GGX. */
+    usesAnisotropy: boolean;
+    /** Set by IridescenceBlock; tells PBRMetallicRoughnessBlock to replace the
+     *  base-layer F0 by the thin-film interference Fresnel color before direct
+     *  and IBL specular evaluation. */
+    usesIridescence: boolean;
+    /** Set by SubSurfaceBlock; reserved for future SS path. Marker only. */
+    usesSubsurface: boolean;
+    /** When false (default), BonesBlock emits a pass-through of its `world`
+     *  input — no skeleton binding is required. Set to true only when every
+     *  mesh using this material has a skeleton. */
+    hasSkeleton: boolean;
+    /** When false (default), InstancesBlock passes through the uniform world
+     *  matrix. Set to true when thin-instance attributes are bound. */
+    hasInstances: boolean;
+}
+
+/** A single connection point on a block — input only.
+ *  Output connection types are resolved by the emitter at graph-walk time. */
+declare interface NodeConnection {
+    /** Connection name on the owning block (e.g. "rgb", "uv", "color"). */
+    readonly name: string;
+    /** For inputs only: the upstream block id + output name. Null if unconnected. */
+    readonly source: NodeConnectionRef | null;
+}
+
+declare interface NodeConnectionRef {
+    readonly blockId: number;
+    readonly outputName: string;
+}
+
+declare interface NodeEmitContext {
+    /** Resolve an input → WGSL expression (handles memoization + recursive walk). */
+    readonly resolve: (block: NodeBlock, inputName: string, stage: Stage, state: NodeBuildState) => NodeExpr;
+    /** Resolve a specific (producerBlock, outputName) — used when one block reads another directly. */
+    readonly resolveOutput: (producer: NodeBlock, outputName: string, stage: Stage, state: NodeBuildState) => NodeExpr;
+    /** Mint a fresh SSA temp name. */
+    readonly temp: (state: NodeBuildState, prefix?: string) => string;
+    /** Cast a typed expression to a target WGSL type when the shapes differ. */
+    readonly cast: (value: NodeExpr, target: NodeValueType) => NodeExpr;
+    /** Access the surrounding graph (so emitters can find upstream blocks). */
+    readonly graph: NodeGraph;
+
+/** Typed WGSL expression produced by an emitter. */
+declare interface NodeExpr {
+    readonly expr: string;
+    readonly type: NodeValueType;
+}
+
+/** Parsed graph. Roots are FragmentOutputBlock + VertexOutputBlock (located by className). */
+declare interface NodeGraph {
+    readonly blocks: ReadonlyMap<number, NodeBlock>;
+    /** Named overridable inputs (uniform InputBlocks) — name → block id. */
+    readonly namedInputs: ReadonlyMap<string, number>;
+    /** BJS alpha mode (0=DISABLE, 2=COMBINE, …). Determines the GPU blend equation. */
+    readonly alphaMode: number;
+    /** Whether the material requires alpha blending at runtime.
+     *  Derived from the graph (FragmentOutputBlock.a is connected) plus
+     *  JSON-level overrides (`_needAlphaBlending`, `forceAlphaBlending`). */
+    readonly needsAlphaBlending: boolean;
+    /** Babylon.js material back-face culling flag. */
+    readonly backFaceCulling: boolean;
+}
+
+/** A live handle to one named Node Material input (uniform or texture). Set
+ *  `value` for scalar/vector inputs or `texture` for `texture2d` inputs; writes
+ *  flag the material UBO dirty so the change is uploaded next frame. */
+export declare interface NodeInputHandle {
+    readonly type: "f32" | "vec2f" | "vec3f" | "vec4f" | "texture2d";
+    value?: number | number[];
+    texture?: Texture2D | null;
+}
+
+declare interface NodeLoopVariable {
+    readonly valueVar: string;
+    readonly valueType: NodeValueType;
+    readonly indexVar: string;
+}
+
+/** A compiled Node Material (Babylon NME graph). Exposes an `inputs` map of
+ *  named handles for live uniform/texture updates, and dispatches rendering
+ *  through the inherited `_buildGroup` hook. */
+export declare interface NodeMaterial extends Material {
+    readonly inputs: Record<string, NodeInputHandle>;
+
+declare interface NodePbrMrHelperRequest {
+    readonly key: string;
+    readonly useEnv: boolean;
+    readonly useClearcoat: boolean;
+    readonly useSheen: boolean;
+    readonly useRefraction: boolean;
+    readonly useSubsurface: boolean;
+    readonly useAnisotropy: boolean;
+    readonly useIridescence: boolean;
+    readonly useShAlbedoScaling: boolean;
+    readonly useCcBump: boolean;
+    readonly useCcTint: boolean;
+    readonly useSpecularAA: boolean;
+    readonly remapClearcoatF0: boolean;
+}
+
+/** Per-node rest pose TRS + parent link for hierarchy traversal. */
+declare interface NodeRest {
+    readonly parentIdx: number;
    tx: number;
+    ty: number;
+    tz: number;
+    rx: number;
+    ry: number;
+    rz: number;
+    rw: number;
+    sx: number;
+    sy: number;
+    sz: number;
+}
+
+declare interface NodeTextureBinding {
+    readonly name: string;
+    readonly kind: "texture2d" | "textureCube";
+    readonly texture: Texture2D | null;
+}
+
+declare type NodeValueType = "f32" | "vec2f" | "vec3f" | "vec4f" | "mat4f" | "texture2d" | "textureCube";
+
+/** Babylon-compatible normalized camera viewport. x/y/width/height are fractions of the render target. */
+export declare interface NormalizedViewport {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+/**
+ * Normalizes the vector `(x, y, z)` to unit length.
+ * @param x - X component.
+ * @param y - Y component.
+ * @param z - Z component.
+ * @param epsilon - Length threshold below which the vector is treated as degenerate.
+ * @returns The unit-length vector, or `[0, 1, 0]` if the input length is at or below `epsilon`.
+ */
+export declare function normalizeVec3(x: number, y: number, z: number, epsilon?: number): Vec3Tuple;
+
+/**
+ * A 4-component quaternion whose `x`/`y`/`z`/`w` setters fire an `onDirty` callback
+ * when a component actually changes, letting the hierarchy system detect rotation updates.
+ */
+export declare class ObservableQuat implements Quat {
+    private _x;
+    private _y;
+    private _z;
+    private _w;
+    private readonly _onDirty;
+    constructor(x: number, y: number, z: number, w: number, onDirty: () => void);
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+    get z(): number;
+    set z(v: number);
+    get w(): number;
+    set w(v: number);
+    /** Bulk set — one dirty notification instead of four. */
+    set(x: number, y: number, z: number, w: number): void;
+    /** Copy values from another quaternion. */
+    copyFrom(q: Quat): void;
+    /** Copy into a Float32Array at offset. */
+    toArray(out: Float32Array, offset?: number): void;
+}
+
+export declare class ObservableVec3 implements Vec3 {
+    private _x;
+    private _y;
+    private _z;
+    private readonly _onDirty;
+    constructor(x: number, y: number, z: number, onDirty: () => void);
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+    get z(): number;
+    set z(v: number);
+    /** Bulk set — one dirty notification instead of three. */
+    set(x: number, y: number, z: number): void;
+    /** Copy values from another vector. */
+    copyFrom(v: Vec3): void;
+    /** Copy into a Float32Array at offset. */
+    toArray(out: Float32Array, offset?: number): void;
+}
+
+/** Opaque handle returned by `addBoxObstacle` / `addCylinderObstacle`. */
+export declare interface ObstacleHandle {
+
+/** Off-mesh connection (teleport segment) baked into the navmesh. */
+export declare interface OffMeshConnection {
+    startPosition: Vec3;
+    endPosition: Vec3;
+    radius: number;
+    bidirectional: boolean;
+    /** @defaultValue 0 */
+    area?: number;
+    /** @defaultValue 1 */
+    flags?: number;
+    userId?: number;
+}
+
+/** Register a callback to run before each rendered frame. */
+export declare function onBeforeRender(scene: SceneContext, cb: (deltaMs: number) => void): void;
+
+/** Register a callback to run when `disposeScene` is called. Used to tie
+ *  user-owned GPU resources (e.g. a `SpriteRenderer`) to the scene's lifetime. */
+export declare function onSceneDispose(scene: SceneContext, cb: () => void): void;
+
+/** Parse a Babylon NME graph (by snippet ID or inline JSON), emit WGSL, compile
+ *  the GPU pipeline, and return a ready-to-render `NodeMaterial`.
+ *  @param engine - Engine context.
+ *  @param snippetId - Snippet server ID; ignored when `options.json` is supplied.
+ *  @param options - Inline JSON, texture overrides, shadow generators, and graph flags.
+ *  @returns A promise resolving to the compiled `NodeMaterial`. */
+export declare function parseNodeMaterialFromSnippet(engine: EngineContext, snippetId: string, options?: ParseNodeMaterialOptions): Promise<NodeMaterial>;
+
+/** Options for `parseNodeMaterialFromSnippet()`. */
+export declare interface ParseNodeMaterialOptions {
+    readonly snippetServer?: string;
+    /** Pre-resolved JSON (object or string). When provided, bypasses the network. */
+    readonly json?: string | object;
+    /** Texture overrides keyed by TextureBlock / ImageSourceBlock name. */
+    readonly textures?: Readonly<Record<string, Texture2D>>;
+    /** Shadow generators to integrate into the material. Each contributes
+     *  one shadow-light slot whose lightIndex is the position of its light in
+     *  `scene.lights` at the time of rendering. Materials built without this
+     *  option have zero shadow bindings / zero shadow WGSL. */
+    readonly shadowGenerators?: readonly ShadowGenerator[];
+    /** For each entry in shadowGenerators, the index of the owning light in
+     *  scene.lights. When omitted, defaults to [0, 1, …] (first N lights). */
+    readonly shadowLightIndices?: readonly number[];
+    /** When true, BonesBlock produces a skinned world matrix (requires all
+     *  meshes using this material to have a skeleton). Default false. */
+    readonly hasSkeleton?: boolean;
+    /** When true, InstancesBlock wires per-instance attributes. Default false. */
+    readonly hasInstances?: boolean;
+    /** Optional graph-specific block loader. Avoids the full default registry when callers know the exact block set. */
+    readonly blockLoader?: (className: string) => Promise<BlockEmitter>;
+}
+
+/** Base interface every frame-graph pass implements: a named unit of GPU work with `_initialize` / `_execute` / `_dispose` lifecycle hooks. */
+export declare interface Pass {
+    readonly name: string;
+
+/** Pause playback of an animation group. */
+export declare function pauseAnimation(group: AnimationGroup): void;
+
+/** User-facing properties for a physically based (metallic-roughness) material.
+ *  Create one manually via `createPbrMaterial()` or let `loadGltf()` build it.
+ *  Optional sub-feature objects (clearcoat, sheen, anisotropy, subsurface) are
+ *  only bundled when referenced. */
+export declare interface PbrMaterialProps extends Material {
+    baseColorTexture?: Texture2D;
+    /** Linear RGB/A factor multiplied with the base-color texture (glTF baseColorFactor). Default [1,1,1,1]. */
+    baseColorFactor?: [number, number, number, number];
+    normalTexture?: Texture2D;
+    /** Normal map scale (glTF normalTexture.scale). Default 1.0. */
+    normalTextureScale?: number;
+    /** Occlusion-Roughness-Metallic packed: R=occ, G=rough, B=metal. */
+    ormTexture?: Texture2D;
+    emissiveTexture?: Texture2D;
+    /** Emissive color as float uniform (linear RGB). Used when no emissiveTexture.
+     *  If both set, emissiveColor multiplies emissiveTexture. */
+    emissiveColor?: [number, number, number];
+    /** KHR_materials_pbrSpecularGlossiness: RGB=specular, A=glossiness. */
+    specGlossTexture?: Texture2D;
+    /** Whether material is double-sided (disables back-face culling). */
+    doubleSided?: boolean;
+    /** Overall material alpha (0=fully transparent, 1=opaque). Default 1.0. */
+    alpha?: number;
+    /** Enable alpha blending (glTF alphaMode "BLEND"). Enables radianceOverAlpha + specularOverAlpha. */
+    alphaBlend?: boolean;
+    /** Alpha test cutoff (glTF alphaMode "MASK"). Fragments with base alpha * material alpha below this value are discarded. */
+    alphaCutOff?: number;
+    /** Scale factor for environment/IBL contribution. Default 1.0. */
+    environmentIntensity?: number;
+    /** Scale factor for direct light contribution. Default 1.0. */
+    directIntensity?: number;
+    /** Whether direct point/spot lights use physical inverse-square falloff.
+     *  Default true, matching Babylon.js PBRMaterial. Set false for Standard-style
+     *  linear range + spot exponent falloff (`usePhysicalLightFalloff = false`). */
+    usePhysicalLightFalloff?: boolean;
+    /** Dielectric F0 reflectance (default 0.04, glass ≈ 0.2). */
+    reflectance?: number;
+    /** glTF metallicFactor multiplier applied over ORM.b metallic channel. Default 1.0. */
+    metallicFactor?: number;
+    /** glTF roughnessFactor multiplier applied over ORM.g roughness channel. Default 1.0. */
+    roughnessFactor?: number;
+    /** Strength of ambient occlusion from ORM R channel. Default 1.0; 0.0 ignores R channel. */
+    occlusionStrength?: number;
+    /** UV set index for the occlusion texture (0 = UV1, 1 = UV2). Default 0. */
+    occlusionTexCoord?: number;
+    /** Separate occlusion texture sampled with UV2 when occlusionTexCoord=1.
+     *  R channel is occlusion. When set, ORM.r is NOT used for occlusion. */
+    occlusionTexture?: Texture2D;
+    /** Scales dielectric F0 (default 1.0). Maps to BJS metallicF0Factor. */
+    metallicF0Factor?: number;
+    /** Grazing specular/F90 weight (default follows metallicF0Factor for legacy callers). */
+    specularWeight?: number;
+    /** Tints dielectric reflectance (linear RGB, default [1,1,1]). Maps to BJS metallicReflectanceColor. */
+    metallicReflectanceColor?: [number, number, number];
+    /** Texture whose RGB tints reflectance and A scales F0. Maps to BJS metallicReflectanceTexture. */
+    metallicReflectanceTexture?: Texture2D;
+    /** Texture whose RGB tints reflectance only. Maps to BJS reflectanceTexture. */
+    reflectanceTexture?: Texture2D;
+    /** When true + both reflectance textures set, metallicReflectanceTexture only contributes A (F0 scalar). */
+    useOnlyMetallicFromMetallicReflectanceTexture?: boolean;
+    /** Enable specular anti-aliasing on IBL alphaG (matches BJS SPECULARAA). Default false.
+     *  Set automatically by the glTF loader for materials loaded from glTF files. */
+    enableSpecularAA?: boolean;
+    /** Clearcoat layer configuration. When set with isEnabled=true, adds a glossy transparent
+     *  top layer (like car paint or lacquer). Tree-shakable — only bundled when used. */
+    clearCoat?: ClearCoatProps;
+    /** Sheen layer configuration. When set with isEnabled=true, adds a soft velvet-like
+     *  sheen layer (like fabric or cloth). Tree-shakable — only bundled when used. */
+    sheen?: SheenProps;
+    /** Iridescence thin-film configuration. When set with isEnabled=true, replaces
+     *  base-layer F0 with a wavelength-dependent thin-film Fresnel blend.
+     *  Maps to BJS PBRMaterial.iridescence and KHR_materials_iridescence.
+     *  Tree-shakable — only bundled when used. */
+    iridescence?: IridescenceProps;
+    /** When true, the albedo texture is in sRGB/gamma space (loaded as rgba8unorm)
+     *  and the shader applies pow(baseColor, 2.2) for sRGB→linear conversion.
+     *  Matches BJS PBRMaterial's Texture.gammaSpace=true behavior.
+     *  When false (default), assumes the texture already provides linear values
+     *  (e.g. rgba8unorm-srgb format or glTF sRGB textures). */
+    gammaAlbedo?: boolean;
+    /** Anisotropy layer configuration. When set with isEnabled=true, stretches specular
+     *  highlights along a preferred direction. Tree-shakable — only bundled when used. */
+    anisotropy?: AnisotropyProps;
+    /** Subsurface configuration. Presence of nested sub-features (translucency, scattering)
+     *  enables them — no isEnabled booleans needed. Tree-shakable — only bundled when used. */
+    subsurface?: SubSurfaceProps;
+    /** True transmissive surface: render task provides a scene-color refraction texture
+     *  just before this material draws. Set by KHR_materials_transmission. */
+    transmissive?: boolean;
+    /** When true, the material samples the environment cubemap using the view direction
+     *  (camera→fragment) instead of the reflected view direction. Used for PBR skybox boxes
+     *  where the mesh surrounds the camera and should display the environment directly.
+     *  Also zeroes SH irradiance — skybox is pure cubemap + BRDF only. */
+    skyboxMode?: boolean;
+    /** When true, the material is unlit — the base color is output directly,
+     *  bypassing all lighting, IBL, tonemap, and shading calculations.
+     *  Matches `KHR_materials_unlit` glTF extension. Alpha handling is preserved. */
+    unlit?: boolean;
+    /** Linear-RGB tint applied to baseColor when `unlit` is true (i.e. glTF
+     *  `baseColorFactor`). When omitted or [1,1,1], no tint is applied.
+     *  Only bundled/bound when the unlit extension is active. */
+    unlitColor?: [number, number, number];
+
+/** Configuration for a directional-light PCF shadow generator: map size, depth bias, darkness, and ortho projection bounds. */
+export declare interface PcfDirectionalShadowGeneratorConfig {
+    mapSize?: number;
+    bias?: number;
+    darkness?: number;
+    normalBias?: number;
+    /** Ortho near plane. Default 1. */
+    orthoMinZ?: number;
+    /** Ortho far plane. Default 10000. */
+    orthoMaxZ?: number;
+    /** Force the shadow map to be regenerated every frame. Default false. */
+    forceRefreshEveryFrame?: boolean;
+}
+
+/** Configuration for a spot-light PCF shadow generator: map size, depth bias, darkness, and projection near/far planes. */
+export declare interface PcfSpotlightShadowGeneratorConfig {
+    mapSize?: number;
+    bias?: number;
+    darkness?: number;
+    normalBias?: number;
+    /** Near plane for the shadow projection. Default: uses camera near (1). */
+    near?: number;
+    /** Far plane for the shadow projection. Default: uses camera far or light range. */
+    far?: number;
+    /** Force the shadow map to be regenerated every frame. Default false. */
+    forceRefreshEveryFrame?: boolean;
+}
+
+/** A body and its shape wired together, as produced by `createPhysicsAggregate`. */
+export declare interface PhysicsAggregate {
+    readonly body: PhysicsBody;
+    readonly shape: PhysicsShape;
+}
+
+/** Options for `createPhysicsAggregate`: mass, material (friction/restitution), and optional shape geometry overrides. */
+export declare interface PhysicsAggregateOptions {
+    mass: number;
+    friction?: number;
+    restitution?: number;
+    radius?: number;
+    pointA?: Vec3;
+    pointB?: Vec3;
+    extents?: Vec3;
+    rotation?: Quat;
+    center?: Vec3;
+    startAsleep?: boolean;
+    isTriggerShape?: boolean;
+}
+
+/** Opaque handle to a Havok rigid body, bound to a scene node and a motion type. */
+export declare interface PhysicsBody {
    readonly node: SceneNode;
+    readonly motionType: PhysicsMotionType;
+}
+
+/** How a body moves: `STATIC` (immovable), `ANIMATED` (driven by the node transform), or `DYNAMIC` (simulated). */
+export declare const enum PhysicsMotionType {
+    STATIC = 0,
+    ANIMATED = 1,
+    DYNAMIC = 2
+}
+
+/** Opaque handle to a Havok collision shape. */
+export declare interface PhysicsShape {
+
+/** Options for `createPhysicsShape`: the shape type plus its geometry parameters. */
+export declare interface PhysicsShapeOptions {
+    type: PhysicsShapeType;
+    parameters?: PhysicsShapeParameters;
+}
+
+/** Geometry parameters describing a collision shape; which fields apply depends on the shape type. */
+export declare interface PhysicsShapeParameters {
+    center?: Vec3;
+    radius?: number;
+    pointA?: Vec3;
+    pointB?: Vec3;
+    rotation?: Quat;
+    extents?: Vec3;
+}
+
+/** Geometry type of a physics collision shape. */
+export declare const enum PhysicsShapeType {
+    SPHERE = 0,
+    CAPSULE = 1,
+    CYLINDER = 2,
+    BOX = 3,
+    CONVEX_HULL = 4,
+    CONTAINER = 5,
+    MESH = 6,
+    HEIGHTFIELD = 7
+}
+
+/** Pure-state handle to a Havok physics world: the WASM module, the native world, its bodies, and the timestep. */
+export declare interface PhysicsWorld {
+
+/** Pick the mesh at CSS-space canvas coordinates, matching Babylon.js Scene.pick. Returns a PickingInfo. */
+export declare function pickAsync(picker: GpuPicker, x: number, y: number): Promise<PickingInfo>;
+
+/** Result of a GPU pick operation. */
+export declare interface PickingInfo {
+    hit: boolean;
+    distance: number;
+    pickedPoint: [number, number, number] | null;
+    pickedNormal: [number, number, number] | null;
+    pickedNormalWorld: [number, number, number] | null;
+    pickedFaceNormal: [number, number, number] | null;
+    pickedFaceNormalWorld: [number, number, number] | null;
+    /** The picked mesh.  May be a regular Lite `Mesh` or a `GaussianSplattingMesh`
+     *  (when GS picking via the gs-picking-pipeline ports the BJS
+     *  `GaussianSplattingGpuPickingMaterialPlugin`). */
+    pickedMesh: Mesh | GaussianSplattingMesh | null;
+    faceId: number;
+    bu: number;
+    bv: number;
+    subMeshId: number;
+    thinInstanceIndex: number;
+    ray: Ray | null;
+}
+
+/** Sampler and format overrides for `createTexture2DFromPixels()`. */
+export declare interface PixelsTexture2DOptions {
+    /** Address mode U. Default 'clamp-to-edge'. */
+    addressModeU?: GPUAddressMode;
+    /** Address mode V. Default 'clamp-to-edge'. */
+    addressModeV?: GPUAddressMode;
+    /** Min filter. Default 'nearest'. */
+    minFilter?: GPUFilterMode;
+    /** Mag filter. Default 'nearest'. */
+    magFilter?: GPUFilterMode;
+    /** Use sRGB format (rgba8unorm-srgb) so the hardware converts to linear on
+     *  sample. Use for color data; leave false for lookup tables. Default false. */
+    srgb?: boolean;
+}
+
+/** A viewport expressed in integer render-target pixels, with `y` measured from the top (WebGPU convention). */
+export declare interface PixelViewport {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+/** Options for `createPlaneData`. Subset of Babylon's CreatePlane. */
+export declare interface PlaneOptions {
+    size?: number;
+    width?: number;
+    height?: number;
+}
+
+/** Start playing an animation group. */
+export declare function playAnimation(group: AnimationGroup): void;
+
+/**
+ * Plays a frame animation on a billboard sprite addressed by its stable handle.
+ * The handle is resolved each tick, so the animation survives swap-remove reindexing.
+ * @param manager - Animation manager that drives the playback.
+ * @param handle - Stable handle of the billboard sprite to animate.
+ * @param from - First frame index of the range.
+ * @param to - Last frame index of the range.
+ * @param loop - When `true`, the animation restarts after reaching `to`.
+ * @param delayMs - Delay in milliseconds between frame steps.
+ * @param options - Optional end callback and removal behaviour.
+ * @returns The created sprite frame animation.
+ */
+export declare function playBillboardSpriteAnimation(manager: SpriteAnimationManager, handle: BillboardSpriteHandle, from: number, to: number, loop: boolean, delayMs: number, options?: PlaySpriteAnimationOptions): SpriteFrameAnimation;
+
+/**
+ * Play a frame animation against a raw billboard sprite slot index.
+ *
+ * This is the zero-handle, slot-based path for structurally stable systems.
+ * If the slot is swap-removed externally, the animation follows whatever
+ * sprite later occupies the same index. Use `playBillboardSpriteAnimation`
+ * with a handle when animation must track a stable sprite identity across removals.
+ */
+export declare function playBillboardSpriteIndexAnimation(manager: SpriteAnimationManager, system: BillboardSpriteSystem, index: number, from: number, to: number, loop: boolean, delayMs: number, options?: PlaySpriteAnimationOptions): SpriteFrameAnimation;
+
+/**
+ * Plays a frame animation on a 2D sprite addressed by its stable handle.
+ * The handle is resolved each tick, so the animation survives swap-remove reindexing.
+ * @param manager - Animation manager that drives the playback.
+ * @param handle - Stable handle of the sprite to animate.
+ * @param from - First frame index of the range.
+ * @param to - Last frame index of the range.
+ * @param loop - When `true`, the animation restarts after reaching `to`.
+ * @param delayMs - Delay in milliseconds between frame steps.
+ * @param options - Optional end callback and removal behaviour.
+ * @returns The created sprite frame animation.
+ */
+export declare function playSprite2DAnimation(manager: SpriteAnimationManager, handle: Sprite2DHandle, from: number, to: number, loop: boolean, delayMs: number, options?: PlaySpriteAnimationOptions): SpriteFrameAnimation;
+
+/**
+ * Play a frame animation against a raw Sprite2D slot index.
+ *
+ * This is the zero-handle, slot-based path for structurally stable layers.
+ * If the slot is swap-removed externally, the animation follows whatever
+ * sprite later occupies the same index. Use `playSprite2DAnimation` with a
+ * handle when animation must track a stable sprite identity across removals.
+ */
+export declare function playSprite2DIndexAnimation(manager: SpriteAnimationManager, layer: Sprite2DLayer, index: number, from: number, to: number, loop: boolean, delayMs: number, options?: PlaySpriteAnimationOptions): SpriteFrameAnimation;
+
+/** Optional callbacks and behaviour applied when starting a sprite frame animation. */
+export declare interface PlaySpriteAnimationOptions {
+    /** Optional. Called once when a non-looping animation reaches its last frame. */
+    readonly onEnd?: () => void;
+    readonly removeWhenFinished?: boolean;
+}
+
+/** Replay an animation; omit options to keep callbacks/removal, pass options to overwrite them, or `{}` to clear them. */
+export declare function playSpriteFrameAnimation(animation: SpriteFrameAnimation, from?: number, to?: number, loop?: boolean, delayMs?: number, options?: PlaySpriteAnimationOptions): void;
+
+export declare interface PointLight extends LightBase {
+    readonly lightType: "point";
+    position: ObservableVec3;
+    diffuse: [number, number, number];
+    specular: [number, number, number];
+    intensity: number;
+    range: number;
+}
+
+/** Options for `createPolyhedronData`. Subset of Babylon's CreatePolyhedron. */
+export declare interface PolyhedronOptions {
+    /** Preset index 0-14. 0=Tetrahedron, 1=Octahedron, 2=Dodecahedron,
+     *  3=Icosahedron, 4=Rhombicuboctahedron, 5=TriangularPrism, 6=PentagonalPrism,
+     *  7=HexagonalPrism, 8=SquarePyramid(J1), 9=PentagonalPyramid(J2),
+     *  10=TriangularDipyramid(J12), 11=PentagonalDipyramid(J13),
+     *  12=ElongatedSquareDipyramid(J15), 13=ElongatedPentagonalDipyramid(J16),
+     *  14=ElongatedPentagonalCupola(J20). Default 0. */
+    type?: number;
+    size?: number;
+    sizeX?: number;
+    sizeY?: number;
+    sizeZ?: number;
+    flat?: boolean;
+}
+
+/** Output blend mode: `0` opaque, `1` additive, `2` premultiplied, `7` non-premultiplied alpha. */
+export declare type PostProcessAlphaMode = 0 | 1 | 2 | 7;
+
+/** Source sampling filter for a post-process pass. */
+export declare type PostProcessSamplingMode = "nearest" | "linear";
+
+/** A fullscreen post-process pass that samples a source texture, applies a fragment shader, and writes to an output target. */
+export declare interface PostProcessTask extends Task, PostProcessTaskSettings {
+    readonly name: string;
+    sourceSamplingMode: PostProcessSamplingMode;
+    targetTexture: RenderTarget | null;
+    alphaMode: PostProcessAlphaMode;
+    viewport: NormalizedViewport | null;
+    clear: boolean;
+    outputTexture: RenderTarget;
+    /** Recompute and upload the pass's uniform buffer from current settings. Call after mutating effect parameters. */
+    updateUniforms(): void;
+
+declare interface PostProcessTaskConfig extends PostProcessTaskSettings {
+
+/** Shared user-facing settings for a post-process pass: source/target textures, sampling, alpha mode, viewport, and clear. */
+export declare interface PostProcessTaskSettings {
+    name?: string;
+    sourceTexture: RenderTarget;
+    sourceSamplingMode?: PostProcessSamplingMode;
+    targetTexture?: RenderTarget | null;
+    alphaMode?: PostProcessAlphaMode;
+    viewport?: NormalizedViewport | null;
+    /** Clear the target before drawing. Set false when several viewport passes share a target. */
+    clear?: boolean;
+}
+
+declare interface PostProcessVec2 {
+    x: number;
+    y: number;
+}
+
+declare interface PostProcessVec2_2 {
+    x: number;
+    y: number;
+}
+
+/** Something that runs before the main render pass (shadow maps, compute, etc.). */
+export declare interface PrePassRenderable {
+    /** Execute pre-pass work (e.g., render shadow depth map + blur). Returns the number of GPU draw calls issued. */
+    execute(encoder: GPUCommandEncoder, engine: EngineContext): number;
+}
+
+/** A reusable, target-independent set of compiled property tracks with a total duration. */
+export declare interface PropertyAnimationClip {
+    readonly name: string;
+    readonly tracks: readonly PropertyAnimationTrack[];
+    readonly duration: number;
+    readonly frameRate: number;
+}
+
+/** Options for {@link createPropertyAnimationClip}. */
+export declare interface PropertyAnimationClipOptions {
+    readonly frameRate?: number;
+}
+
+/** Interpolation mode between keyframes: smooth `"linear"` or hold-previous `"step"`. */
+export declare type PropertyAnimationInterpolation = "linear" | "step";
+
+/** A compiled animation track: a sampler plus the metadata needed to evaluate and write its property. */
+export declare interface PropertyAnimationTrack {
+    readonly path: string;
+    readonly sampler: AnimationSampler;
+    readonly stride: number;
+    readonly quaternion: boolean;
+}
+
+/** Options describing one animated property track passed to {@link createPropertyAnimationClip}. */
+export declare interface PropertyAnimationTrackOptions {
+    readonly path: string;
+    readonly keys: readonly AnimationKeyframe[];
+    readonly frameRate?: number;
+    readonly interpolation?: PropertyAnimationInterpolation;
+    readonly quaternion?: boolean;
+}
+
+/** Quaternion rotation */
+declare interface Quat {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+
+/** A ray defined by origin, direction, and length. */
+declare interface Ray {
+    origin: [number, number, number];
+    direction: [number, number, number];
+    length: number;
+}
+
+/**
+ * Cast a 'walkability' ray on the navmesh from `start` to `end`.
+ * Matches BJS Addons semantics: `hit` is true only when `0 < t < 1` and
+ * `hitPoint` is the linear interpolation between start and end at parameter t.
+ *
+ * Recast's raycast ignores the y component of the end position (2D check).
+ */
+export declare function raycast(plugin: NavigationPlugin, start: Vec3, end: Vec3): {
+    hit: boolean;
+    hitPoint?: Vec3;
+};
+
+/** Rebuild renderables whose pipeline/bind-group feature state depends on a material.
+ *  Use after texture, sampler, bind-group layout, culling, or feature changes.
+ *  UBO-only scalar/vector changes should use markMaterialUboDirty instead. */
+export declare function rebuildMaterial(scene: SceneContext, materialOrView: Material, options?: RebuildMaterialOptions): void;
+
+declare interface RebuildMaterialOptions {
+    /** Rebuild views created from the same source material. Defaults to true. */
+    rebuildViews?: boolean;
+    /** Rebuild the frame graph after material renderables are refreshed. Defaults to false so callers can batch updates. */
+    rebuildFrameGraph?: boolean;
+}
+
+/** Refraction sub-feature (KHR_materials_transmission + _volume + _ior).
+ *  Presence enables frame-graph scene-texture transmission. */
+export declare interface RefractionProps {
+    /** Transmission factor (0=off, 1=fully transmissive). Default 0.
+     *  Maps to KHR_materials_transmission.transmissionFactor. */
+    intensity?: number;
+    /** Optional transmission texture (R channel). Multiplies `intensity`. */
+    texture?: Texture2D;
+    /** Index of refraction (KHR_materials_ior.ior). Default 1.5 (glass). */
+    indexOfRefraction?: number;
+    /** When true, the thickness value is also used as the refracted
+     *  sample offset depth (KHR_materials_volume — matches BJS
+     *  `useThicknessAsDepth`). Default true when volume is present. */
+    useThicknessAsDepth?: boolean;
+    /** Chromatic dispersion strength (KHR_materials_dispersion.dispersion).
+     *  Splits the refracted ray into per-RGB index-of-refraction offsets,
+     *  producing chromatic aberration. Requires volume. Default 0 (off). */
+    dispersion?: number;
+}
+
+/** Register the effect renderer with its engine. Idempotent — a second call is a no-op. */
+export declare function registerEffectRenderer(er: EffectRenderer): void;
+
+/** Build and register the standalone frame-graph context with its engine. */
+export declare function registerFrameGraphContext(ctx: FrameGraphContext): void;
+
+/**
+ * Register a scene with the engine. Builds deferred work, sorts renderables by order,
+ * and adds the scene to the engine's render list in overlay order.
+ */
+export declare function registerScene(engine: EngineContext, scene: SceneContext): Promise<void>;
+
+/**
+ * Register a scene with the engine and install the scene-owned shadow frame-graph task.
+ * Use only for scenes that generate shadow maps.
+ */
+export declare function registerSceneWithShadowSupport(engine: EngineContext, scene: SceneContext): Promise<void>;
+
+/** Push the renderer onto its engine's `_renderingContexts`. Idempotent — a second call is a no-op. */
+export declare function registerSpriteRenderer(sr: SpriteRenderer): void;
+
+/** Detaches `group` from `manager`, removing its animation task so it is no longer ticked. */
+export declare function removeAnimationGroup(manager: AnimationManager, group: AnimationGroup): void;
+
+/** Detaches `task` from `manager`, marking it inactive and running its dispose hook if it was attached. */
+export declare function removeAnimationTask(manager: AnimationManager, task: AnimationTask): void;
+
+/**
+ * Removes the billboard sprite referenced by `handle`. Does nothing if it is already gone.
+ * @param handle - Handle of the sprite to remove.
+ */
+export declare function removeBillboardSprite(handle: BillboardSpriteHandle): void;
+
+/**
+ * Removes the billboard sprite at the given instance index using swap-remove with the last sprite.
+ * @param system - Billboard system that owns the sprite.
+ * @param index - Instance index to remove.
+ * @throws If `index` is out of range.
+ */
+export declare function removeBillboardSpriteIndex(system: BillboardSpriteSystem, index: number): void;
+
+/** Remove a mesh from the scene and destroy its GPU resources.
+ *  Standalone function for tree-shaking — only included when actually used. */
+export declare function removeFromScene(scene: SceneContext, mesh: Mesh): void;
+
+/** Remove a mesh from this task's renderable + binding lists. Idempotent. */
+export declare function removeMeshFromTask(task: RenderTask, mesh: object): void;
+
+/** Remove an obstacle previously added by `addBoxObstacle` / `addCylinderObstacle`. */
+export declare function removeObstacle(plugin: NavigationPlugin, obstacle: ObstacleHandle): void;
+
+/**
+ * Removes the sprite referenced by `handle`. Does nothing if it is already gone.
+ * @param handle - Handle of the sprite to remove.
+ */
+export declare function removeSprite2D(handle: Sprite2DHandle): void;
+
+/** Swap-remove a sprite. The last sprite (if any) takes its slot. */
+export declare function removeSprite2DIndex(layer: Sprite2DLayer, index: number): void;
+
+/**
+ * Removes an animation from a manager and clears its ownership if the manager owns it.
+ * @param manager - Manager to remove the animation from.
+ * @param animation - Animation to remove.
+ */
+export declare function removeSpriteAnimation(manager: SpriteAnimationManager, animation: SpriteFrameAnimation): void;
+
+/**
+ * Detaches a sprite animation manager previously attached with {@link addSpriteAnimationManager}.
+ * @param manager - Animation manager the sprite manager was attached to.
+ * @param spriteManager - Sprite animation manager to detach.
+ */
+export declare function removeSpriteAnimationManager(manager: AnimationManager, spriteManager: SpriteAnimationManager): void;
+
+/** Remove a layer from the renderer and destroy any GPU resources cached for it. */
+export declare function removeSpriteRendererLayer(sr: SpriteRenderer, layer: Sprite2DLayer): boolean;
+
+/** Remove instance by index. Swap-removes: last instance fills the gap. */
+export declare function removeThinInstance(mesh: Mesh, index: number): void;
+
+/** Something that draws itself into a render pass. The bind() method returns a
+ *  DrawBinding capturing target-specific GPU state and the per-frame draw closure. */
+export declare interface Renderable {
+    /** Sort key for draw order (lower = drawn first). Default: 100 (opaque), 200 (transparent). */
+    readonly order: number;
+    /** Whether this renderable is transparent (auto-derived from material). */
+    readonly isTransparent: boolean;
    /** Reference to the source mesh (for distance sort + material-change detection). */
+    readonly mesh?: Mesh;
    /**
+     * Resolve target-specific GPU state (pipeline) and return a `DrawBinding` whose
+     * `draw` closure captures that state. Called by the render pass task at build/insert
+     * time. The scene bind group (group 0) is set once per pass by the task — renderables
+     * never see it. Renderables that need to participate in multiple passes with different
+     * target formats should pick the appropriate pipeline based on `target`.
+     */
+    bind(engine: EngineContext, target: RenderTargetSignature): DrawBinding;
+}
+
+/**
+ * A surface Babylon Lite can render into. Either a DOM canvas (main thread) or an
+ * `OffscreenCanvas` (e.g. one transferred to a Web Worker via
+ * `transferControlToOffscreen()`). Both expose `getContext("webgpu")` plus a
+ * read/write backing-store `width`/`height`; only the DOM canvas exposes layout
+ * (`clientWidth`/`clientHeight`) and attributes (`setAttribute`).
+ */
+export declare type RenderCanvas = HTMLCanvasElement | OffscreenCanvas;
+
+/**
+ * Minimal surface an engine sees for anything it renders. Scenes (and any other
+ * future renderable thing) register themselves as a `RenderingContext` and
+ * own their own update / record logic. Engine knows nothing of scene internals.
+ */
+declare interface RenderingContext_2 {
    /** Clear color used when this context is the first active one in a frame. */
+    clearColor: GPUColorDict;
+
+/** A frame-graph pass that begins a render pass into its bound `RenderTarget`, runs an execute callback, then ends the pass. */
+export declare interface RenderPass extends Pass {
    /** Per-frame mutable state. RenderTask mirrors live scene state
+     *  (e.g. `scene.clearColor` for auto-filled tasks) into these fields
+     *  before iterating its passes. */
+    clearColor: GPUColorDict;
+    /** True → loadOp `"clear"`, false → `"load"` (overlay mode). */
+    clear: boolean;
+
+/** Body of a render pass — receives the live render-pass encoder and returns
+ *  the number of draws issued. */
+export declare type RenderPassExecuteFunc = (pass: GPURenderPassEncoder) => number;
+
+/** Allocated GPU state for a render target. */
+export declare interface RenderTarget {
+
+/** Describes a render target — what attachments to create, not the GPU objects
+ *  themselves. GPU textures are allocated later by `buildRenderTarget`. */
+export declare interface RenderTargetDescriptor {
+    label?: string;
+    colorFormat?: GPUTextureFormat;
+    depthStencilFormat?: GPUTextureFormat;
    sampleCount: number;
+    /** 'canvas' means match the canvas pixel size. Otherwise explicit pixels. */
+    size: "canvas" | {
+        width: number;
+        height: number;
+    };
+    /** If true, the color attachment resolves to the swapchain texture. The RT still
+     *  owns the MSAA texture (when sampleCount \> 1) and the depth texture; only the
+     *  final color is the swapchain view, acquired per frame and patched in at execute
+     *  time. With sampleCount === 1 the RT owns no color texture (the swap view is the
+     *  color attachment directly). */
+    resolveToSwapchain?: boolean;
+    /** Override projection Y-flip. Defaults to true for offscreen targets and false for swapchain targets. */
+    flipY?: boolean;
+}
+
+/** Signature of a render target's attachment set — enough to key a GPURenderPipeline. */
+export declare interface RenderTargetSignature {
+
+/** A frame-graph task that records a single `RenderPass`, binds the scene's `RenderTarget`, and draws renderables into it. */
+export declare interface RenderTask extends Task {
+    readonly name: string;
+    /** Render tasks are scene-bound because they consume scene camera, lights, and renderables. */
+    readonly scene: SceneContext;
    /** Add a mesh to this task's explicit render list with an optional per-pass material override.
+     *  Resolved at `record()` time via `material._buildGroup._rebuildSingle`,
+     *  so the mesh's material family must already have been registered with
+     *  the scene (so its batch builder has run). */
+    addMesh(mesh: Mesh, opts?: {
+        material?: Material;
+    }): void;
+
+/** Configuration for `createRenderTask`: render target, clear state, optional camera override, and transmission settings. */
+export declare interface RenderTaskConfig {
+    name: string;
+    /** TODO: rt should not live in this config long-term. Until texture
+     *  management is virtualized, callers must provide the concrete target; once
+     *  virtualized, the task should create/manage its own render target. */
+    rt: RenderTarget;
+    /** Background clear color. May be mutated frame-to-frame. */
+    clrColor?: GPUColorDict;
+    /** When true, controls color + depth `loadOp` ("clear"). When false, use "load"
+     *  so this pass overlays previous content (UI overlays, second scene, etc.). */
+    clr?: boolean;
+    /** Per-pass camera override. Null/undefined uses `scene.camera`. */
+    cam?: Camera | null;
+    /** Use canvas dimensions, not render-target dimensions, for this pass's scene UBO aspect. */
+    cs?: boolean;
+    /** Scene-texture transmission settings. `copyCount: 0` copies before every transmissive draw.
+     *  `generateMipmaps: false` allocates only mip 0 for the refraction texture and skips mip generation. */
+    transmission?: {
+        copyCount?: number;
+        generateMipmaps?: boolean;
+    };
+}
+
+/**
+ * Reset all variant-participating meshes to their original (default) materials.
+ */
+export declare function resetVariant(container: AssetContainer): void;
+
+/** Resize the swapchain backing-store to match the canvas client size. When the size
+ *  changes, asks every registered rendering context to rebuild its canvas-sized GPU
+ *  resources via the optional `_resize` hook. If the canvas has not been laid out yet,
+ *  preserves its explicit backing-store size.
+ *
+ *  Only DOM canvases are auto-sized from layout here. An `OffscreenCanvas` has no layout
+ *  box, so its size is pushed in externally via {@link setEngineSize} (e.g. from the host
+ *  thread that owns the visible canvas) and this call is a no-op for it. */
+export declare function resizeEngine(engine: EngineContext): void;
+
+/** Resolve a Babylon-style normalized viewport to integer render-target pixels.
+ *  Babylon viewport y is normalized from the bottom; WebGPU viewport/scissor y is from the top. */
+export declare function resolveCameraViewport(camera: Camera | null | undefined, targetWidth: number, targetHeight: number): PixelViewport;
+
+/** Options for `createRibbonData`: a set of parallel paths joined into a strip. */
+export declare interface RibbonOptions {
+    pathArray: Vec3[][];
+    closeArray?: boolean;
+    closePath?: boolean;
+    offset?: number;
+}
+
+/** Scattering sub-feature. Presence enables screen-space subsurface scattering.
+ *  NOTE: PrePass/SSS pipeline is not yet implemented — this type is reserved. */
+declare interface ScatteringProps {
+    /** Per-channel scattering diffusion distance. */
+    diffusionDistance?: [number, number, number];
+    /** World-space scale factor for the diffusion kernel. Default 1.0. */
+    metersPerUnit?: number;
+}
+
+/** Top-level scene context — pure state, no attached methods. */
+export declare interface SceneContext extends RenderingContext_2 {
+    readonly engine: EngineContext;
+    clearColor: GPUColorDict;
+    camera: Camera | null;
+    lights: LightBase[];
+    imageProcessing: ImageProcessingConfig;
+    /** All meshes added to the scene (standard + PBR). */
+    meshes: Mesh[];
+    /** Animation groups loaded from glTF or created manually. */
+    animationGroups: AnimationGroup[];
+    /** Fog configuration. Null = no fog. */
+    fog: FogConfig | null;
+    /** Scene clip plane as (normal.x, normal.y, normal.z, d). Matches Babylon.js Plane `dot(worldPosition, plane) > 0` discard semantics. */
+    clipPlane: ClipPlane | null;
+    /** Shadow generators registered on this scene. */
+    shadowGenerators: ShadowGenerator[];
+    /** Background material primaryColor (linear RGB). Default from Babylon createDefaultEnvironment. */
+    environmentPrimaryColor?: [number, number, number];
+    /** Environment cubemap Y rotation in radians. */
+    envRotationY?: number;
+    /** Fixed delta time in ms for deterministic animation. 0 = use real rAF delta. */
+    fixedDeltaMs: number;
+
+/** Options passed to the scene-context factory. */
+export declare interface SceneContextOptions {
+    defaultRenderTask?: boolean;
+}
+
+/** Common base for all scene entities: TRS transform, parent/children hierarchy, and a cached world matrix. */
+export declare interface SceneNode {
+    name: string;
+    children: SceneNode[];
+    position: ObservableVec3;
+    /** Quaternion rotation — source of truth for the local matrix. */
+    rotationQuaternion: ObservableQuat;
+    /** Euler XYZ bidirectional proxy — reads decompose current quat; writes update quat atomically. */
+    rotation: EulerProxy;
+    scaling: ObservableVec3;
+    parent: IWorldMatrixProvider | null;
+    readonly worldMatrix: Mat4;
+    readonly worldMatrixVersion: number;
    /** Self-visibility. Undefined/true = visible; `false` skips render + camera AABB.
+     *  Cascade is materialized at write-time by `setSubtreeVisible`. */
+    visible?: boolean;
+}
+
+/** Updatable scene uniforms — called once per frame before any draw calls.
+ *  Multiple renderables may share a scene UBO; only one updater is needed per UBO. */
+export declare interface SceneUniformUpdater {
+    /** Write per-frame camera/light/fog data to the scene UBO. */
+    update(engine: EngineContext): void;
+}
+
+/**
+ * Select a material variant by name on a loaded glTF asset.
+ *
+ * Two-step operation:
+ * 1. Restores ALL variant-participating meshes to their original (default) materials.
+ * 2. Applies the selected variant's material overrides.
+ *
+ * This ensures meshes without a mapping for the new variant revert to their defaults,
+ * even when switching between variants (e.g. Red → White).
+ *
+ * Works both before and after addToScene():
+ * - Before: materials are set directly (renderable built later).
+ * - After: the property-setter intercept triggers renderable rebuild automatically.
+ */
+export declare function selectVariant(container: AssetContainer, variantName: string): void;
+
+/** Mark an animation group as additive. Reference defaults to frame 0, matching Babylon.js MakeAnimationAdditive. */
+export declare function setAnimationAdditive(group: AnimationGroup, options?: AnimationAdditiveOptions): void;
+
+/** Registers a single category `handler` on `manager` that drives every task tagged with `category` in one pass.
+ *  @throws If `category` is empty. */
+export declare function setAnimationTaskCategoryHandler(manager: AnimationManager, category: string, handler: AnimationTaskCategoryHandler): void;
+
+/** Set the weighted contribution for an animation group. Feature-specific mixers remain explicit opt-ins. */
+export declare function setAnimationWeight(group: AnimationGroup, weight: number): void;
+
+/**
+ * Set the custom-shader `fx.params` vec4 for a billboard system created with a `customShader`.
+ * No-op effect on systems without one (the value is simply stored). Read in WGSL as `fx.params`.
+ */
+export declare function setBillboardShaderParams(system: BillboardSpriteSystem, params: readonly [number, number, number, number]): void;
+
+/**
+ * Sets the atlas frame of the billboard sprite referenced by `handle`, preserving its world size and flip state.
+ * @param handle - Handle of the sprite to update.
+ * @param frame - Atlas frame index.
+ * @throws If the handle has already been removed.
+ */
+export declare function setBillboardSpriteFrame(handle: BillboardSpriteHandle, frame: number): void;
+
+/**
+ * Update only the frame UVs for one billboard sprite.
+ *
+ * The sprite keeps its explicit `sizeWorld`/saved size. Pixel frame dimensions
+ * do not imply a world-space resize; call `updateBillboardSpriteIndex` with
+ * both `frame` and `sizeWorld` when that is desired. Existing flip state is
+ * preserved for non-degenerate UV ranges.
+ */
+export declare function setBillboardSpriteFrameIndex(system: BillboardSpriteSystem, index: number, frame: number): void;
+
+/**
+ * Bind a texture to one of the effect's texture slots, marking the bind group dirty so it is rebuilt.
+ * @param wrapper - The effect wrapper to update.
+ * @param bindingNameOrIndex - The texture binding's name or numeric index.
+ * @param texture - The texture to bind.
+ */
+export declare function setEffectTexture(wrapper: EffectWrapper, bindingNameOrIndex: string | number, texture: Texture2D): void;
+
+/**
+ * Write data into the effect's uniform buffer(s). Pass a single buffer to write the
+ * wrapper's only uniform slot, or a record keyed by binding name/index to write specific slots.
+ * @param wrapper - The effect wrapper to update.
+ * @param data - The uniform bytes, or a map of binding key to uniform bytes.
+ */
+export declare function setEffectUniforms(wrapper: EffectWrapper, data: ArrayBuffer | ArrayBufferView | Record<string | number, ArrayBuffer | ArrayBufferView>): void;
+
+/** Set the swapchain backing-store size directly, in device pixels. Use this when the
+ *  engine renders into an `OffscreenCanvas` whose layout size is only known on another
+ *  thread (the host posts the CSS size × devicePixelRatio). When the size changes, asks
+ *  every registered rendering context to rebuild its canvas-sized GPU resources via the
+ *  optional `_resize` hook. */
+export declare function setEngineSize(engine: EngineContext, widthPx: number, heightPx: number): void;
+
+/** Raise (or lower) the maximum number of scene lights in the shared lights UBO.
+ *  Must be called BEFORE scene pipelines are compiled — existing pipelines
+ *  and UBOs bake the cap into their WGSL/layout. */
+export declare function setMaxLights(n: number): void;
+
+/** Update morph target weights on CPU and GPU.
+ *  Only the first four weights are used, matching the current morph target limit.
+ *  @param engine - Engine context that owns the morph target GPU buffer.
+ *  @param morphTargets - Morph target data returned by `createMorphTargets()`.
+ *  @param weights - New morph weights; missing slots are reset to 0.
+ */
+export declare function setMorphTargetWeights(engine: EngineContext, morphTargets: MorphTargetData, weights: ArrayLike<number>): void;
+
+/** Set the seed used by Recast's randomized queries (e.g. `findRandomPointAroundCircle`). */
+export declare function setNavigationRandomSeed(plugin: NavigationPlugin, seed: number): void;
+
+/**
+ * Reparents `child` while preserving its current world-space transform, mirroring
+ * Babylon.js `TransformNode.setParent()`.
+ * @param child - The mesh to reparent.
+ * @param parent - The new parent (any world-matrix provider), or `null` to detach to world space.
+ */
+export declare function setParent(child: Mesh, parent: IWorldMatrixProvider | null): void;
+
+/**
+ * Sets a body's mass and a matching diagonal inertia tensor.
+ * @param world - The physics world.
+ * @param body - The body to update.
+ * @param mass - Mass in kilograms.
+ */
+export declare function setPhysicsBodyMass(world: PhysicsWorld, body: PhysicsBody, mass: number): void;
+
+/**
+ * Assigns a collision shape to a body.
+ * @param world - The physics world.
+ * @param body - The body to attach the shape to.
+ * @param shape - The collision shape.
+ */
+export declare function setPhysicsBodyShape(world: PhysicsWorld, body: PhysicsBody, shape: PhysicsShape): void;
+
+/**
+ * Sets the world's gravity vector.
+ * @param world - The physics world.
+ * @param gravity - Gravity acceleration in m/s².
+ */
+export declare function setPhysicsGravity(world: PhysicsWorld, gravity: Vec3): void;
+
+/**
+ * Sets a shape's surface material properties.
+ * @param world - The physics world.
+ * @param shape - The collision shape.
+ * @param friction - Friction coefficient (used for both static and dynamic friction).
+ * @param restitution - Bounciness in `[0, 1]`.
+ */
+export declare function setPhysicsShapeMaterial(world: PhysicsWorld, shape: PhysicsShape, friction: number, restitution: number): void;
+
+/**
+ * Sets the fixed simulation timestep used by each world step.
+ * @param world - The physics world.
+ * @param dt - Timestep in seconds (e.g. `1 / 60`).
+ */
+export declare function setPhysicsTimestep(world: PhysicsWorld, dt: number): void;
+
+/**
+ * Clamps the maximum linear and angular speeds of bodies in the world.
+ * @param world - The physics world.
+ * @param maxLinear - Maximum linear speed.
+ * @param maxAngular - Maximum angular speed.
+ */
+export declare function setPhysicsVelocityLimits(world: PhysicsWorld, maxLinear: number, maxAngular: number): void;
+
+/** Set a declared `f32` uniform. Convenience wrapper over `setShaderUniform()`. */
+export declare function setShaderFloat(material: ShaderMaterial, name: string, value: number): void;
+
+/** Set a declared `mat4x4<f32>` uniform. Convenience wrapper over `setShaderUniform()`. */
+export declare function setShaderMatrix(material: ShaderMaterial, name: string, value: Float32Array): void;
+
+/** Bind (or clear) the texture for a declared sampler, enforcing that depth and
+ *  non-depth samplers receive a matching `Texture2D`.
+ *  @param material - Target material.
+ *  @param name - Declared sampler name.
+ *  @param texture - Texture to bind, or `null` to clear. */
+export declare function setShaderTexture(material: ShaderMaterial, name: string, texture: Texture2D | null): void;
+
+/** Set a declared uniform's value, validating its element count against the
+ *  declared type and bumping the material's UBO version.
+ *  @param material - Target material.
+ *  @param name - Declared uniform name.
+ *  @param value - New value (scalar, array, or `Float32Array`). */
+export declare function setShaderUniform(material: ShaderMaterial, name: string, value: ShaderUniformValue): void;
+
+/** Set a declared `vec3<f32>` uniform. Convenience wrapper over `setShaderUniform()`. */
+export declare function setShaderVector3(material: ShaderMaterial, name: string, value: readonly [number, number, number]): void;
+
+/** Register scene-owned shadow caster inputs for a generator. */
+export declare function setShadowTaskCasterMeshes(shadowGenerator: ShadowGenerator, casterMeshes: readonly Mesh[]): void;
+
+/**
+ * Sets the atlas frame of the sprite referenced by `handle`.
+ * @param handle - Handle of the sprite to update.
+ * @param frame - Atlas frame index.
+ * @throws If the handle has already been removed.
+ */
+export declare function setSprite2DFrame(handle: Sprite2DHandle, frame: number): void;
+
+/**
+ * Update only the frame UVs for one sprite.
+ *
+ * The sprite keeps its explicit `sizePx`/saved size. For atlas-driven size
+ * changes, call `updateSprite2DIndex(layer, index, { frame, sizePx })`.
+ * Existing flip state is preserved for non-degenerate UV ranges.
+ */
+export declare function setSprite2DFrameIndex(layer: Sprite2DLayer, index: number, frame: number): void;
+
+/**
+ * Set the user `fx.params` vec4 fed to this layer's custom shader (`createSprite2DCustomShader`)
+ * each frame. No visual effect unless the layer was created with a `customShader`. Read in WGSL
+ * as `fx.params`. Mutates in place; the renderer re-uploads the small FX UBO next frame.
+ */
+export declare function setSprite2DShaderParams(layer: Sprite2DLayer, params: readonly [number, number, number, number]): void;
+
+/**
+ * Set the per-sprite UV scroll offset for one sprite of a `uvScroll` layer (live). The two floats
+ * are added to the sprite's sampled UV in the vertex stage — driving parallax / infinite-scroll
+ * backgrounds without re-uploading texture coordinates. Marks only this sprite's range dirty.
+ *
+ * Throws if the layer was not created with `Sprite2DLayerOptions.uvScroll: true` (non-scroll layers
+ * carry no uvOffset slot) or if `index` is out of range.
+ */
+export declare function setSprite2DUvOffset(layer: Sprite2DLayer, index: number, uvOffset: readonly [number, number]): void;
+
+/** Set `visible` on `node` and all descendants (via `node.children`). glTF
+ *  KHR_node_visibility specifies that children inherit their parent's
+ *  invisibility — we materialize this at set-time so the render hot-path
+ *  only has to check a single boolean per mesh. */
+declare function setSubtreeVisible(node: SceneNode, v: boolean): void;
+export { setSubtreeVisible as setMeshVisible }
+export { setSubtreeVisible }
+
+/** Set per-instance RGBA colors for a thin-instanced mesh. */
+export declare function setThinInstanceColors(mesh: Mesh, colors: Float32Array): void;
+
+/** Update one instance's matrix. */
+export declare function setThinInstanceMatrix(mesh: Mesh, index: number, matrix: Mat4): void;
+
+/** Set all instances from a pre-built matrix array. */
+export declare function setThinInstances(mesh: Mesh, matrices: Float32Array, count: number): void;
+
+/**
+ * Write bytes into the uniform effect's single uniform buffer.
+ * @param wrapper - The uniform effect wrapper to update.
+ * @param data - Uniform bytes to upload.
+ */
+export declare function setUniformEffectUniforms(wrapper: UniformEffectWrapper, data: ArrayBuffer | ArrayBufferView): void;
+
+/** Vertex attribute names a ShaderMaterial can bind. */
+export declare type ShaderAttributeName = "position" | "normal" | "uv" | "uv2" | "tangent" | "color";
+
+/** A resolved WGSL preprocessor define (name + value). */
+export declare interface ShaderDefine {
+    readonly name: string;
+    readonly value: ShaderDefineValue;
+}
+
+/** Map of WGSL preprocessor define names to their values. */
+export declare type ShaderDefineMap = Readonly<Record<string, ShaderDefineValue>>;
+
+/** Value of a WGSL preprocessor define — boolean toggle or numeric constant. */
+export declare type ShaderDefineValue = boolean | number;
+
+/** A custom WGSL material: compiled from user-supplied vertex/fragment sources
+ *  with declared attributes, uniforms, samplers, and defines. Update its values
+ *  via `setShaderUniform()` / `setShaderTexture()` and friends. */
+export declare interface ShaderMaterial extends Material {
+    readonly name?: string;
+    readonly vertexSource: string;
+    readonly fragmentSource: string;
+    readonly attributes: readonly ShaderAttributeName[];
+    readonly uniformDecls: readonly ShaderUniformDecl[];
+    readonly samplerDecls: readonly ShaderSamplerDecl[];
+    readonly defines: readonly ShaderDefine[];
+    readonly needAlphaBlending: boolean;
+    readonly blendMode: "alpha" | "additive";
+    readonly needAlphaTesting: boolean;
+    readonly backFaceCulling: boolean;
+    readonly depthWrite: boolean;
+    readonly depthCompare: GPUCompareFunction;
+
+/** Options describing a ShaderMaterial: WGSL sources, attributes, uniforms,
+ *  samplers, defines, and blend/depth state. Passed to `createShaderMaterial()`. */
+export declare interface ShaderMaterialOptions {
+    readonly name?: string;
+    readonly vertexSource: string;
+    readonly fragmentSource: string;
+    readonly attributes: readonly ShaderAttributeName[];
+    readonly uniforms?: readonly ShaderUniformOption[];
+    readonly samplers?: readonly ShaderSamplerOption[];
+    readonly defines?: ShaderDefineMap;
+    readonly needAlphaBlending?: boolean;
+    /** Blend equation used when `needAlphaBlending` is set. "alpha" (default) is
+     *  standard src-over; "additive" adds the fragment's premultiplied-by-alpha
+     *  color to the framebuffer, which is the right choice for glows/light FX. */
+    readonly blendMode?: "alpha" | "additive";
+    readonly needAlphaTesting?: boolean;
+    readonly backFaceCulling?: boolean;
+    readonly depthWrite?: boolean;
+    readonly depthCompare?: GPUCompareFunction;
+}
+
+/** A sampler declaration: WGSL identifier and the bound texture's sample type. */
+export declare interface ShaderSamplerDecl {
+    readonly name: string;
+    readonly sampleType?: "float" | "unfilterable-float" | "depth";
+}
+
+/** A sampler entry: either a bare sampler name or an explicit declaration. */
+export declare type ShaderSamplerOption = string | ShaderSamplerDecl;
+
+/** Built-in uniform names automatically populated by the renderer each frame
+ *  (transforms, camera position, screen size, alpha cutoff). */
+export declare type ShaderSystemUniformName = "world" | "view" | "projection" | "viewProjection" | "worldView" | "worldViewProjection" | "cameraPosition" | "screenSize" | "alphaCutoff";
+
+/** A custom uniform declaration: WGSL identifier, type, and optional default. */
+export declare interface ShaderUniformDecl {
+    readonly name: string;
+    readonly type: ShaderUniformType;
+    readonly defaultValue?: number | readonly number[];
+}
+
+/** A uniform entry: either a system uniform name or an explicit custom declaration. */
+export declare type ShaderUniformOption = ShaderSystemUniformName | ShaderUniformDecl;
+
+/** WGSL scalar/vector/matrix types supported for ShaderMaterial uniforms. */
+export declare type ShaderUniformType = "f32" | "u32" | "i32" | "vec2<f32>" | "vec3<f32>" | "vec4<f32>" | "mat4x4<f32>";
+
+/** Accepted value shape when setting a ShaderMaterial uniform. */
+export declare type ShaderUniformValue = number | readonly number[] | Float32Array;
+
+/** Runtime state for a light's shadow generator: shadow technique, map textures, light matrix, and per-frame task hooks. */
+export declare interface ShadowGenerator {
+
+/** Scene-owned frame-graph task that schedules shadow-map generation across the scene's shadow generators. */
+export declare interface ShadowTask extends Task {
+    readonly name: "shadow";
+}
+
+/** Sheen layer properties. Maps to BJS PBRMaterial.sheen sub-object. */
+declare interface SheenProps {
+    /** Whether sheen is active. Default false. */
+    isEnabled: boolean;
+    /** Sheen color (linear RGB). Default [1, 1, 1]. */
+    color?: [number, number, number];
+    /** Sheen roughness. Default 0.0. */
+    roughness?: number;
+    /** Sheen intensity (0=off, 1=full). Default 1.0. */
+    intensity?: number;
+    /** Optional sheen tint texture (modulates sheen color). Loaded via loadTexture2D(). */
+    texture?: Texture2D;
+    /** When true (recommended for glTF), applies proper sheen albedo scaling
+     *  on the base layer and treats the sheen texture as already-linear (no pow).
+     *  When false (default, legacy), applies pow(rgb, 2.2) to the sheen texture
+     *  and uses a (1-F0) attenuation on the sheen lobe without base-layer scaling. */
+    albedoScaling?: boolean;
+}
+
+/** Connects a skeleton to its GPU bone texture for per-frame updates. */
+declare interface SkeletonBinding {
+    readonly jointNodes: readonly number[];
+    readonly inverseBindMatrices: Float32Array;
+    readonly invMeshWorld: Mat4;
+    readonly boneTexture: GPUTexture;
+    readonly boneCount: number;
+    readonly boneMatrices: Float32Array;
+    readonly runtimeSkeleton?: SkeletonData;
+}
+
+/** Skeleton GPU data — bone texture + vertex buffers for skinning.
+ *  Created by createSkeleton() in skeleton/create-skeleton.ts.
+ *  Attached to mesh.skeleton. */
+declare interface SkeletonData {
+    readonly boneTexture: GPUTexture;
+    readonly boneCount: number;
+    readonly jointsBuffer: GPUBuffer;
+    readonly weightsBuffer: GPUBuffer;
+    readonly joints: Uint16Array | Uint8Array;
+    readonly weights: Float32Array;
+    readonly boneMatrices: Float32Array;
+    /** Extra joints/weights for 8-bone skinning (JOINTS_1/WEIGHTS_1). */
+    readonly joints1Buffer: GPUBuffer | null;
+    readonly weights1Buffer: GPUBuffer | null;
+    readonly joints1: Uint16Array | Uint8Array | null;
+    readonly weights1: Float32Array | null;
+}
+
+/** Procedural UV sphere — matches Babylon MeshBuilder.CreateSphere defaults.
+ *  Generates vertex positions, normals, and indices for a unit sphere.
+ *  Left-handed winding (CCW front face) to match Babylon. */
+export declare interface SphereMeshData {
+    positions: Float32Array;
+    normals: Float32Array;
+    uvs: Float32Array;
+    indices: Uint32Array;
+    vertexCount: number;
+    indexCount: number;
+}
+
+/** Options for {@link createSphereData}. Subset of Babylon's CreateSphere. */
+export declare interface SphereOptions {
+    segments?: number;
+    diameter?: number;
+    diameterX?: number;
+    diameterY?: number;
+    diameterZ?: number;
+}
+
+export declare interface SpotLight extends LightBase {
+    readonly lightType: "spot";
+    position: ObservableVec3;
+    direction: ObservableVec3;
+    /** Full cone angle in radians. */
+    angle: number;
+    /** Falloff exponent — higher = sharper spotlight. */
+    exponent: number;
+    diffuse: [number, number, number];
+    specular: [number, number, number];
+    intensity: number;
+    range: number;
+}
+
+/** A compiled-on-demand custom sprite shader. Pure data; pass as `customShader` to `createSprite2DLayer`. */
+export declare interface Sprite2DCustomShader {
+
+/** Options for {@link createSprite2DCustomShader}. */
+export declare interface Sprite2DCustomShaderOptions {
+    /** WGSL fragment body. See the module docs for the in-scope identifiers. */
+    readonly fragment: string;
+    /** Extra textures, in binding order. Each contributes a `texture_2d` + `sampler`. */
+    readonly extraTextures?: readonly Sprite2DCustomTexture[];
+}
+
+/** One extra texture bound after the atlas. In WGSL it becomes `<name>Tex` + `<name>Samp`. */
+export declare type Sprite2DCustomTexture = CustomShaderTexture;
+
+/** Depth participation. `"none"` uses `SpriteRenderer`; depth-enabled modes use `addToScene`. */
+export declare type Sprite2DDepthMode = "none" | "test" | "test-write";
+
+/** Stable identity for a single 2D sprite that survives swap-remove reindexing. */
+export declare interface Sprite2DHandle {
    readonly layer: Sprite2DLayer;
+    readonly id: number;
+}
+
+/** A `Sprite2DLayer` — pure data, no methods. */
+export declare interface Sprite2DLayer {
    readonly atlas: SpriteAtlas;
+    readonly depth: Sprite2DDepthMode;
+    readonly blendMode: SpriteBlendMode;
+    opacity: number;
+    visible: boolean;
+    order: number;
+    view: Sprite2DView;
+    /** Layer-wide pivot in normalised sprite-local space; see `Sprite2DLayerOptions.pivot`. */
+    pivot: [number, number];
+    /**
+     * Opt-in custom fragment shader for this layer; see `Sprite2DLayerOptions.customShader`.
+     * **Absent** (not `null`) on plain layers — never default-initialized, so the always-loaded
+     * path carries zero custom-shader bytes (see `sprite-fx-hook.ts`). Present only when the
+     * layer was created with a `customShader`.
+     */
+    readonly customShader?: Sprite2DCustomShader;
+    /**
+     * User `fx.params` vec4 fed to a custom shader each frame; mutate via `setSprite2DShaderParams`.
+     * **Absent** on plain layers (only allocated for custom-shader layers, or lazily by the setter).
+     */
+    shaderParams?: [number, number, number, number];
    /** Default NDC depth for newly added sprites; see `Sprite2DLayerOptions.layerZ`. */
+    layerZ: number;
+    readonly count: number;
+
+/** Options accepted by `createSprite2DLayer`. */
+export declare interface Sprite2DLayerOptions {
+    capacity?: number;
+    blendMode?: SpriteBlendMode;
+    opacity?: number;
+    visible?: boolean;
+    order?: number;
+    view?: Partial<Sprite2DView>;
+    depth?: Sprite2DDepthMode;
+    /**
+     * Layer-wide rotation / scaling pivot in normalised sprite-local space
+     * (`[0,0]` = top-left, `[0.5, 0.5]` = center, `[1,1]` = bottom-right).
+     * The pivot point of every sprite in the layer lands at its `positionPx`
+     * and is the center of `rotation`. Defaults to `[0.5, 0.5]` (center) to
+     * match Babylon.js sprite behavior. Per-sprite / per-frame pivot is a
+     * future PR — most 2D HUD layers want one uniform pivot anyway.
+     */
+    pivot?: [number, number];
+    /**
+     * Opt-in per-layer custom fragment shader (see `createSprite2DCustomShader`). Works on both
+     * pure-2D (`depth: "none"`) layers drawn by a `SpriteRenderer` and depth-hosted
+     * (`depth: "test" | "test-write"`) layers. Drives procedural effects (animated sky, clouds,
+     * water / heat shimmer, twinkle, vignette) from a built-in `fx.time` clock plus an optional
+     * `fx.params` vec4 set via `setSprite2DShaderParams`.
+     */
+    customShader?: Sprite2DCustomShader;
+    /**
+     * Default NDC depth (`0` = near, `1` = far) for sprites added to this layer when their
+     * `Sprite2DProps.z` is omitted. Only meaningful for `depth: "test" | "test-write"` layers
+     * (depth-hosted sprites added to a `SceneContext` via `addDepthHostedSpriteLayer`).
+     *
+     * Depth-hosted layers store one Z per sprite (slot [13] of their 14-float instance buffer),
+     * so a single layer can mix sprites at different depths — e.g. one in front of a box, one
+     * behind it. Pure-2D layers (`depth: "none"`) use the 13-float HUD layout and carry no Z slot.
+     * Defaults to `0.5`. Mutating `layer.layerZ` after sprites have been added does **not**
+     * retroactively change them; it only affects sprites added afterwards. To move an existing
+     * depth-hosted sprite, call `updateSprite2DIndex(layer, idx, { z: … })`.
+     */
+    layerZ?: number;
+    /**
+     * Opt-in per-sprite UV scroll offset. When `true`, every sprite gains two extra instance
+     * floats (`uvOffset.xy`) added to its sampled UV in the vertex stage — enabling parallax /
+     * infinite-scroll backgrounds without re-uploading texture coordinates. Set the offset per
+     * sprite via `Sprite2DProps.uvOffset` (on add) or `setSprite2DUvOffset` (live).
+     *
+     * **Zero cross-scene cost:** layers created without `uvScroll` keep the narrow 13/14-float
+     * layout, the base vertex attributes, and the base WGSL — they ship none of the uvScroll
+     * widening. The wider stride, the extra `@location(7)` attribute, and the `+ iUvOffset` WGSL
+     * are gated directly on this per-layer flag. Defaults to `false`.
+     *
+     * Pairs naturally with a tileable atlas texture sampled in `repeat` wrap mode
+     * (`loadSpriteAtlas(..., { textureOptions: { addressModeU: "repeat", addressModeV: "repeat" } })`).
+     */
+    uvScroll?: boolean;
+}
+
+/** Per-sprite init record passed to `addSprite2DIndex` / `updateSprite2DIndex`. */
+export declare interface Sprite2DProps {
+    positionPx: [number, number];
+    sizePx?: [number, number];
+    frame?: number;
+    rotation?: number;
+    color?: [number, number, number, number];
+    flipX?: boolean;
+    flipY?: boolean;
+    visible?: boolean;
+    /** Reserved for picking. Accepted but unused today. */
+    pickable?: boolean;
+    /** Reserved for clip animation. Accepted but unused today. */
+    clip?: unknown;
+    /**
+     * Per-sprite NDC depth (`0` = near, `1` = far). Only stored and consumed by depth-hosted
+     * layers (`depth: "test" | "test-write"`); pure-2D HUD layers use a 13-float layout and
+     * do not allocate a Z slot. When omitted on add for a depth-hosted layer, defaults to the
+     * **owning layer's** `layerZ` at the moment of insertion. When omitted on update, the
+     * sprite's existing Z is preserved. Mutate freely — the next binding update will re-upload
+     * only the dirty range.
+     */
+    z?: number;
+    /**
+     * Per-sprite UV scroll offset added to the sampled UV in the vertex stage. Only stored and
+     * consumed by `uvScroll` layers (created with `Sprite2DLayerOptions.uvScroll: true`); non-scroll
+     * layers use the narrow 13/14-float layout and do not allocate a uvOffset slot. When omitted on
+     * add for a uvScroll layer, defaults to `[0, 0]`. When omitted on update, the sprite's existing
+     * offset is preserved. Live updates: `setSprite2DUvOffset`.
+     */
+    uvOffset?: [number, number];
+}
+
+/** Per-layer 2D camera (pan / zoom / rotation). Identity = pixel-perfect HUD. */
+export declare interface Sprite2DView {
+    positionPx: [number, number];
+    zoom: number;
+    rotation: number;
+}
+
+/** Handle to a sprite animation manager attached to a scene or renderer; dispose it to detach. */
+export declare interface SpriteAnimationBinding {
    active: boolean;
+
+/** Owns a set of sprite frame animations and advances them in lockstep. */
+export declare interface SpriteAnimationManager {
    animations: SpriteFrameAnimation[];
+    fixedDeltaMs: number;
+    running: boolean;
+
+/** Optional configuration for a sprite animation manager. */
+export declare interface SpriteAnimationManagerOptions {
+    readonly fixedDeltaMs?: number;
+    /** Optional. Called each tick of the manager's autonomous loop with the elapsed milliseconds. */
+    readonly onUpdate?: (deltaMs: number) => void;
+}
+
+/** Abstracts the sprite a frame animation drives, decoupling the animation core from each sprite family. */
+export declare interface SpriteAnimationTarget {
+    /** Sets the target's current atlas frame. */
+    readonly setFrame: (frame: number) => void;
+    /** Optional. Removes the target from its system, used when `removeWhenFinished` is set. */
+    readonly remove?: () => void;
+    /** Optional. Returns `false` when the target no longer exists, stopping the animation. */
+    readonly isAlive?: () => boolean;
+}
+
+/** A loaded sprite atlas — pure data, no methods. Frames are addressed by integer index. */
+export declare interface SpriteAtlas {
+    readonly texture: Texture2D;
+    readonly textureSizePx: readonly [number, number];
+    readonly frames: readonly SpriteFrame[];
+    readonly premultipliedAlpha: boolean;
+}
+
+/** One source frame for `createSpriteAtlasFromFrames`. */
+export declare interface SpriteAtlasFrameSource {
+    /** Tightly packed RGBA8 bytes — `width * height * 4`, row-major, top-to-bottom, straight alpha. */
+    readonly pixels: Uint8Array;
+    readonly width: number;
+    readonly height: number;
+    /** Pivot in [0,1] of the frame. Default `[0.5, 0.5]`. */
+    readonly pivot?: readonly [number, number];
+    /** Recorded on the emitted `SpriteFrame.name`. */
+    readonly name?: string;
+}
+
+/** Options for `createSpriteAtlasFromFrames`. */
+export declare interface SpriteAtlasPackOptions {
+    /** Transparent gap (px) between packed frames; guards against bilinear bleed. Default `1`. */
+    paddingPx?: number;
+    /** Shelf width (px) before wrapping to a new row. Default `1024`. */
+    maxWidthPx?: number;
+    /** Min/mag filter for the packed texture. Default `"nearest"`. */
+    sampling?: SpriteSampling;
+    premultipliedAlpha?: boolean;
+}
+
+/**
+ * Additive blending. The sprite's RGB, scaled by its own alpha, is added to the framebuffer,
+ * so glows / light shafts / sparks stack and brighten (stars, embers, fireflies, sun shafts).
+ */
+export declare const spriteBlendAdditive: SpriteBlendDescriptor;
+
+/**
+ * Straight-alpha "over" blending (the default). RGB is composited by source alpha; this is
+ * the standard transparency mode for HUDs, UI, and soft-edged sprites.
+ */
+export declare const spriteBlendAlpha: SpriteBlendDescriptor;
+
+/**
+ * A sprite-layer blend descriptor. Pass one of the exported `spriteBlend*` values to
+ * `createSprite2DLayer({ blendMode })`. The fields are internal plumbing; treat the value
+ * as opaque.
+ */
+export declare interface SpriteBlendDescriptor {
+
+/**
+ * Output blend mode for a sprite layer — a pure-data descriptor value. Import one of
+ * `spriteBlendAlpha` (default), `spriteBlendPremultiplied`, or `spriteBlendAdditive` and pass
+ * it as `Sprite2DLayerOptions.blendMode`. (Type alias of {@link SpriteBlendDescriptor}.)
+ */
+export declare type SpriteBlendMode = SpriteBlendDescriptor;
+
+/**
+ * Multiply blending. The framebuffer is multiplied by the sprite's RGB (`result = src * dst`),
+ * so the sprite darkens / tints what is behind it — ideal for soft shadow blobs, dirt / grime
+ * decals, ambient-occlusion stamps, and coloured "gel" overlays that modulate the scene colour.
+ * Sprites should be opaque (or white where they must leave the background unchanged) since a pure
+ * multiply ignores source alpha for RGB.
+ */
+export declare const spriteBlendMultiply: SpriteBlendDescriptor;
+
+/**
+ * Premultiplied-alpha "over" blending. The sprite's RGB is assumed already multiplied by its
+ * alpha; per-layer opacity scales RGB and A together for a correct fade.
+ */
+export declare const spriteBlendPremultiplied: SpriteBlendDescriptor;
+
+/** A single frame in an atlas. UVs in [0,1]; pivot in [0,1] of the frame. */
+export declare interface SpriteFrame {
+    readonly name?: string;
+    readonly uvMin: readonly [number, number];
+    readonly uvMax: readonly [number, number];
+    readonly sourceSizePx: readonly [number, number];
+    readonly pivot: readonly [number, number];
+}
+
+/** A single frame-range animation playing on a {@link SpriteAnimationTarget}. */
+export declare interface SpriteFrameAnimation {
    readonly target: SpriteAnimationTarget;
+    from: number;
+    to: number;
+    current: number;
+    loop: boolean;
+    delayMs: number;
+    accumulatedMs: number;
+    animationStarted: boolean;
+    /** Optional. Called once when a non-looping animation reaches its last frame. */
+    onEnd?: () => void;
+    removeWhenFinished: boolean;
+}
+
+/**
+ * A `SpriteRenderer` — pure data, plugs into `engine._renderingContexts`.
+ * Inherits `clearColor`, `_drawCallsPre`, `_update`, `_record` from `RenderingContext`;
+ * adds only its discriminator tag and the renderer-owned layer list.
+ *
+ * **Lifecycle.** A `SpriteRenderer` is independent of any `SceneContext` — it is
+ * registered directly on the engine, opens its own sampleCount=1 swapchain pass, and
+ * must be disposed by the caller. Two patterns:
+ *
+ *   1. **Standalone** (no scene, or one or more renderers alongside a scene):
+ *      `registerSpriteRenderer` after `createSpriteRenderer`, `disposeSpriteRenderer`
+ *      on shutdown. Caller owns the lifetime end-to-end.
+ *   2. **HUD-on-3D** (renderer overlaid on a scene): same `register` step,
+ *      then tie disposal to the scene with
+ *      `onSceneDispose(scene, () => disposeSpriteRenderer(hud))` —
+ *      `disposeScene` then cleans it up automatically. Register the renderer
+ *      *after* `registerScene` so it draws on top.
+ *
+ * Scene 52 demonstrates pattern (2). For depth-hosted sprites that should
+ * sort against 3D meshes, use `addDepthHostedSpriteLayer(scene, layer)` with
+ * a depth-enabled `Sprite2DLayer` instead — that route is fully owned by the scene.
+ */
+export declare interface SpriteRenderer extends RenderingContext_2 {
    /** Renderer-owned layer membership. Use `addSpriteRendererLayer` / `removeSpriteRendererLayer` to mutate. */
+    readonly layers: readonly Sprite2DLayer[];
+
+/** Options accepted by `createSpriteRenderer`. */
+export declare interface SpriteRendererOptions {
+    /** Layers to draw, in registration order. The renderer also re-sorts internally each frame. */
+    layers: readonly Sprite2DLayer[];
+    /** Default true. Set false for HUD overlays so the sprite pass preserves existing scene color. */
+    clear?: boolean;
+    /** Default `{ r: 0, g: 0, b: 0, a: 1 }`. */
+    clearValue?: GPUColorDict;
+}
+
+/** Texture sampling mode for a sprite atlas. */
+export declare type SpriteSampling = "linear" | "nearest";
+
+/** Which shader stage an emitter writes into. Neutral blocks can run in either;
+ *  the walker places them in the stage of their consumer (fragment by default). */
+declare type Stage = "vertex" | "fragment";
+
+/** Accumulators for a single shader stage. */
+declare interface StageState {
+    /** Top-level helper declarations (functions, constants) keyed by canonical id. */
+    readonly helpers: Map<string, string>;
+    /** Statements emitted inside main(). */
+    readonly body: string[];
+    /** Memoized (blockId, outputName) → expr for already-emitted values in this stage. */
+    readonly memo: Map<string, NodeExpr>;
+}
+
+/** StandardMaterial properties — plain data. */
+export declare interface StandardMaterialProps extends Material {
+    diffuseColor: [number, number, number];
+    alpha: number;
+    specularColor: [number, number, number];
+    specularPower: number;
+    emissiveColor: [number, number, number];
+    ambientColor: [number, number, number];
+    /** Optional diffuse texture. Null = solid color only. */
+    diffuseTexture: Texture2D | null;
+    /** Diffuse texture UV channel. 0=UV1, 1=UV2. Default 0. */
+    diffuseCoordIndex: 0 | 1;
+    /** Optional emissive texture. Null = solid emissive color only. */
+    emissiveTexture: Texture2D | null;
+    /** Optional bump/normal-map texture. Uses cotangent-frame (no tangent attribute needed). */
+    bumpTexture: Texture2D | null;
+    /** Bump perturbation strength. Default 1.0 (maps to 1/level in BJS). */
+    bumpLevel: number;
+    /** Optional specular texture. Replaces specularColor; alpha modulates glossiness. */
+    specularTexture: Texture2D | null;
+    /** Specular texture UV channel. 0=UV1, 1=UV2. Default 0. */
+    specularCoordIndex: 0 | 1;
+    /** Optional ambient/occlusion texture. Multiplies final diffuse contribution. */
+    ambientTexture: Texture2D | null;
+    /** Ambient texture intensity. Default 1.0. */
+    ambientTexLevel: number;
+    /** Ambient texture UV channel. 0=UV1, 1=UV2. Default 0. */
+    ambientCoordIndex: 0 | 1;
+    /** Optional lightmap texture. Added to final color (additive mode). */
+    lightmapTexture: Texture2D | null;
+    /** Lightmap intensity. Default 1.0. */
+    lightmapLevel: number;
+    /** Lightmap UV channel. 0=UV1, 1=UV2. Default 1 (BJS convention). */
+    lightmapCoordIndex: 0 | 1;
+    /** Optional opacity texture. Multiplies alpha (.a channel). */
+    opacityTexture: Texture2D | null;
+    /** Opacity texture intensity. Default 1.0. */
+    opacityLevel: number;
+    /** When true, derive opacity from RGB luminance instead of .a channel. Default false. */
+    opacityFromRGB: boolean;
+    /** Alpha test cutoff. Fragments with `alpha < alphaCutOff` are discarded. Default 0 (no alpha test). */
+    alphaCutOff: number;
+    /** Optional reflection texture (2D spherical map). Null = no reflection. */
+    reflectionTexture: Texture2D | null;
+    /** Optional cube reflection texture. Null = no cube reflection. */
+    reflectionCubeTexture: {
+        texture: GPUTexture;
+        view: GPUTextureView;
+        sampler: GPUSampler;
+    } | null;
+    /** Reflection intensity. Default 1.0. */
+    reflectionLevel: number;
+    /** Reflection coordinate mode. 1=spherical, 2=planar. Default 1. */
+    reflectionCoordMode: 1 | 2;
+    /** UV tiling scale. Default [1, 1]. */
+    uvScale: [number, number];
+    /** Back-face culling. Default true (BJS convention). False = double-sided. */
+    backFaceCulling: boolean;
+    /** When true, skip all lighting and output emissive * diffuse * baseColor. Default false. */
+    disableLighting: boolean;
+}
+
+/** Starts the manager's autonomous requestAnimationFrame loop. No-op if already running.
+ *  @throws If `requestAnimationFrame` is unavailable in the host environment. */
+export declare function startAnimationManager(manager: AnimationManager): void;
+
+/**
+ * Start the render loop. Resolves after the first frame has been rendered.
+ * Scenes registered via `registerScene()` before this call are included in
+ * the first frame; later registrations join on subsequent frames.
+ */
+export declare function startEngine(engine: EngineContext): Promise<void>;
+
+/**
+ * Starts a sprite animation manager on its own autonomous animation loop.
+ * @param manager - Sprite animation manager to start.
+ * @throws If the manager is already attached to a render loop or another manager.
+ */
+export declare function startSpriteAnimationManager(manager: SpriteAnimationManager): void;
+
+/** Stop playback and reset to frame 0. */
+export declare function stopAnimation(group: AnimationGroup): void;
+
+/** Stops the manager's autonomous requestAnimationFrame loop. No-op if not running. */
+export declare function stopAnimationManager(manager: AnimationManager): void;
+
+/** Stop the render loop. */
+export declare function stopEngine(engine: EngineContext): void;
+
+/**
+ * Pauses an animation without removing it; it can be resumed with `playSpriteFrameAnimation`.
+ * @param animation - Animation to stop.
+ */
+export declare function stopSpriteAnimation(animation: SpriteFrameAnimation): void;
+
+/**
+ * Stops a sprite animation manager started with {@link startSpriteAnimationManager}.
+ * @param manager - Sprite animation manager to stop.
+ */
+export declare function stopSpriteAnimationManager(manager: SpriteAnimationManager): void;
+
+/** Subsurface configuration. Nested sub-features — presence = enabled. */
+export declare interface SubSurfaceProps {
+    /** Translucency: light passing through thin surfaces. */
+    translucency?: TranslucencyProps;
+    /** Scattering: screen-space subsurface scattering (PrePass). Reserved — not yet implemented. */
+    scattering?: ScatteringProps;
+    /** Thickness: per-texel thickness for transmittance. */
+    thickness?: ThicknessProps;
+    /** Tint: absorption tint color for transmittance. */
+    tint?: TintProps;
+    /** Refraction: physical light transmission through the surface
+     *  (KHR_materials_transmission + _volume + _ior). Presence enables it.
+     *  Requires the frame graph to produce a transmission refraction texture. */
+    refraction?: RefractionProps;
+}
+
+declare type TargetPath = 0 | 1 | 2 | 3 | 4;
+
+/** Polymorphic interface that all frame-graph tasks implement: records `Pass` objects during `record()` and is executed once per frame. */
+export declare interface Task {
+    readonly name: string;
+    /** Engine captured at task creation. */
+    readonly engine: EngineContext;
+    /** Owning scene for scene-bound tasks. Undefined for scene-less standalone frame graphs. */
+    readonly scene?: SceneContext | undefined;
    /** Called once when the frame graph is built. Must complete synchronously. */
+    record(): void;
    /** Optional fast path for built-in tasks that execute without recorded Pass objects. */
+    execute?(): number;
+    /** Free all GPU resources owned by this task. */
+    dispose(): void;
+}
+
+/** A loaded 2D texture: the GPU texture, its default view and sampler, pixel
+ *  dimensions, and an optional per-texture UV transform. This is the public
+ *  texture handle returned by `loadTexture2D()`, `createSolidTexture2D()`, etc. */
+export declare interface Texture2D {
+    texture: GPUTexture;
+    view: GPUTextureView;
+    sampler: GPUSampler;
+    width: number;
+    height: number;
+    /** Per-texture UV transform fields. All optional; defaults make identity.
+     *  Match BJS Texture.uScale/vScale/uOffset/vOffset/uAng semantics. These
+     *  fields are **build-time**: they are sampled when a material pipeline
+     *  is first compiled. Mutating them after the pipeline is built requires
+     *  a material rebuild (flag-based rebuild path). If a cached texture
+     *  wrapper needs a different transform than another use site, create a
+     *  fresh wrapper via `cloneTexture2D()`. */
+    uScale?: number;
+    vScale?: number;
+    uOffset?: number;
+    vOffset?: number;
+    /** Rotation in radians around the (0,0) UV corner. */
+    uAng?: number;
+    /** True if the texel data is stored with origin at the top (y-down) and
+     *  must be flipped in V when sampled with standard (y-up) UVs. Applied at
+     *  UV-transform time in the material, so compressed-format textures (where
+     *  in-place row flipping is impractical) remain correct. */
+    invertY?: boolean;
+
+/** Sampler, format, and decode options for `loadTexture2D()`. */
+export declare interface Texture2DOptions {
+    /** Generate mipmaps. Default true. */
+    mipMaps?: boolean;
+    /** Address mode U. Default 'repeat'. */
+    addressModeU?: GPUAddressMode;
+    /** Address mode V. Default 'repeat'. */
+    addressModeV?: GPUAddressMode;
+    /** Min filter. Default 'linear'. */
+    minFilter?: GPUFilterMode;
+    /** Mag filter. Default 'linear'. */
+    magFilter?: GPUFilterMode;
+    /** Flip Y axis during upload. Default true (matches Babylon.js convention). */
+    invertY?: boolean;
+    /** Use sRGB format (rgba8unorm-srgb). Enables hardware sRGB→linear on sample.
+     *  Use for color/albedo textures in PBR workflows. Default false. */
+    srgb?: boolean;
+    /** Premultiply alpha at decode time. Default false (straight RGBA, matches PNG-on-disk).
+     *  Set true for sprite atlases that will be rendered with a premultiplied blend pipeline
+     *  (`srcFactor: ONE`); doing so produces mathematically correct soft edges and stacked
+     *  translucency. */
+    premultiplyAlpha?: boolean;
+}
+
+/** Thickness sub-feature. Controls how thick the material is at each point. */
+export declare interface ThicknessProps {
+    /** Thickness map texture. R channel is sampled by default (matches
+     *  existing BJS non-glTF path). Set `useGlTFChannel=true` for G-channel
+     *  sampling as specified by KHR_materials_volume. */
+    texture?: Texture2D;
+    /** When true, sample the thickness texture's G channel (KHR_materials_volume).
+     *  Default false — samples R channel (BJS default). Set by the glTF loader. */
+    useGlTFChannel?: boolean;
+    /** Minimum thickness. Default 0. */
+    min?: number;
+    /** Maximum thickness. Default 1.0. */
+    max?: number;
+}
+
+/** CPU-side data backing a thin-instanced mesh: world matrices, optional colors, and GPU sync state. */
+export declare interface ThinInstanceData {
+    /** CPU-side instance world matrices (16 floats per instance). */
+    matrices: Float32Array;
+    /** Active instance count. */
+    count: number;
    /** Optional per-instance RGBA colors (4 floats per instance). */
+    colors?: Float32Array | null;
+
+/** Tint sub-feature. Controls absorption tint color for transmittance. */
+export declare interface TintProps {
+    /** Tint color (linear RGB). Default [1,1,1]. */
+    color?: [number, number, number];
+    /** Distance at which the tint color is reached. Default 1.0. */
+    atDistance?: number;
+}
+
+/** Options for `createTorusData`. Subset of Babylon's CreateTorus. */
+export declare interface TorusOptions {
+    diameter?: number;
+    thickness?: number;
+    tessellation?: number;
+}
+
+/** TransformNode is a SceneNode — pure type alias, no extra fields. */
+export declare type TransformNode = SceneNode;
+
+/** Translucency sub-feature. Presence enables translucency (no isEnabled boolean). */
+export declare interface TranslucencyProps {
+    /** Translucency intensity (0=off, 1=full). Default 1.0. */
+    intensity?: number;
+    /** Translucency color (linear RGB). Tints the transmitted light. Default [1,1,1]. */
+    color?: [number, number, number];
+    /** Diffusion distance for the Burley transmittance BRDF. Controls how far
+     *  light travels through the material per RGB channel. Default [1,1,1]. */
+    diffusionDistance?: [number, number, number];
+}
+
+/** Options for `createTubeData`: a circular cross-section swept along a path. */
+export declare interface TubeOptions {
+    path: Vec3[];
+    radius?: number;
+    tessellation?: number;
+    /** Per-point radius override; receives the point index and its distance along the path. */
+    radiusFunction?: (i: number, distance: number) => number;
+    cap?: number;
+    arc?: number;
+}
+
+declare interface UboField {
+
+/** A frame-graph task that draws a `UniformEffectWrapper` as a fullscreen pass into a render target. */
+export declare interface UniformEffectRenderTask extends Task {
+    readonly name: string;
+
+/** Configuration for `createUniformEffectRenderTask`: the uniform effect to draw, its render target, and optional clear state. */
+export declare interface UniformEffectRenderTaskConfig {
+    name: string;
+    effect: UniformEffectWrapper;
+    target: RenderTarget;
+    clear?: boolean;
+    clearColor?: GPUColorDict;
+}
+
+/** Lightweight reusable fullscreen effect with a single uniform buffer and no texture or sampler bindings. */
+export declare interface UniformEffectWrapper {
+    readonly name: string;
+    readonly options: UniformEffectWrapperOptions;
+}
+
+/** Configuration for a lightweight fullscreen effect with exactly one uniform buffer at bind group 0 / binding 0. */
+export declare interface UniformEffectWrapperOptions {
+    name?: string;
+    fragmentWGSL: string;
+    vertexWGSL?: string;
+    uniformByteLength: number;
+}
+
+/** Unregister the effect renderer from its engine. No-op if not registered. */
+export declare function unregisterEffectRenderer(er: EffectRenderer): void;
+
+/** Unregister the standalone frame-graph context from its engine. */
+export declare function unregisterFrameGraphContext(ctx: FrameGraphContext): void;
+
+/** Remove a previously-registered scene. Idempotent. Does not dispose scene resources. */
+export declare function unregisterScene(engine: EngineContext, scene: SceneContext): void;
+
+/** Splice the renderer out of its engine's `_renderingContexts`. No-op if not present. */
+export declare function unregisterSpriteRenderer(sr: SpriteRenderer): void;
+
+/** Advances every active task by `deltaMs` (or by `fixedDeltaMs` when set), running the category handler first.
+ *  Ignores non-finite or negative steps. */
+export declare function updateAnimationManager(manager: AnimationManager, deltaMs: number): void;
+
+/**
+ * Updates the properties of the billboard sprite referenced by `handle`.
+ * @param handle - Handle of the sprite to update.
+ * @param patch - Partial set of properties to overwrite.
+ * @throws If the handle has already been removed.
+ */
+export declare function updateBillboardSprite(handle: BillboardSpriteHandle, patch: Partial<BillboardSpriteInit>): void;
+
+/**
+ * Updates the billboard sprite at the given instance index.
+ * @param system - Billboard system that owns the sprite.
+ * @param index - Instance index to update.
+ * @param patch - Partial set of properties to overwrite.
+ * @throws If `index` is out of range.
+ */
+export declare function updateBillboardSpriteIndex(system: BillboardSpriteSystem, index: number, patch: Partial<BillboardSpriteInit>): void;
+
+/** Update a mesh's GPU vertex positions in place (e.g. CPU vertex animation).
+ *  `positions` must hold tightly-packed XYZ floats matching the mesh's vertex count.
+ *  `vertexOffset` is the first vertex to overwrite (defaults to 0).
+ *  The mesh must have been created via createMeshFromData / a mesh factory.
+ *  Zero-allocation GPU upload only — CPU-side picking geometry is not refreshed. */
+export declare function updateMeshPositions(engine: EngineContext, mesh: Mesh, positions: Float32Array, vertexOffset?: number): void;
+
+/** Advance the crowd simulation by `dt` seconds. */
+export declare function updateNavCrowd(crowd: NavCrowd, dt: number): void;
+
+/** Run `tileCache.update()` until all pending obstacle requests are resolved. */
+export declare function updateNavMeshObstacles(plugin: NavigationPlugin): void;
+
+/**
+ * Updates the properties of the sprite referenced by `handle`.
+ * @param handle - Handle of the sprite to update.
+ * @param patch - Partial set of properties to overwrite.
+ * @throws If the handle has already been removed.
+ */
+export declare function updateSprite2D(handle: Sprite2DHandle, patch: Partial<Sprite2DProps>): void;
+
+/** Patch one sprite. Unspecified fields are preserved. */
+export declare function updateSprite2DIndex(layer: Sprite2DLayer, index: number, patch: Partial<Sprite2DProps>): void;
+
+/**
+ * Advances every animation in the manager by one time step, removing those that have finished.
+ * Uses the manager's `fixedDeltaMs` when set, otherwise `deltaMs`.
+ * @param manager - Manager to update.
+ * @param deltaMs - Elapsed time in milliseconds since the last update.
+ */
+export declare function updateSpriteAnimationManager(manager: SpriteAnimationManager, deltaMs: number): void;
+
+/** Per-mesh original + variant material entry. */
+declare interface VariantMeshEntry {
+    mesh: Mesh;
+    material: AnyMaterial;
+}
+
+declare interface Varying {
+
+/** 3-component vector (position, direction, color) */
+export declare interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+
+/** 3-component vector as a fixed-length `[x, y, z]` tuple. */
+export declare type Vec3Tuple = [number, number, number];
+
+/** Babylon Lite version string. */
+export declare const VERSION = "0.1.0";
+
+declare interface VertexAttribute {
+
+export { }