babylonjs-loaders 9.25.0 → 9.26.1

package/babylonjs.loaders.module.d.ts

@@ -7,6 +7,7 @@ export * from "babylonjs-loaders/glTF/pure";
 export * from "babylonjs-loaders/OBJ/pure";
 export * from "babylonjs-loaders/STL/pure";
 export * from "babylonjs-loaders/SPLAT/pure";
+export * from "babylonjs-loaders/USD/pure";
 export * from "babylonjs-loaders/dynamic";
 
 }
@@ -17,6 +18,7 @@ export * from "babylonjs-loaders/glTF/index";
 export * from "babylonjs-loaders/OBJ/index";
 export * from "babylonjs-loaders/STL/index";
 export * from "babylonjs-loaders/SPLAT/index";
+export * from "babylonjs-loaders/USD/index";
 export * from "babylonjs-loaders/dynamic";
 
 }
@@ -8731,6 +8733,452 @@ declare module "babylonjs-loaders/glTF/1.0/glTFBinaryExtension" {
 export * from "babylonjs-loaders/glTF/1.0/glTFBinaryExtension.pure";
 import "babylonjs-loaders/glTF/1.0/glTFLoader";
 
+}
+declare module "babylonjs-loaders/USD/usdWorkerMessages" {
+import { USDLoadProgress } from "babylonjs-loaders/USD/usdLoadingOptions";
+export interface WorkerAsset {
+    bytes: Uint8Array;
+    fileName: string;
+    files?: Record<string, Uint8Array>;
+    resolveByFileName: boolean;
+    glueUrl?: string;
+    wasmUrl?: string;
+    dataUrl?: string;
+}
+export interface ExtractRequest {
+    type: "extract";
+    requestId: number;
+    asset: WorkerAsset;
+}
+export interface WorkerTimings {
+    totalMs: number;
+    stageOpenMs: number;
+    stageReadMs: number;
+    preparationMs: number;
+    packingMs: number;
+    heapCopyMs: number;
+}
+export interface WorkerStatistics {
+    nodes: number;
+    meshes: number;
+    analyticPrimitives: number;
+    instances: number;
+    materials: number;
+    vertices: number;
+    triangles: number;
+    commandBytes: number;
+    dataBytes: number;
+}
+export type WorkerResponse = {
+    type: "progress";
+    requestId: number;
+    progress: USDLoadProgress;
+} | {
+    type: "log";
+    requestId: number;
+    level: number;
+    message: string;
+} | {
+    type: "result";
+    requestId: number;
+    commands: ArrayBuffer;
+    data: ArrayBuffer;
+    timings: WorkerTimings;
+    statistics: WorkerStatistics;
+    missingAssets: string[];
+} | {
+    type: "error";
+    requestId: number;
+    message: string;
+    stack?: string;
+};
+
+}
+declare module "babylonjs-loaders/USD/usdSceneMaterializer" {
+import { AbstractAssetContainer } from "babylonjs/assetContainer";
+import { Scene } from "babylonjs/scene.pure";
+export interface MaterializationResult {
+    container: AbstractAssetContainer & {
+        dispose(): void;
+    };
+    materializeMs: number;
+}
+export function materializeCommandBuffers(scene: Scene, commandBuffer: ArrayBuffer, dataBuffer: ArrayBuffer, addToScene: boolean, signal?: AbortSignal): Promise<MaterializationResult>;
+
+}
+declare module "babylonjs-loaders/USD/usdLoadingOptions" {
+/**
+ * Binary input accepted for supporting USD layers and assets.
+ */
+export type USDBinaryInput = ArrayBuffer | ArrayBufferView;
+/**
+ * Virtual files supplied alongside the root USD layer, keyed by their path relative to the
+ * root layer.
+ */
+export type USDVirtualFiles = Readonly<Record<string, USDBinaryInput>>;
+/**
+ * Progress phases reported by the USD worker and Babylon materializer.
+ */
+export interface USDLoadProgress {
+    /**
+     * Current importer phase.
+     */
+    phase: "initializing" | "staging" | "extracting" | "materializing";
+    /**
+     * Human-readable phase description.
+     */
+    message: string;
+}
+/**
+ * Options for the OpenUSD scene loader.
+ */
+export interface USDFileLoaderOptions {
+    /**
+     * Virtual path used to stage the root layer. Set this when supporting files need
+     * to resolve relative to a directory hierarchy.
+     */
+    rootFileName?: string;
+    /**
+     * Supporting layers, payloads, and textures keyed by virtual path in the same
+     * virtual file system as `rootFileName`.
+     */
+    files?: USDVirtualFiles;
+    /**
+     * Enables conservative file-name fallback for unresolved absolute references.
+     * Defaults to true.
+     */
+    resolveByFileName?: boolean;
+    /**
+     * URL of the module worker. Defaults to the protocol-versioned worker hosted on the Babylon.js CDN.
+     */
+    workerUrl?: string | URL;
+    /**
+     * URL of the generated Emscripten JavaScript module.
+     */
+    glueUrl?: string;
+    /**
+     * URL of the OpenUSD WebAssembly binary.
+     */
+    wasmUrl?: string;
+    /**
+     * URL of the OpenUSD preloaded resource bundle.
+     */
+    dataUrl?: string;
+    /**
+     * Called when the importer moves to a new processing phase.
+     */
+    onProgress?: (progress: USDLoadProgress) => void;
+    /**
+     * Called for OpenUSD diagnostic messages.
+     */
+    onLog?: (level: "info" | "warning" | "error", message: string) => void;
+    /**
+     * Called after extraction and Babylon.js object creation complete.
+     */
+    onComplete?: (diagnostics: USDImportDiagnostics) => void;
+}
+/**
+ * Timing data measured by the OpenUSD worker and Babylon materializer.
+ */
+export interface USDImportTimings {
+    /** Total extraction time, including the final Wasm heap copy. */
+    totalMs: number;
+    /** Time spent opening and composing the USD stage. */
+    stageOpenMs: number;
+    /** Time spent traversing the composed stage. */
+    stageReadMs: number;
+    /** Time spent preparing renderable vertex streams. */
+    preparationMs: number;
+    /** Time spent packing the command and raw-data buffers. */
+    packingMs: number;
+    /** Time spent copying command and data buffers from the Wasm heap. */
+    heapCopyMs: number;
+    /** Time spent creating Babylon.js objects. */
+    materializeMs: number;
+}
+/**
+ * Statistics reported for an imported USD stage.
+ */
+export interface USDImportStatistics {
+    /** Number of transform nodes extracted from the composed stage. */
+    nodes: number;
+    /** Number of polygonal `UsdGeomMesh` sources. */
+    meshes: number;
+    /** Number of analytic cube, sphere, cylinder, and cone sources. */
+    analyticPrimitives: number;
+    /** Number of native Babylon instances created from shared USD geometry. */
+    instances: number;
+    /** Number of authored USD materials translated. */
+    materials: number;
+    /** Number of unique vertices in polygonal source meshes. */
+    vertices: number;
+    /** Number of unique triangles in polygonal source meshes. */
+    triangles: number;
+    /** Size of the command buffer in bytes. */
+    commandBytes: number;
+    /** Size of the raw-data buffer in bytes. */
+    dataBytes: number;
+}
+/**
+ * Diagnostics reported after a USD import completes.
+ */
+export interface USDImportDiagnostics {
+    /** Timing data for extraction and Babylon.js object creation. */
+    timings: USDImportTimings;
+    /** Counts and buffer sizes reported by the OpenUSD extractor. */
+    statistics: USDImportStatistics;
+    /** Asset references OpenUSD could not resolve from the supplied virtual files. */
+    missingAssets: readonly string[];
+}
+
+}
+declare module "babylonjs-loaders/USD/usdFileLoader.types" {
+export {};
+import { USDFileLoaderMetadata } from "babylonjs-loaders/USD/usdFileLoader.metadata";
+import { USDFileLoaderOptions } from "babylonjs-loaders/USD/usdLoadingOptions";
+module "babylonjs/Loading/sceneLoader" {
+    interface SceneLoaderPluginOptions {
+        /**
+         * Defines options for the USD loader.
+         */
+        [USDFileLoaderMetadata.name]: Partial<USDFileLoaderOptions>;
+    }
+}
+
+}
+declare module "babylonjs-loaders/USD/usdFileLoader.pure" {
+/** This file must only contain pure code and pure imports */
+import { AssetContainer } from "babylonjs/assetContainer";
+import { ISceneLoaderAsyncResult, ISceneLoaderPluginAsync, ISceneLoaderPluginFactory, ISceneLoaderProgressEvent, SceneLoaderPluginOptions } from "babylonjs/Loading/sceneLoader";
+import { Scene } from "babylonjs/scene.pure";
+import { USDFileLoaderOptions } from "babylonjs-loaders/USD/usdLoadingOptions";
+/**
+ * OpenUSD scene loader backed by a WebAssembly command-buffer extractor.
+ */
+export class USDFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPluginFactory {
+    /**
+     * Default URLs for the prebuilt OpenUSD importer assets.
+     */
+    static DefaultConfiguration: {
+        glueUrl: string;
+        wasmUrl: string;
+        dataUrl: string;
+        workerUrl: string;
+    };
+    /**
+     * Defines the name of the plugin.
+     */
+    readonly name: "usd";
+    /**
+     * Defines the extensions the plugin can load.
+     */
+    readonly extensions: {
+        readonly ".usd": {
+            readonly isBinary: true;
+        };
+        readonly ".usda": {
+            readonly isBinary: true;
+        };
+        readonly ".usdc": {
+            readonly isBinary: true;
+        };
+        readonly ".usdz": {
+            readonly isBinary: true;
+        };
+    };
+    private readonly _options;
+    private _worker;
+    private _workerUrl;
+    private _workerBlobUrl;
+    private _nextRequestId;
+    private readonly _pending;
+    private readonly _activeLoads;
+    /**
+     * Creates a USD loader.
+     * @param options Options controlling worker assets, supporting files, and diagnostics.
+     */
+    constructor(options?: Partial<USDFileLoaderOptions>);
+    /**
+     * Creates a configured plugin instance for a SceneLoader operation.
+     * @param options SceneLoader plugin options.
+     * @returns The configured USD loader.
+     */
+    createPlugin(options: SceneLoaderPluginOptions): ISceneLoaderPluginAsync;
+    /**
+     * Imports all objects from a USD stage into a scene.
+     * @param _meshesNames Mesh name filtering is not currently supported.
+     * @param scene The scene receiving the imported objects.
+     * @param data The USD, USDA, USDC, or USDZ bytes.
+     * @param rootUrl The source root URL.
+     * @param onProgress SceneLoader progress callback.
+     * @param fileName Name of the root USD layer.
+     * @returns The imported Babylon.js objects.
+     */
+    importMeshAsync(_meshesNames: string | readonly string[] | null | undefined, scene: Scene, data: unknown, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<ISceneLoaderAsyncResult>;
+    /**
+     * Loads a USD stage into a scene.
+     * @param scene The scene receiving the imported objects.
+     * @param data The USD, USDA, USDC, or USDZ bytes.
+     * @param rootUrl The source root URL.
+     * @param onProgress SceneLoader progress callback.
+     * @param fileName Name of the root USD layer.
+     */
+    loadAsync(scene: Scene, data: unknown, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
+    /**
+     * Loads a USD stage into an asset container.
+     * @param scene The scene used to create imported objects.
+     * @param data The USD, USDA, USDC, or USDZ bytes.
+     * @param rootUrl The source root URL.
+     * @param onProgress SceneLoader progress callback.
+     * @param fileName Name of the root USD layer.
+     * @returns The populated asset container.
+     */
+    loadAssetContainerAsync(scene: Scene, data: unknown, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<AssetContainer>;
+    /**
+     * Releases the worker and rejects pending loads.
+     */
+    dispose(): void;
+    private _loadAsync;
+    private _getWorker;
+    private _terminateWorker;
+}
+/** @internal */
+export function _RegisterUSDLoaderDependencies(): void;
+/**
+ * Registers the USD scene loader plugin and its Babylon.js runtime dependencies.
+ * Safe to call multiple times; only the first call has an effect.
+ */
+export function RegisterUSDFileLoader(): void;
+
+}
+declare module "babylonjs-loaders/USD/usdFileLoader.metadata" {
+/**
+ * Defines the USD loader plugin metadata.
+ */
+export const USDFileLoaderMetadata: {
+    readonly name: "usd";
+    readonly extensions: {
+        readonly ".usd": {
+            readonly isBinary: true;
+        };
+        readonly ".usda": {
+            readonly isBinary: true;
+        };
+        readonly ".usdc": {
+            readonly isBinary: true;
+        };
+        readonly ".usdz": {
+            readonly isBinary: true;
+        };
+    };
+};
+
+}
+declare module "babylonjs-loaders/USD/usdFileLoader" {
+/**
+ * Re-exports the pure implementation and applies the runtime registration side effect.
+ * Import "./usdFileLoader.pure" for tree-shakeable, side-effect-free usage.
+ */
+export * from "babylonjs-loaders/USD/usdFileLoader.types";
+export * from "babylonjs-loaders/USD/usdFileLoader.pure";
+
+}
+declare module "babylonjs-loaders/USD/usdCommandProtocol" {
+export const COMMAND_MAGIC = 1111774037;
+export const PROTOCOL_VERSION = 5;
+export const MISSING_OFFSET = 4294967295;
+export enum Command {
+    Scene = 1,
+    Texture = 2,
+    Material = 3,
+    TransformNode = 4,
+    Skeleton = 5,
+    Geometry = 6,
+    Mesh = 7,
+    Instance = 8,
+    Animation = 9,
+    AnalyticPrimitive = 10,
+    ThinInstances = 11,
+    MorphTarget = 12
+}
+export enum AnalyticPrimitiveType {
+    Cube = 0,
+    Sphere = 1,
+    Cylinder = 2,
+    Cone = 3
+}
+export enum PrimitiveAxis {
+    X = 0,
+    Y = 1,
+    Z = 2
+}
+export enum AnimationTarget {
+    Node = 0,
+    Bone = 1,
+    MorphTarget = 2
+}
+export enum AnimationProperty {
+    Position = 0,
+    RotationQuaternion = 1,
+    Scaling = 2,
+    Matrix = 3,
+    Influence = 4
+}
+export enum MaterialFlags {
+    DoubleSided = 1,
+    Unlit = 2,
+    AlphaBlend = 4
+}
+export enum TextureOutputChannel {
+    R = 0,
+    G = 1,
+    B = 2,
+    A = 3,
+    RGB = 4
+}
+export enum USDTextureColorSpace {
+    Auto = 0,
+    Raw = 1,
+    SRGB = 2
+}
+export enum MeshFlags {
+    DoubleSided = 1,
+    LeftHanded = 2
+}
+export enum GeometryFlags {
+    Normals = 1,
+    Tangents = 2,
+    Uv0 = 4,
+    Colors = 8,
+    Skin0 = 16,
+    Skin1 = 32
+}
+export interface CommandRecord {
+    opcode: Command;
+    flags: number;
+    payloadOffset: number;
+    payloadLength: number;
+}
+export function readCommands(buffer: ArrayBuffer): CommandRecord[];
+export class PayloadReader {
+    #private;
+    offset: number;
+    constructor(buffer: ArrayBuffer, offset: number, length: number);
+    u32(): number;
+    f32(): number;
+}
+
+}
+declare module "babylonjs-loaders/USD/pure" {
+/** Pure barrel — re-exports only side-effect-free modules */
+export * from "babylonjs-loaders/USD/usdFileLoader.pure";
+export * from "babylonjs-loaders/USD/usdLoadingOptions";
+
+}
+declare module "babylonjs-loaders/USD/index" {
+export * from "babylonjs-loaders/USD/usdFileLoader";
+export * from "babylonjs-loaders/USD/usdLoadingOptions";
+
 }
 declare module "babylonjs-loaders/STL/stlFileLoader.types" {
 export {};
@@ -9776,6 +10224,18 @@ export interface ISOGLODMetadata {
  * Selects which LOD value drives the {@link GaussianSplattingStream} debug wireframe colors.
  */
 export type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
+/**
+ * Immutable metadata-resolution state for a stream's total number of finest-LOD splats.
+ * @experimental
+ */
+export type GaussianSplattingStreamLod0SplatCount = Readonly<{
+    status: "pending";
+}> | Readonly<{
+    status: "available";
+    count: number;
+}> | Readonly<{
+    status: "unavailable";
+}>;
 /**
  * Options for {@link GaussianSplattingStream}.
  */
@@ -9895,6 +10355,7 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
     private readonly _rootUrl;
     private readonly _streamOptions;
     private readonly _leafNodes;
+    private _lod0SplatCount;
     private _lodBaseDistance;
     private _lodMultiplier;
     private _lodBehindPenalty;
@@ -10059,6 +10520,19 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
      * @experimental
      */
     get effectiveSplatBudget(): number;
+    /**
+     * The resolved maximum number of splats kept resident in the work buffer. This combines
+     * {@link IGaussianSplattingStreamOptions.maxResidentSplats} and {@link IGaussianSplattingStreamOptions.memoryBudgetMb},
+     * taking the smaller limit when both are configured. `0` means the resident budget is disabled.
+     * @experimental
+     */
+    get residentSplatBudget(): number;
+    /**
+     * The total number of splats represented by valid level-0 leaf entries. This remains pending while source
+     * metadata is loading and is unavailable when no applicable level-0 entries exist or required metadata fails.
+     * @experimental
+     */
+    get lod0SplatCount(): GaussianSplattingStreamLod0SplatCount;
     /**
      * Resolves the raw {@link splatBudget} option to a concrete cap: `undefined` ⇒ 0 (disabled), `"auto"` ⇒ a
      * device-tiered default, a positive number ⇒ itself (floored).
@@ -10228,6 +10702,11 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
      * @returns sorted unique file indices
      */
     private _collectAllFileIds;
+    /**
+     * Settles the level-0 diagnostic from normalized renderable leaf entries after their source metadata resolves.
+     * A file may back several leaf ranges, so its source count is deliberately not used in the total.
+     */
+    private _resolveLod0SplatCount;
     /**
      * Fetches the environment bundle and every referenced file's metadata to learn splat counts, caching
      * each file's parsed metadata for the later on-demand decode. Metadata fetches run in parallel.
@@ -11413,12 +11892,16 @@ declare module "babylonjs-loaders/FBX/pure" {
 /** Pure barrel — re-exports only side-effect-free modules */
 export { FBXFileLoader } from "babylonjs-loaders/FBX/fbxFileLoader.pure";
 export { FBXFileLoaderMetadata } from "babylonjs-loaders/FBX/fbxFileLoader.metadata";
+export { FBXConstraintBehavior, FBXConstraintSolver } from "babylonjs-loaders/FBX/fbxConstraintBehavior";
 
 }
 declare module "babylonjs-loaders/FBX/index" {
 export { FBXFileLoader } from "babylonjs-loaders/FBX/fbxFileLoader";
-export type { FBXFileLoaderOptions, FBXNormalMapCoordinateSystem } from "babylonjs-loaders/FBX/fbxFileLoader";
+export type { FBXFileLoaderOptions, FBXNormalMapCoordinateSystem, FBXLoaderWarning } from "babylonjs-loaders/FBX/fbxFileLoader";
 export { FBXFileLoaderMetadata } from "babylonjs-loaders/FBX/fbxFileLoader.metadata";
+export { FBXConstraintBehavior, FBXConstraintSolver } from "babylonjs-loaders/FBX/fbxConstraintBehavior";
+export type { FBXConstraintBehaviorOptions, FBXConstraintBehaviorTarget } from "babylonjs-loaders/FBX/fbxConstraintBehavior";
+export type { FBXConstraintData, FBXConstraintTarget, FBXConstraintType } from "babylonjs-loaders/FBX/interpreter/constraints";
 
 }
 declare module "babylonjs-loaders/FBX/fbxFileLoader.types" {
@@ -11447,12 +11930,83 @@ export type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
  * Defines options for the FBX loader.
  */
 export interface FBXFileLoaderOptions {
+    /**
+     * Bundle of defaults for the options that change what the loaded scene looks like.
+     * - "compatible" (default): the behaviour of the loader as first shipped: StandardMaterial for every material,
+     *   one Babylon geometry per model, curve geometry skipped, constraints recorded as metadata only, clips rebased
+     *   to start at frame 0, cameras and lights placed in world space.
+     * - "full": everything the loader can do: PBRMaterial for physically based shaders, geometry shared between
+     *   instances, curves as lines meshes, constraints solved at runtime, authored clip times, cameras and lights
+     *   parented to their nodes so they animate.
+     * An option set explicitly always wins over the preset.
+     */
+    preset?: "compatible" | "full";
     /**
      * Source convention for tangent-space normal maps connected through FBX normal-map slots.
      * FBX does not standardize this convention, so the loader defaults to the glTF/USD-style Y-up convention.
      * Set to "y-down" for assets authored with inverted green/Y normal maps.
      */
     normalMapCoordinateSystem?: FBXNormalMapCoordinateSystem;
+    /**
+     * Which Babylon material to build.
+     * - "standard" (default, "full" preset: "auto"): always StandardMaterial (PBR parameters are approximated).
+     * - "auto": PBRMaterial for physically based FBX materials (Standard Surface, Arnold, 3ds Max Physical,
+     *   3ds Max PBR, glTF, OpenPBR, Stingray PBS) and StandardMaterial for classic Lambert/Phong materials.
+     * - "pbr": always PBRMaterial (Lambert/Phong parameters are converted).
+     */
+    materials?: "auto" | "standard" | "pbr";
+    /**
+     * Unit conversion applied at the root of the loaded hierarchy.
+     * - "preserve" (default): keep the file's units (1 Babylon unit = 1 FBX unit).
+     * - "meters": scale so that 1 Babylon unit is 1 meter, using the file's UnitScaleFactor.
+     * - a number: centimeters per Babylon unit (100 = meters, 1 = centimeters, 2.54 = inches).
+     */
+    unitScale?: "preserve" | "meters" | number;
+    /**
+     * Share vertex data between models that reference the same FBX geometry (default false, "full" preset: true).
+     * Skinned meshes are never shared.
+     */
+    shareGeometry?: boolean;
+    /**
+     * Called for every recoverable issue found while loading (unsupported features, malformed data that was
+     * skipped, approximations). The same list is stored on the root node's metadata as `fbxDiagnostics`.
+     */
+    onWarning?: (warning: FBXLoaderWarning) => void;
+    /**
+     * Segments per knot span when tessellating NURBS surfaces. Zero or undefined uses the subdivision stored in
+     * the file (usually 4), capped at 16.
+     */
+    nurbsSubdivision?: number;
+    /** How curve geometry (Line, NurbsCurve) is imported: skipped (default) or as lines meshes ("full" preset). */
+    curves?: "lines" | "skip";
+    /**
+     * Constraints (aim, parent, position, rotation, scale): "metadata" (default) only records them on the nodes,
+     * "apply" ("full" preset) attaches an `FBXConstraintBehavior` to each constrained node so it is solved before
+     * every render. IK chains are always metadata only.
+     */
+    constraints?: "apply" | "metadata";
+    /**
+     * Shift every clip so its first keyframe sits at frame 0 (default true). With false ("full" preset) keys keep
+     * the times authored in the file, so clips of one file stay aligned with each other and with their declared
+     * ranges.
+     */
+    rebaseAnimations?: boolean;
+    /**
+     * Parent cameras and lights to their FBX node so they follow its animation (default false, "full" preset:
+     * true). Otherwise they are created at the node's world position and orientation, unparented.
+     */
+    attachCamerasAndLights?: boolean;
+}
+/** A recoverable issue reported while loading an FBX file. */
+export interface FBXLoaderWarning {
+    /** Which part of the loader reported the issue */
+    source: "scene" | "model" | "geometry" | "skin" | "rig" | "animation" | "blendShape" | "camera" | "light";
+    /** Human readable description */
+    message: string;
+    /** Name of the affected object, when known */
+    objectName?: string;
+    /** Structured details from the interpreter, when any */
+    details?: unknown;
 }
 /**
  * FBX file loader plugin for Babylon.js.
@@ -11475,6 +12029,22 @@ export class FBXFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
     private readonly _bindRestBones;
     private readonly _sourceBonesBySkeleton;
     private readonly _scaleCompensationHelpersBySkeleton;
+    /** Frame rate of the file being loaded (GlobalSettings TimeMode); animation is baked at this rate. */
+    private _frameRate;
+    /** Layers of the animation stack currently being converted; used by the transform samplers. */
+    private _activeLayers;
+    /** Parent model per model id, for inherit-mode aware sampling. */
+    private _parentModelById;
+    /** Curve nodes per model id for the stack currently being converted. */
+    private _curveNodesByModelId;
+    /** Helper nodes inserted above models whose InheritType is not RSrs. */
+    private _inheritScaleHelpers;
+    /** First mesh built per (geometry, geometric transform), for geometry sharing between instances. */
+    private _meshByGeometryKey;
+    /** Instance mesh -> source mesh whose geometry it shares. */
+    private _instanceSource;
+    /** Property curve nodes that were mapped onto Babylon animations; their "not evaluated" diagnostics are dropped. */
+    private _evaluatedCurveNodeIds;
     /**
      * Creates a new FBX loader.
      * @param options - Options controlling FBX loading behavior
@@ -11517,6 +12087,11 @@ export class FBXFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
      * @returns A promise containing the loaded asset container
      */
     loadAssetContainerAsync(scene: Scene, data: unknown, rootUrl: string, _onProgress?: (event: ISceneLoaderProgressEvent) => void, _fileName?: string): Promise<AssetContainer>;
+    /**
+     * Parses and interprets the file. Parsing is synchronous, so no progress events are emitted: the scene loader's
+     * progress callback reports download bytes and must not be fed synthetic counts.
+     */
+    private _parseAndInterpret;
     private _parse;
     private _parseFromArrayBuffer;
     private _buildScene;
@@ -11528,6 +12103,15 @@ export class FBXFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
     private _linkSkeletonsToTransformNodes;
     private static _modelSubtreeMatchesNameFilter;
     private static _applyModelMetadata;
+    /**
+     * Wires a LodGroup's children as Babylon LOD levels: the first child holds the highest detail; every further
+     * child replaces it beyond the group's threshold distance (or screen coverage when thresholds are percentages).
+     * Each child's display mode is honoured first: level 1 (show) stays visible outside the LOD chain, level 2
+     * (hide) is disabled, and only level 0 (use LOD) children take part in the distance switching.
+     */
+    private static _applyLodGroup;
+    /** Builds a lines mesh from Line or tessellated NurbsCurve geometry, applying the model's geometric transform. */
+    private _createLinesMesh;
     private _createMesh;
     /**
      * Apply multi-material to a mesh by creating sub-meshes grouped by material index.
@@ -11551,6 +12135,11 @@ export class FBXFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
      */
     private _buildSkinningData;
     private _createMaterial;
+    private _createPbrMaterial;
+    /** Alpha of a classic Lambert/Phong material: Opacity when present, otherwise 1 - TransparentColor * TransparencyFactor. */
+    private static _alphaFromClassicTransparency;
+    private static _applyTextureSettings;
+    private _createStandardMaterial;
     private _configureNormalTexture;
     private _getNormalMapTangentHandednessScale;
     private static _isSupportedMaterialTextureSlot;
@@ -11574,11 +12163,27 @@ export class FBXFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
     private _createCamera;
     private _createLight;
     private _createSkeleton;
+    private _rigBoneModelIds;
+    private _isRigBone;
     private _getSourceBone;
     private _getScaleCompensationHelper;
     private static _computeFBXAbsoluteMatrices;
+    /**
+     * Effective ("inherit") scale of every bone, following the FBX SDK: the local scale for RSrs bones, and for
+     * RrSs / Rrs bones the local scale multiplied by the scale of the bone's inherit-scale node (the parent for RrSs,
+     * the parent's inherit-scale node for Rrs). Bones are ordered parents first.
+     */
+    private static _computeBoneInheritScales;
+    private static _getBoneInheritScaleNode;
+    /** Scale a bone inherits into its own scale (RrSs chains), or unit scale. */
+    private static _getBoneInheritedScale;
     private static _computeFBXRuntimeLocalMatrix;
     private static _applyParentScaleCompensation;
+    /**
+     * Splits a bone's FBX local matrix into a helper (which cancels the parent scale and carries the translation,
+     * so the translation still follows the parent scale as the SDK does) and the bone's own rotation/scale. For RrSs
+     * bones the inherited scale is folded into the bone scale.
+     */
     private static _splitParentScaleCompensatedLocalMatrix;
     private static _safeInverseScale;
     private static _getInverseScaleVector;
@@ -11595,13 +12200,8 @@ export class FBXFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
      * In row-vector convention: v' = v * M
      */
     private static _computeFBXLocalMatrix;
-    /**
-     * Apply the FBX transform chain to a Babylon TransformNode or Mesh.
-     * Decomposes the full local matrix into position/rotation/scale.
-     */
-    private static _applyFBXTransform;
+    private _applyRestTRS;
     private static _computeFBXModelLocalMatrix;
-    private static _getBoneReferenceWorldMatrix;
     private static _applyMatrixToTransform;
     private _createAnimationGroup;
     private _buildInheritedRigBoneAnimations;
@@ -11611,9 +12211,61 @@ export class FBXFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPlugi
      * Computes the full FBX transform matrix at each keyframe and decomposes into TRS.
      */
     private _buildNodeAnimations;
+    /**
+     * Baked keys are interpolated linearly by Babylon. Between two frames an FBX cubic segment can deviate from that
+     * line, so sample times are refined (midpoints inserted, up to two levels) wherever the interpolated transform
+     * differs noticeably from the curve. Flat and linear segments stay at frame resolution.
+     */
+    private static _refineSampleTimes;
+    /**
+     * Keys of a scalar property animated by one or more layers: the authored keys when a single layer drives it,
+     * otherwise the frame grid evaluated through the layer stack.
+     * @param sources - Per-layer curves of the property (each with at least one curve)
+     * @param animStack - Stack being converted
+     * @param mapValue - Conversion from the FBX value to the Babylon property value
+     * @returns Animation keys
+     */
+    private _layeredScalarKeys;
+    /**
+     * Maps an animated FBX property (anything other than node transforms and blend shape weights) onto the Babylon
+     * property that carries it: mesh visibility, camera field of view and clip planes, light intensity, colour and
+     * cone angles, and material colours, alpha, roughness and metalness. `group` holds the curve nodes of every
+     * layer animating that property, in layer order; several layers are evaluated through the layer stack.
+     */
+    private _buildPropertyAnimations;
+    /** Records constraints on their nodes and, unless disabled, attaches the runtime behavior that solves them. */
+    private _applyConstraints;
+    /** Collects every recoverable issue the interpreter recorded, stores it on the root node and notifies the caller. */
+    private _reportDiagnostics;
+    /** Curve nodes affecting the inherit scale of a model: its own scale curves and those of its inherit-scale chain. */
+    private _collectInheritScaleCurves;
     private _isVector3KeysConstant;
+    /** Samples the animated Lcl Translation / Rotation / Scaling of a model, blending all layers of the active stack. */
+    private _sampleModelTRS;
+    /**
+     * Local position/rotation/scale of a model from FBX Lcl values. Without pivots and offsets the components map
+     * directly (rotation = pre * lcl * post⁻¹), which keeps zero and negative scales exact. With pivots the full
+     * matrix is built and decomposed.
+     */
+    private static _computeLocalTRS;
+    /** Applies inherit-mode adjustments to a local TRS (see _computeInheritAwareLocalMatrix). */
+    private _adjustTRSForInheritMode;
     private _sampleModelLocalMatrix;
     private _sampleModelScale;
+    /**
+     * Effective scale of a model for inherit-mode math (`inherit_scale` in ufbx terms): its own local scale, multiplied
+     * componentwise by the inherited scale when the model uses RrSs inheritance. `time` samples animation; undefined
+     * uses the rest pose.
+     */
+    private _getInheritScale;
+    /** RrSs nodes inherit scale from their parent; Rrs nodes skip their immediate parent (chaining through Rrs parents). */
+    private _getInheritScaleNode;
+    /**
+     * Local matrix of a model relative to its Babylon parent frame, accounting for inherit modes. For RSrs (the
+     * default) this is the FBX local matrix. For RrSs / Rrs the node sits under a helper that removes the parent's
+     * scale, so translation is pre-scaled by the parent scale and (for RrSs) scale accumulates componentwise.
+     */
+    private _computeInheritAwareLocalMatrix;
     /**
      * Build matrix-baked bone animation from full FBX local transforms.
      * The bind matrix carries the skinning offset, so animation curves drive
@@ -11651,6 +12303,197 @@ declare module "babylonjs-loaders/FBX/fbxFileLoader" {
 export * from "babylonjs-loaders/FBX/fbxFileLoader.types";
 export * from "babylonjs-loaders/FBX/fbxFileLoader.pure";
 
+}
+declare module "babylonjs-loaders/FBX/fbxConstraintBehavior" {
+/**
+ * Runtime evaluation of FBX constraints. An `FBXConstraintBehavior` is attached to each constrained node; all
+ * behaviors of a scene register with one `FBXConstraintSolver`, which solves them in dependency order (a constraint
+ * whose target or parent is driven by another constraint is solved after it) and reuses scratch objects, so solving
+ * allocates nothing per frame.
+ *
+ * The solver brackets the scene's animation phase: before animations run it writes each node's unconstrained
+ * transform back, after they ran it captures the result as the new unconstrained transform and solves. A partial
+ * weight therefore always blends from what animation (or nothing) produced this frame, never from the previous
+ * solve's output, so a 50% weight stays a 50% blend instead of converging on the target.
+ *
+ * All maths happen in FBX space, i.e. relative to the loader's root node, so the handedness conversion applied
+ * at the root never enters the solve.
+ */
+import { Behavior } from "babylonjs/Behaviors/behavior";
+import { Nullable } from "babylonjs/types";
+import { Node } from "babylonjs/node";
+import { Scene } from "babylonjs/scene";
+import { Matrix, Vector3 } from "babylonjs/Maths/math.vector.pure";
+import { TransformNode } from "babylonjs/Meshes/transformNode.pure";
+import { FBXConstraintData } from "babylonjs-loaders/FBX/interpreter/constraints";
+/** Resolved target of a constraint. */
+export interface FBXConstraintBehaviorTarget {
+    /** Target node */
+    node: TransformNode;
+    /** Normalized target weight (0..1) */
+    weight: number;
+    /** Offset matrix for parent constraints (in the target's space) */
+    offset: Matrix;
+}
+/** Options resolved by the loader when creating the behavior. */
+export interface FBXConstraintBehaviorOptions {
+    /** Root of the loaded asset; world matrices are made relative to it */
+    root: TransformNode;
+    /** Resolved targets of the constraint, in file order */
+    targets: FBXConstraintBehaviorTarget[];
+    /** World up object of an aim constraint, when it has one */
+    upNode: Nullable<TransformNode>;
+    /** Scene up axis in FBX space */
+    sceneUp: Vector3;
+}
+/**
+ * Solves every FBX constraint of a scene once per frame, in dependency order, from the scene's animation phase
+ * observers (`beginFrame` before animations, `solve` after them). Created on demand by the first
+ * `FBXConstraintBehavior` attached in the scene and removed with the last one.
+ */
+export class FBXConstraintSolver {
+    private readonly _scene;
+    private readonly _behaviors;
+    private _ordered;
+    private _cyclic;
+    private _dirty;
+    private _beforeAnimations;
+    private _afterAnimations;
+    private constructor();
+    /**
+     * Solver of a scene, if any constraint behavior is attached in it.
+     * @param scene - Scene to look up
+     * @returns The solver, or undefined
+     */
+    static Get(scene: Scene): FBXConstraintSolver | undefined;
+    /**
+     * Solver of a scene, created when missing.
+     * @param scene - Scene to look up
+     * @returns The solver
+     */
+    static GetOrCreate(scene: Scene): FBXConstraintSolver;
+    /** Registered behaviors in solve order (a target's constraint before the constraints that read it). */
+    get constraints(): readonly FBXConstraintBehavior[];
+    /**
+     * Behaviors that take part in a dependency cycle (A targets B while B targets A). They are solved after all
+     * acyclic constraints, in registration order, so each sees the other's result from the previous solve.
+     */
+    get cyclicConstraints(): readonly FBXConstraintBehavior[];
+    /**
+     * Adds a behavior to the solve set.
+     * @param behavior - Behavior to add
+     */
+    register(behavior: FBXConstraintBehavior): void;
+    /**
+     * Removes a behavior from the solve set; the solver disposes itself with the last one.
+     * @param behavior - Behavior to remove
+     */
+    unregister(behavior: FBXConstraintBehavior): void;
+    /** Marks the solve order stale, e.g. after re-parenting a constrained node. */
+    invalidateOrder(): void;
+    /**
+     * Start of a frame, before animations run: every constrained node gets its unconstrained transform back, so
+     * that animation either overwrites it or leaves it untouched.
+     */
+    beginFrame(): void;
+    /**
+     * End of the animation phase: takes every constrained node's current transform as its unconstrained value,
+     * then solves every registered constraint once, in dependency order.
+     */
+    solve(): void;
+    private _ensureOrder;
+    private static _IsAncestorOrSelf;
+}
+/** Babylon behavior evaluating an FBX aim, parent, position, rotation or scale constraint. */
+export class FBXConstraintBehavior implements Behavior<TransformNode> {
+    /** Constraint data extracted from the file */
+    readonly constraint: FBXConstraintData;
+    private readonly _options;
+    /** Behavior name (`fbxConstraint:` followed by the constraint name) */
+    readonly name: string;
+    /** Node the behavior is attached to */
+    attachedNode: Nullable<TransformNode>;
+    /** Set to false to pause the constraint without detaching it */
+    enabled: boolean;
+    private readonly _offsetTranslation;
+    private readonly _offsetRotation;
+    private readonly _offsetScale;
+    private readonly _localBasisTransposed;
+    /** Unconstrained transform of the current frame (what animation produced), blended towards the constraint's result. */
+    private readonly _base;
+    private _hasBase;
+    /**
+     * Creates the behavior.
+     * @param constraint - Constraint data extracted from the file
+     * @param _options - Resolved targets and scene information
+     */
+    constructor(
+    /** Constraint data extracted from the file */
+    constraint: FBXConstraintData, _options: FBXConstraintBehaviorOptions);
+    /** Nothing to initialize */
+    init(): void;
+    /**
+     * Registers the behavior with the scene's solver, takes the node's current transform as the unconstrained
+     * value and solves the constraint once.
+     * @param target - Node to constrain
+     */
+    attach(target: TransformNode): void;
+    /** Unregisters the behavior; the node keeps its last solved transform. */
+    detach(): void;
+    /**
+     * Takes the node's current transform as the unconstrained value the next solve blends from. The solver calls
+     * this after the scene's animations ran; call it yourself after writing a transform by hand.
+     */
+    captureBase(): void;
+    /**
+     * Writes the unconstrained transform back to the node. The solver calls this before the scene's animations
+     * run, so a node nothing animates keeps its unconstrained value between frames instead of the solved one.
+     */
+    restoreBase(): void;
+    /**
+     * Nodes whose world transform the solve reads: the targets, the up node and the constrained node's parent.
+     * @returns The nodes, used by the solver to order constraints
+     */
+    dependencyNodes(): Nullable<Node>[];
+    /**
+     * Solves the constraint from the captured unconstrained transform and writes the node's local transform.
+     * Blends are relative to the value captured by `captureBase`, not to whatever the node holds now.
+     */
+    evaluate(): void;
+    /**
+     * World matrix of a node relative to the asset root (FBX space).
+     * @param node - node to evaluate
+     * @param out - matrix receiving the result
+     * @returns `out`
+     */
+    private _fbxWorld;
+    /**
+     * Weighted blend of the targets' world transforms (relative to the root).
+     * @param position - Receives the blended translation
+     * @param rotation - Receives the blended rotation
+     * @param scale - Receives the blended scale
+     * @returns The total target weight, 0 when no target contributes
+     */
+    private _blendTargets;
+    private _applyWeighted;
+    private _applyRotation;
+    private _writePosition;
+    private _writeScaling;
+    private _solvePosition;
+    private _solveRotation;
+    private _solveScale;
+    private _solveParent;
+    private _solveAim;
+    /**
+     * Builds a rotation matrix whose rows are `first`, `second` made orthogonal to it, and their cross product.
+     * @param first - primary axis
+     * @param second - secondary axis
+     * @param out - matrix receiving the basis
+     * @returns false when the axes are parallel or degenerate (`out` is then unchanged)
+     */
+    private static _OrthonormalBasisToRef;
+}
+
 }
 declare module "babylonjs-loaders/FBX/types/fbxTypes" {
 /**
@@ -11667,6 +12510,11 @@ export interface FBXProperty {
     type: FBXPropertyType;
     /** Parsed property value. */
     value: FBXPropertyValue;
+    /**
+     * Exact decimal text of an int64 whose magnitude exceeds 2^53; `value` then holds the rounded double. Object
+     * ids are the only int64 values where the last bits matter, and `resolveConnections` keys them by this text.
+     */
+    raw?: string;
 }
 /** A node in the FBX document tree */
 export interface FBXNode {
@@ -11693,11 +12541,22 @@ export function findDocumentNode(doc: FBXDocument, name: string): FBXNode | unde
 /** Extract a property value by index, with type narrowing */
 export function getPropertyValue<T extends FBXPropertyValue>(node: FBXNode, index: number): T | undefined;
 /**
- * Converts an FBX object ID value to a safe JavaScript number.
+ * Validates an FBX object ID value: IDs are 64-bit integers, so anything non-numeric, non-finite or fractional is
+ * rejected. IDs beyond 2^53 are carried losslessly through the property's `raw` text by `resolveConnections`.
  * @param value - Parsed FBX object ID value
- * @returns The object ID, or undefined when the value is not numeric
+ * @returns The object ID, or undefined when the value cannot be an ID
  */
 export function getSafeFBXObjectId(value: unknown): number | undefined;
+/** Typed array payload types produced by the parsers. */
+export type FBXArrayValue = Float32Array | Float64Array | Int32Array | Uint8Array;
+/**
+ * Returns the array payload of a node.
+ * FBX 7.x stores arrays as a single array property. FBX 6.x (and some 7.x ASCII exporters) store them as a run of
+ * scalar properties, and a one-element array degenerates to a single scalar. All of these are coalesced here.
+ * @param node - Node whose properties hold the array
+ * @returns The array, or null when the node has no numeric payload
+ */
+export function getNodeArray(node: FBXNode | undefined | null): FBXArrayValue | null;
 /** Get the numeric ID from a node (first property is typically the int64 UID) */
 export function getNodeId(node: FBXNode): number | undefined;
 /**
@@ -11761,6 +12620,8 @@ export function computeFBXLocalMatrix(components: FBXTransformComponents): Matri
 
 }
 declare module "babylonjs-loaders/FBX/interpreter/skeleton" {
+import { FBXNodeTransformData } from "babylonjs-loaders/FBX/interpreter/nodeTransform";
+import { FBXPropertyTemplate, FBXPropertyTemplateMap } from "babylonjs-loaders/FBX/interpreter/propertyTemplates";
 import { FBXNode } from "babylonjs-loaders/FBX/types/fbxTypes";
 import { FBXObjectMap } from "babylonjs-loaders/FBX/interpreter/connections";
 export type FBXClusterMode = "Normalize" | "Additive" | "TotalOne" | "Unknown";
@@ -11835,25 +12696,9 @@ export interface FBXSkinData {
     /** Recoverable skinning/bind diagnostics */
     diagnostics: FBXSkinDiagnostic[];
 }
-/**
- * Extract all skin deformers from the FBX scene.
- * Returns skin data including bone hierarchy and vertex weights.
- */
-export function extractSkins(objectMap: FBXObjectMap): FBXSkinData[];
+export function extractSkins(objectMap: FBXObjectMap, propertyTemplates?: FBXPropertyTemplateMap): FBXSkinData[];
 export function isSkeletonModel(modelNode: FBXNode): boolean;
-export function extractBoneTransform(modelNode: FBXNode): {
-    translation: [number, number, number];
-    rotation: [number, number, number];
-    preRotation: [number, number, number];
-    postRotation: [number, number, number];
-    rotationPivot: [number, number, number];
-    scalingPivot: [number, number, number];
-    rotationOffset: [number, number, number];
-    scalingOffset: [number, number, number];
-    scale: [number, number, number];
-    rotationOrder: number;
-    inheritType: number;
-};
+export function extractBoneTransform(modelNode: FBXNode, template?: FBXPropertyTemplate): FBXNodeTransformData;
 
 }
 declare module "babylonjs-loaders/FBX/interpreter/sceneDiagnostics" {
@@ -11919,12 +12764,173 @@ export function resolveNumberProperty(node: FBXNode, template: FBXPropertyTempla
 export function resolveVector2Property(node: FBXNode, template: FBXPropertyTemplate | undefined, propertyName: string, fallback: [number, number]): [number, number];
 export function resolveVector3Property(node: FBXNode, template: FBXPropertyTemplate | undefined, propertyName: string, fallback: [number, number, number]): [number, number, number];
 export function resolvePropertyValues(node: FBXNode, template: FBXPropertyTemplate | undefined, propertyName: string): FBXPropertyValue[] | undefined;
+/** A property from a Properties70 ("P") or Properties60 ("Property") block. */
+export interface FBXPropertyEntry {
+    name: string;
+    type: string;
+    flags: string;
+    values: FBXPropertyValue[];
+}
+/**
+ * Lists the properties declared directly on an object, from both the 7.x and 6.x property blocks.
+ * @param node - Object node
+ * @returns Property entries in declaration order (empty when the node has no property block)
+ */
+export function getPropertyEntries(node: FBXNode | undefined): FBXPropertyEntry[];
+/** Value of a user property: scalars as-is, vectors and colours as number arrays. */
+export type FBXUserPropertyValue = string | number | boolean | number[];
+/**
+ * User-defined properties of an object: those flagged "U" (user) in the property flags. Every DCC exports custom
+ * attributes this way (Maya extra attributes, 3ds Max user properties, Blender custom properties).
+ * @param node - Object node
+ * @returns Map of property name to value, or undefined when the object has none
+ */
+export function extractUserProperties(node: FBXNode): Record<string, FBXUserPropertyValue> | undefined;
+export function userPropertyValue(values: FBXPropertyValue[], typeName?: string): FBXUserPropertyValue | undefined;
+
+}
+declare module "babylonjs-loaders/FBX/interpreter/nurbs" {
+/**
+ * NURBS curves and surfaces, and polyline ("Line") geometry.
+ *
+ * The basis evaluation and tessellation follow the FBX SDK conventions as implemented by ufbx: knot spans are
+ * subdivided uniformly, closed and periodic curves wrap their control points, and surfaces are tessellated into
+ * quads (degenerate quads at poles become triangles) with welded positions along the wrapped edges.
+ */
+import { FBXNode } from "babylonjs-loaders/FBX/types/fbxTypes";
+import { FBXGeometryData, FBXGeometryDiagnostic } from "babylonjs-loaders/FBX/interpreter/geometry";
+export type FBXNurbsTopology = "open" | "closed" | "periodic";
+/** Knot vector and derived data of one parametric direction. */
+export interface FBXNurbsBasis {
+    order: number;
+    topology: FBXNurbsTopology;
+    knots: Float64Array;
+    /** Parameter range that the curve is defined on */
+    tMin: number;
+    tMax: number;
+    /** Distinct knot values inside [tMin, tMax], i.e. the boundaries of the non-empty spans */
+    spans: Float64Array;
+    /** False when the knot vector is too short or not monotonic */
+    valid: boolean;
+}
+/** NURBS curve: homogeneous control points (x, y, z, w) and a basis. */
+export interface FBXNurbsCurveData {
+    basis: FBXNurbsBasis;
+    /** Control points as x,y,z,w */
+    controlPoints: Float64Array;
+    numControlPoints: number;
+}
+/** NURBS surface: control points laid out as `v * numU + u`. */
+export interface FBXNurbsSurfaceData {
+    basisU: FBXNurbsBasis;
+    basisV: FBXNurbsBasis;
+    numU: number;
+    numV: number;
+    /** Control points as x,y,z,w */
+    controlPoints: Float64Array;
+    flipNormals: boolean;
+    /** Span subdivision stored in the file (Step), 0 when absent */
+    stepU: number;
+    stepV: number;
+}
+/** Polyline geometry ready for a lines mesh: one or more open or closed point runs. */
+export interface FBXCurveGeometryData {
+    id: number;
+    name: string;
+    kind: "line" | "nurbsCurve";
+    /** Each polyline as x,y,z triples; closed runs repeat their first point at the end */
+    polylines: Float64Array[];
+    /** Display colour from the geometry's Color property */
+    color: [number, number, number] | null;
+    diagnostics: FBXGeometryDiagnostic[];
+}
+export function createNurbsBasis(order: number, form: string | undefined, knots: Float64Array): FBXNurbsBasis;
+/**
+ * Evaluates the basis functions (and their derivatives) that are non-zero at `u`.
+ * @returns index of the first influencing control point, or -1 when the basis cannot be evaluated
+ */
+export function evaluateNurbsBasis(basis: FBXNurbsBasis, u: number, weights: Float64Array, derivatives: Float64Array | null): number;
+/** Evaluates a curve point; `out` receives position (0..2) and derivative (3..5). */
+export function evaluateNurbsCurve(curve: FBXNurbsCurveData, u: number, out: Float64Array, weights: Float64Array, derivs: Float64Array): boolean;
+/** Evaluates a surface point; `out` receives position (0..2), du (3..5) and dv (6..8). */
+export function evaluateNurbsSurface(surface: FBXNurbsSurfaceData, u: number, v: number, out: Float64Array, scratch: {
+    wu: Float64Array;
+    wv: Float64Array;
+    du: Float64Array;
+    dv: Float64Array;
+}): boolean;
+/**
+ * Tessellates a curve into a polyline with `subdivision` segments per knot span. Closed and periodic curves
+ * end on a copy of their first point.
+ */
+export function tessellateNurbsCurve(curve: FBXNurbsCurveData, subdivision?: number): Float64Array | null;
+/** Span subdivision to use for a surface direction: an explicit override, else the file's Step, else 4. */
+export function resolveSpanSubdivision(fileStep: number, override: number | undefined): number;
+/**
+ * Tessellates a surface into triangles. Positions on wrapped (closed/periodic) edges and at poles are welded
+ * exactly like the FBX SDK does, so degenerate quads collapse into triangles.
+ */
+export function tessellateNurbsSurface(surface: FBXNurbsSurfaceData, subU: number, subV: number): {
+    positions: Float64Array;
+    indices: Uint32Array;
+    normals: Float64Array;
+    uvs: Float64Array;
+} | null;
+/** Reads a NurbsCurve geometry node. */
+export function extractNurbsCurve(node: FBXNode): FBXNurbsCurveData | null;
+/** Reads a NurbsSurface geometry node. */
+export function extractNurbsSurface(node: FBXNode): FBXNurbsSurfaceData | null;
+/** Tessellates a NurbsSurface geometry node into mesh geometry. */
+export function nurbsSurfaceToGeometry(node: FBXNode, geometryId: number, subdivisionOverride: number | undefined): FBXGeometryData | null;
+/** Reads a NurbsCurve geometry node into a tessellated polyline. */
+export function extractNurbsCurveGeometry(node: FBXNode, geometryId: number, subdivision?: number): FBXCurveGeometryData;
+/**
+ * Reads a Line geometry node: Points plus PointsIndex where a negative index (~index) ends a segment, as in
+ * polygon vertex indices.
+ */
+export function extractLineGeometry(node: FBXNode, geometryId: number): FBXCurveGeometryData;
+
+}
+declare module "babylonjs-loaders/FBX/interpreter/nodeTransform" {
+import { FBXNode } from "babylonjs-loaders/FBX/types/fbxTypes";
+import { FBXPropertyTemplate } from "babylonjs-loaders/FBX/interpreter/propertyTemplates";
+/** Transform properties resolved from an FBX Model, with template defaults applied. */
+export interface FBXNodeTransformData {
+    translation: [number, number, number];
+    rotation: [number, number, number];
+    scale: [number, number, number];
+    preRotation: [number, number, number];
+    postRotation: [number, number, number];
+    rotationPivot: [number, number, number];
+    scalingPivot: [number, number, number];
+    rotationOffset: [number, number, number];
+    scalingOffset: [number, number, number];
+    geometricTranslation: [number, number, number];
+    geometricRotation: [number, number, number];
+    geometricScaling: [number, number, number];
+    /** Rotation order: 0=XYZ, 1=XZY, 2=YZX, 3=YXZ, 4=ZXY, 5=ZYX, 6=SphericXYZ */
+    rotationOrder: number;
+    /** FBX transform inheritance mode. 0=RrSs, 1=RSrs, 2=Rrs */
+    inheritType: number;
+    /** Whether the rotation space (rotation order, pre/post rotation) is active for this node */
+    rotationActive: boolean;
+    diagnostics: string[];
+}
+/**
+ * Resolves the transform properties of a Model node the way the FBX SDK evaluates them.
+ *
+ * `RotationActive` gates the whole rotation space: when it is false (the FbxNode template default), the SDK
+ * composes `Lcl Rotation` in plain XYZ order and ignores `RotationOrder`, `PreRotation` and `PostRotation`.
+ * `RotationSpaceForLimitOnly` restricts the rotation space to limits, which has the same effect for us.
+ */
+export function extractNodeTransform(modelNode: FBXNode, template?: FBXPropertyTemplate): FBXNodeTransformData;
 
 }
 declare module "babylonjs-loaders/FBX/interpreter/materials" {
 import { FBXNode } from "babylonjs-loaders/FBX/types/fbxTypes";
 import { FBXObjectMap } from "babylonjs-loaders/FBX/interpreter/connections";
-import { FBXPropertyTemplateMap } from "babylonjs-loaders/FBX/interpreter/propertyTemplates";
+import { FBXPropertyTemplate, FBXPropertyTemplateMap, FBXUserPropertyValue } from "babylonjs-loaders/FBX/interpreter/propertyTemplates";
+import { FBXMaterialModel } from "babylonjs-loaders/FBX/interpreter/materialModel";
 /** Parsed material data */
 export interface FBXMaterialData {
     id: number;
@@ -11932,6 +12938,10 @@ export interface FBXMaterialData {
     type: "Lambert" | "Phong";
     properties: FBXMaterialProperties;
     textures: FBXTextureRef[];
+    /** Unified classic + PBR parameter model resolved from whichever shader flavour the file uses */
+    model: FBXMaterialModel<FBXTextureRef>;
+    /** User-defined properties */
+    userProperties?: Record<string, FBXUserPropertyValue>;
 }
 export interface FBXMaterialProperties {
     diffuseColor?: [number, number, number];
@@ -11967,11 +12977,106 @@ export interface FBXTextureRef {
     uvSetIndex?: number;
     /** Which named UV set this texture uses */
     uvSetName?: string;
+    /** WrapModeU: 0 = repeat, 1 = clamp */
+    wrapU?: number;
+    /** WrapModeV: 0 = repeat, 1 = clamp */
+    wrapV?: number;
+    /** Set when the texture came from a LayeredTexture (only the first layer is used) */
+    layeredTextureId?: number;
 }
 /**
  * Extract material data from an FBX Material node.
  */
 export function extractMaterial(materialNode: FBXNode, materialId: number, objectMap: FBXObjectMap, templates?: FBXPropertyTemplateMap): FBXMaterialData;
+export function extractTextureRef(id: number, node: FBXNode, propertyName: string | undefined, objectMap: FBXObjectMap, template?: FBXPropertyTemplate): FBXTextureRef;
+
+}
+declare module "babylonjs-loaders/FBX/interpreter/materialModel" {
+/**
+ * Unified material model.
+ *
+ * FBX materials come in many vendor flavours: the classic FbxSurfaceLambert / FbxSurfacePhong, Autodesk Standard
+ * Surface (OSL), Arnold aiStandardSurface, 3ds Max Physical Material, 3ds Max PBR (metal/rough and spec/gloss),
+ * the 3ds Max glTF material, OpenPBR, and Maya's Stingray PBS ShaderFX graph. Each stores its parameters under
+ * different property names, sometimes behind a shader binding table.
+ *
+ * This module resolves any of them into two parameter sets, mirroring how the FBX SDK / ufbx expose materials:
+ * `fbx` (the classic Lambert/Phong parameters) and `pbr` (a physically based parameter set), plus feature flags.
+ */
+import { FBXPropertyValue } from "babylonjs-loaders/FBX/types/fbxTypes";
+export type FBXShaderType = "unknown" | "fbxLambert" | "fbxPhong" | "oslStandardSurface" | "arnoldStandardSurface" | "3dsMaxPhysicalMaterial" | "3dsMaxPbrMetalRough" | "3dsMaxPbrSpecGloss" | "gltfMaterial" | "openPbrMaterial" | "shaderFxGraph";
+/** One resolved material parameter: a constant value and/or a texture. */
+export interface FBXMaterialMap<TTexture> {
+    /** Constant value (r,g,b,a for colours, x for scalars) */
+    value?: number[];
+    /** Number of meaningful components in `value` (1 for scalars, 3 or 4 for colours) */
+    valueComponents: number;
+    /** Texture bound to the parameter */
+    texture?: TTexture;
+    /** Whether the texture is enabled (some vendors carry an explicit toggle) */
+    textureEnabled: boolean;
+}
+export type FBXFbxMapName = "diffuseFactor" | "diffuseColor" | "specularFactor" | "specularColor" | "specularExponent" | "reflectionFactor" | "reflectionColor" | "transparencyFactor" | "transparencyColor" | "emissionFactor" | "emissionColor" | "ambientFactor" | "ambientColor" | "normalMap" | "bump" | "bumpFactor" | "displacement" | "displacementFactor" | "vectorDisplacement" | "vectorDisplacementFactor";
+export type FBXPbrMapName = "baseFactor" | "baseColor" | "roughness" | "metalness" | "diffuseRoughness" | "specularFactor" | "specularColor" | "specularIor" | "specularAnisotropy" | "specularRotation" | "transmissionFactor" | "transmissionColor" | "transmissionDepth" | "transmissionScatter" | "transmissionScatterAnisotropy" | "transmissionDispersion" | "transmissionRoughness" | "transmissionExtraRoughness" | "transmissionPriority" | "transmissionEnableInAov" | "subsurfaceFactor" | "subsurfaceColor" | "subsurfaceRadius" | "subsurfaceScale" | "subsurfaceAnisotropy" | "subsurfaceTintColor" | "subsurfaceType" | "sheenFactor" | "sheenColor" | "sheenRoughness" | "coatFactor" | "coatColor" | "coatRoughness" | "coatIor" | "coatAnisotropy" | "coatRotation" | "coatNormal" | "coatAffectBaseColor" | "coatAffectBaseRoughness" | "thinFilmFactor" | "thinFilmThickness" | "thinFilmIor" | "emissionFactor" | "emissionColor" | "opacity" | "indirectDiffuse" | "indirectSpecular" | "normalMap" | "tangentMap" | "displacementMap" | "matteFactor" | "matteColor" | "ambientOcclusion" | "glossiness" | "coatGlossiness" | "transmissionGlossiness";
+export type FBXMaterialFeatureName = "pbr" | "metalness" | "diffuse" | "specular" | "emission" | "transmission" | "coat" | "sheen" | "opacity" | "ambientOcclusion" | "matte" | "unlit" | "ior" | "diffuseRoughness" | "transmissionRoughness" | "thinWalled" | "caustics" | "exitToBackground" | "internalReflections" | "doubleSided" | "roughnessAsGlossiness" | "coatRoughnessAsGlossiness" | "transmissionRoughnessAsGlossiness";
+export interface FBXMaterialModel<TTexture> {
+    shaderType: FBXShaderType;
+    /** Prefix material property names carry for this shader (e.g. "3dsMax|Parameters|") */
+    shaderPropPrefix: string;
+    fbx: Partial<Record<FBXFbxMapName, FBXMaterialMap<TTexture>>>;
+    pbr: Partial<Record<FBXPbrMapName, FBXMaterialMap<TTexture>>>;
+    features: Partial<Record<FBXMaterialFeatureName, {
+        enabled: boolean;
+        explicit: boolean;
+    }>>;
+}
+/** Inputs needed to resolve a material, independent of the parse representation. */
+export interface FBXMaterialSource<TTexture> {
+    /** "lambert", "phong", "unknown", ... as written in the file */
+    shadingModelName: string;
+    /** Property values by full property name (e.g. "DiffuseColor", "Maya|baseColor", "3dsMax|Parameters|roughness") */
+    props: Map<string, {
+        type: string;
+        values: FBXPropertyValue[];
+    }>;
+    /** Textures connected to the material by property name (OP connection property) */
+    texturesByProp: Map<string, TTexture>;
+    /** Connected shader implementation, when any */
+    shader?: {
+        renderApi: string;
+        /** shader semantic name -> material property names */
+        bindings: Map<string, string[]>;
+    };
+}
+/** Shader types whose parameters are physically based; the loader emits PBR materials for them by default. */
+export function isPbrShaderType(type: FBXShaderType): boolean;
+/** Detects the shader flavour of a material from its shading model name, connected shader and 3ds Max class ids. */
+export function detectShaderType<T>(source: FBXMaterialSource<T>): {
+    shaderType: FBXShaderType;
+    shaderPropPrefix: string;
+};
+/**
+ * Resolves the unified material model from raw material data.
+ */
+export function resolveMaterialModel<T>(source: FBXMaterialSource<T>): FBXMaterialModel<T>;
+/** Colour (first three components) of a map, or undefined. */
+export function mapColor<T>(map: FBXMaterialMap<T> | undefined): [number, number, number] | undefined;
+/** Scalar (first component) of a map, or undefined. */
+export function mapScalar<T>(map: FBXMaterialMap<T> | undefined): number | undefined;
+
+}
+declare module "babylonjs-loaders/FBX/interpreter/legacyDocument" {
+/**
+ * FBX 5.x (and older) documents store everything at the top level: one `Model` node per object with inline
+ * geometry, materials, skin links, lights and cameras, and `Children` lists instead of connections. This module
+ * rewrites such a document into the 6.x layout (`Objects`, `Connections`, `Takes`) so the rest of the importer
+ * can treat both the same way. The rules follow the FBX SDK's legacy reader as implemented by ufbx.
+ */
+import { FBXDocument } from "babylonjs-loaders/FBX/types/fbxTypes";
+/** True for pre-6000 files: no `Objects` section but top-level `Model` nodes. */
+export function isLegacyDocument(doc: FBXDocument): boolean;
+/** Rewrites a legacy document into the 6.x object/connection layout. */
+export function upgradeLegacyDocument(doc: FBXDocument): FBXDocument;
 
 }
 declare module "babylonjs-loaders/FBX/interpreter/geometry" {
@@ -11986,7 +13091,7 @@ export interface FBXUVSet {
 /** Recoverable geometry import issue. */
 export interface FBXGeometryDiagnostic {
     /** Diagnostic category. */
-    type: "degenerate-polygon" | "triangulation-fallback" | "layer-index-out-of-bounds" | "layer-data-too-short";
+    type: "degenerate-polygon" | "triangulation-fallback" | "layer-index-out-of-bounds" | "layer-data-too-short" | "nurbs-invalid" | "nurbs-trim-ignored" | "nurbs-deformer-ignored";
     /** Human-readable diagnostic message. */
     message: string;
     /** Polygon index associated with the diagnostic, if applicable. */
@@ -12033,8 +13138,11 @@ export function extractGeometry(geometryNode: FBXNode, nodeId: number): FBXGeome
 
 }
 declare module "babylonjs-loaders/FBX/interpreter/fbxInterpreter" {
+import { FBXUserPropertyValue } from "babylonjs-loaders/FBX/interpreter/propertyTemplates";
 import { FBXDocument } from "babylonjs-loaders/FBX/types/fbxTypes";
 import { FBXGeometryData } from "babylonjs-loaders/FBX/interpreter/geometry";
+import { FBXCurveGeometryData } from "babylonjs-loaders/FBX/interpreter/nurbs";
+import { FBXConstraintData } from "babylonjs-loaders/FBX/interpreter/constraints";
 import { FBXMaterialData } from "babylonjs-loaders/FBX/interpreter/materials";
 import { FBXSkinData } from "babylonjs-loaders/FBX/interpreter/skeleton";
 import { FBXRigData } from "babylonjs-loaders/FBX/interpreter/rig";
@@ -12046,8 +13154,10 @@ export interface FBXModelData {
     id: number;
     name: string;
     subType: string;
-    /** Geometry attached to this model (if it's a Mesh type) */
+    /** Geometry attached to this model (meshes and tessellated NURBS surfaces) */
     geometry?: FBXGeometryData;
+    /** Curve geometry attached to this model (Line and NurbsCurve) */
+    curve?: FBXCurveGeometryData;
     /** Materials assigned to this model */
     materials: FBXMaterialData[];
     /** Child models */
@@ -12079,18 +13189,68 @@ export interface FBXModelData {
     /** Whether backface culling is disabled ("CullingOff") */
     cullingOff: boolean;
     /** User-defined custom properties from Properties70 */
-    customProperties?: Record<string, string | number | boolean>;
+    customProperties?: Record<string, FBXUserPropertyValue>;
+    /** LOD group settings when this model is a LodGroup; children are the levels in order */
+    lodGroup?: FBXLodGroupData;
+    /** Display layer (CollectionExclusive) the model belongs to */
+    displayLayer?: FBXDisplayLayerData;
     /** Recoverable model import diagnostics */
     diagnostics: string[];
 }
+/** LOD group settings (NodeAttribute "LodGroup") */
+export interface FBXLodGroupData {
+    /** Switch distance for level i+1 (level 0 has none). In scene units, or percent of screen when `relative`. */
+    thresholds: number[];
+    /** ThresholdsUsedAsPercentage */
+    relative: boolean;
+    /** DisplayLevels|LevelN: 0 use LOD, 1 show, 2 hide */
+    displayLevels: number[];
+}
+/** Display layer (CollectionExclusive "DisplayLayer") */
+export interface FBXDisplayLayerData {
+    id: number;
+    name: string;
+    show: boolean;
+    freeze: boolean;
+    color: [number, number, number];
+    modelIds: number[];
+}
+/** One member of a selection set: a model, optionally with a component selection on its mesh */
+export interface FBXSelectionNodeData {
+    modelId: number;
+    /** IsTheNodeInSet: the whole node is selected (as opposed to only components) */
+    includeNode: boolean;
+    /** Selected control point indices (VertexIndexArray) */
+    vertices?: number[];
+    /** Selected edge indices (EdgeIndexArray) */
+    edges?: number[];
+    /** Selected polygon indices (PolygonIndexArray) */
+    faces?: number[];
+}
+/** Selection set (Collection "SelectionSet") */
+export interface FBXSelectionSetData {
+    id: number;
+    name: string;
+    members: FBXSelectionNodeData[];
+}
 /** Camera data extracted from FBX */
 export interface FBXCameraData {
     /** Model ID this camera is attached to */
     modelId: number;
+    /** NodeAttribute object ID (animation curves target this) */
+    attributeId: number;
     /** Camera name */
     name: string;
-    /** Field of view in degrees */
+    /** Vertical field of view in degrees */
     fieldOfView: number;
+    /** Horizontal field of view in degrees */
+    fieldOfViewX: number;
+    /** ApertureMode: 0 horizontal and vertical, 1 horizontal, 2 vertical, 3 focal length */
+    apertureMode: number;
+    /** Aperture (film gate after gate fit) size in inches */
+    apertureSizeInch: [number, number];
+    /** Orthographic view size (width, height) in scene units */
+    orthographicSize: [number, number];
     /** Near clip plane */
     nearPlane: number;
     /** Far clip plane */
@@ -12109,6 +13269,8 @@ export interface FBXCameraData {
     orthoZoom?: number;
     /** Camera roll in degrees when present */
     roll?: number;
+    /** User-defined properties on the camera attribute */
+    userProperties?: Record<string, FBXUserPropertyValue>;
     /** Known unsupported or unrecognized camera properties */
     unknownProperties: string[];
     /** Recoverable camera import diagnostics */
@@ -12118,6 +13280,8 @@ export interface FBXCameraData {
 export interface FBXLightData {
     /** Model ID this light is attached to */
     modelId: number;
+    /** NodeAttribute object ID (animation curves target this) */
+    attributeId: number;
     /** Light name */
     name: string;
     /** Light type: 0=Point, 1=Directional, 2=Spot */
@@ -12142,6 +13306,15 @@ export interface FBXLightData {
     enableFarAttenuation?: boolean;
     /** Whether the source light requested shadow casting */
     castShadows?: boolean;
+    /** Near/far attenuation ranges in scene units (when enabled) */
+    nearAttenuationStart?: number;
+    nearAttenuationEnd?: number;
+    farAttenuationStart?: number;
+    farAttenuationEnd?: number;
+    /** Area light shape: 0 rectangle, 1 sphere */
+    areaLightShape?: number;
+    /** User-defined properties on the light attribute */
+    userProperties?: Record<string, FBXUserPropertyValue>;
     /** Known unsupported or unrecognized light properties */
     unknownProperties: string[];
     /** Recoverable light import diagnostics */
@@ -12153,6 +13326,8 @@ export interface FBXSceneData {
     rootModels: FBXModelData[];
     /** All geometries in the scene */
     geometries: FBXGeometryData[];
+    /** All curve geometries (lines and tessellated NURBS curves) */
+    curves: FBXCurveGeometryData[];
     /** All materials in the scene */
     materials: FBXMaterialData[];
     /** Skin deformers (skeletons + vertex weights) */
@@ -12169,6 +13344,12 @@ export interface FBXSceneData {
     lights: FBXLightData[];
     /** Scene-level unsupported feature diagnostics */
     diagnostics: FBXSceneDiagnostic[];
+    /** Constraints (aim, parent, position, rotation, scale, IK) */
+    constraints: FBXConstraintData[];
+    /** Display layers */
+    displayLayers: FBXDisplayLayerData[];
+    /** Selection sets */
+    selectionSets: FBXSelectionSetData[];
     /** Global settings */
     upAxis: number;
     upAxisSign: number;
@@ -12177,11 +13358,91 @@ export interface FBXSceneData {
     coordAxis: number;
     coordAxisSign: number;
     unitScaleFactor: number;
+    /** Scene frame rate derived from GlobalSettings TimeMode / CustomFrameRate */
+    frameRate: number;
 }
 /**
  * Interpret a parsed FBX document into scene data.
  */
-export function interpretFBX(doc: FBXDocument): FBXSceneData;
+/** Options controlling how the document is interpreted. */
+export interface FBXInterpretOptions {
+    /** Segments per knot span when tessellating NURBS surfaces; defaults to the Step stored in the file */
+    nurbsSubdivision?: number;
+    /** Shift every clip so its first key sits at time 0 (default true); false keeps the authored times */
+    rebaseKeyframes?: boolean;
+}
+export function interpretFBX(doc: FBXDocument, options?: FBXInterpretOptions): FBXSceneData;
+
+}
+declare module "babylonjs-loaders/FBX/interpreter/constraints" {
+import { FBXObjectMap } from "babylonjs-loaders/FBX/interpreter/connections";
+export type FBXConstraintType = "aim" | "parent" | "position" | "rotation" | "scale" | "singleChainIK" | "unknown";
+export type Vec3 = [number, number, number];
+export type Bool3 = [boolean, boolean, boolean];
+/** One weighted target of a constraint. */
+export interface FBXConstraintTarget {
+    /** Model id of the target node */
+    modelId: number;
+    /** Normalized weight (file value / 100, or as-is for IK pole targets) */
+    weight: number;
+    /** Parent constraint translation offset expressed in the target's space */
+    offsetTranslation: Vec3;
+    /** Parent constraint rotation offset in degrees, expressed in the target's space */
+    offsetRotation: Vec3;
+    /** Parent constraint scale offset expressed in the target's space */
+    offsetScale: Vec3;
+}
+/** A constraint object of the file, with its targets and parameters resolved. */
+export interface FBXConstraintData {
+    /** Constraint object id */
+    id: number;
+    /** Constraint name */
+    name: string;
+    /** Resolved constraint kind */
+    type: FBXConstraintType;
+    /** Constraint type name as written in the file (e.g. "Parent-Child") */
+    typeName: string;
+    /** Constrained model */
+    nodeId?: number;
+    /** Weighted targets in file order */
+    targets: FBXConstraintTarget[];
+    /** Global weight (file value / 100) */
+    weight: number;
+    /** False when the constraint is switched off in the file */
+    active: boolean;
+    /** Which translation axes the constraint drives */
+    affectTranslation: Bool3;
+    /** Which rotation axes the constraint drives */
+    affectRotation: Bool3;
+    /** Which scale axes the constraint drives */
+    affectScale: Bool3;
+    /** Translation offset of the constrained node */
+    offsetTranslation: Vec3;
+    /** Rotation offset of the constrained node, in degrees */
+    offsetRotation: Vec3;
+    /** Scale offset of the constrained node */
+    offsetScale: Vec3;
+    /** Aim: local axis that points at the target */
+    aimVector: Vec3;
+    /** Aim: local axis aligned with the up direction */
+    upVector: Vec3;
+    /** Aim: world up direction (world up modes 2 and 3) */
+    worldUpVector: Vec3;
+    /** Aim: 0 scene up, 1 aim up node, 2 align to node, 3 vector, 4 none */
+    worldUpType: number;
+    /** Aim: model id of the world up object (world up modes 1 and 2) */
+    worldUpNodeId?: number;
+    /** Single chain IK: model id of the first joint of the chain */
+    ikFirstJointId?: number;
+    /** Single chain IK: model id of the last joint of the chain */
+    ikEndJointId?: number;
+    /** Single chain IK: model id of the effector */
+    ikEffectorId?: number;
+    /** Single chain IK: pole vector */
+    ikPoleVector: Vec3;
+}
+/** Reads every constraint object of the scene. */
+export function extractConstraints(objectMap: FBXObjectMap): FBXConstraintData[];
 
 }
 declare module "babylonjs-loaders/FBX/interpreter/connections" {
@@ -12206,7 +13467,7 @@ export interface FBXObjectEntry {
     /** Object node. */
     node: FBXNode;
     /** Source of the object entry. */
-    source: "Objects" | "legacySyntheticGeometry";
+    source: "Objects" | "legacySyntheticGeometry" | "legacySyntheticAttribute" | "legacySyntheticBlendShape";
     /** Legacy string object name, when applicable. */
     legacyName?: string;
     /** True if the object was synthesized for legacy compatibility. */
@@ -12329,9 +13590,24 @@ export interface FBXBlendShapeData {
 export function extractBlendShapes(objectMap: FBXObjectMap): FBXBlendShapeData[];
 
 }
-declare module "babylonjs-loaders/FBX/interpreter/animation" {
-import { FBXObjectMap } from "babylonjs-loaders/FBX/interpreter/connections";
+declare module "babylonjs-loaders/FBX/interpreter/animationCurve" {
+/**
+ * FBX animation curve model and evaluator.
+ *
+ * Keys carry cubic Bezier tangents expressed the way the FBX SDK stores them: a left and right tangent with a time
+ * extent (dx, as a fraction of the segment scaled by the tangent weight) and a value extent (dy). Linear and constant
+ * segments are represented the same way so that a single evaluator handles every case, including the weighted
+ * tangents Maya and MotionBuilder write, TCB keys, and the pre/post extrapolation modes.
+ */
+/** FBX time units: 46186158000 ticks per second */
+export const FBX_TIME_UNIT = 46186158000;
 export type FBXInterpolationType = "constant" | "linear" | "cubic";
+export type FBXExtrapolationMode = "constant" | "repeat" | "mirror" | "slope" | "repeatRelative";
+export interface FBXExtrapolation {
+    mode: FBXExtrapolationMode;
+    /** Number of repetitions, or -1 for infinite */
+    repeatCount: number;
+}
 /** A single keyframe */
 export interface FBXKeyframe {
     /** Time in seconds */
@@ -12342,9 +13618,15 @@ export interface FBXKeyframe {
     interpolation: FBXInterpolationType;
     /** Constant interpolation variant */
     constantMode?: "standard" | "next";
-    /** Cubic outgoing slope in value units per second */
+    /** Left (incoming) tangent: time extent in seconds and value extent */
+    leftDx: number;
+    leftDy: number;
+    /** Right (outgoing) tangent: time extent in seconds and value extent */
+    rightDx: number;
+    rightDy: number;
+    /** Cubic outgoing slope in value units per second (derived, kept for consumers that export hermite keys) */
     rightSlope?: number;
-    /** Cubic incoming slope for the next key, in value units per second */
+    /** Cubic incoming slope for the next key, in value units per second (derived) */
     nextLeftSlope?: number;
 }
 /** An animation curve (one axis of one property) */
@@ -12355,7 +13637,60 @@ export interface FBXCurveData {
     keys: FBXKeyframe[];
     /** True for baked sample curves that should be connected as linear samples */
     isSampled?: boolean;
+    preExtrapolation?: FBXExtrapolation;
+    postExtrapolation?: FBXExtrapolation;
+}
+/** Raw key attribute data for one key, after run-length decoding. */
+export interface FBXKeyAttributes {
+    flags: number;
+    data: [number, number, number, number];
+}
+/**
+ * Builds keyframes from parallel time/value arrays and their (run-length encoded) attributes, resolving every
+ * tangent mode the FBX SDK writes: user, broken, auto (with clamp / progressive clamp / time-independent flags and
+ * auto bias), TCB, weighted, linear and constant.
+ */
+export function buildKeyframes(times: ArrayLike<number>, values: ArrayLike<number>, attributes: (index: number) => FBXKeyAttributes): FBXKeyframe[];
+/** Auto tangent as the FBX SDK computes it, including clamping and auto bias. */
+export function solveAutoTangent(prevTime: number, time: number, nextTime: number, prevValue: number, value: number, nextValue: number, weightLeft: number, weightRight: number, autoBias: number, flags: number): number;
+/** Builds a keyframe list from explicit per-key slopes (legacy Takes and synthetic curves). */
+export function keyframesFromSlopes(times: number[], values: number[], interpolation: FBXInterpolationType[], constantNext: boolean[], leftSlope: number[], rightSlope: number[], leftWeight?: number[], rightWeight?: number[]): FBXKeyframe[];
+/** Reads a `Pre-Extrapolation` / `Post-Extrapolation` block: `Type` is a character code, `Repetition` a count. */
+export function parseExtrapolation(typeValue: unknown, repetitionValue: unknown): FBXExtrapolation;
+export function evaluateCurve(curve: FBXCurveData | undefined, time: number, defaultValue: number, noExtrapolation?: boolean): number;
+export type Vec3 = [number, number, number];
+export type Quat = [number, number, number, number];
+/** Euler angles in degrees with an FBX rotation order (0=XYZ ... 5=ZYX; spheric falls back to XYZ) to a quaternion. */
+export function eulerToQuat(v: Vec3, order: number): Quat;
+/** Quaternion to Euler angles in degrees for an FBX rotation order (inverse of eulerToQuat). */
+export function quatToEuler(q: Quat, order: number): Vec3;
+/** Blend semantics of an animation layer, derived from its BlendMode and accumulation modes. */
+export interface FBXLayerBlend {
+    /** Layer participates in blending (BlendMode Additive or Override Passthrough) */
+    blended: boolean;
+    /** Layer adds onto the result instead of replacing it (BlendMode Additive) */
+    additive: boolean;
+    /** Rotations compose as quaternions (RotationAccumulationMode ByLayer) */
+    composeRotation: boolean;
+    /** Scales compose multiplicatively (ScaleAccumulationMode Multiply) */
+    composeScale: boolean;
+    /** Layer weight in [0, 1] */
+    weight: number;
+}
+/**
+ * Combines one animation layer's value into the running result, exactly as the FBX SDK evaluator does.
+ * `kind` selects the accumulation rule: "R" rotations (degrees, rotation order given), "S" scales, anything else linear.
+ */
+export function combineLayerValue(result: Vec3, value: Vec3, layer: FBXLayerBlend, kind: "T" | "R" | "S" | "other", rotationOrder: number): Vec3;
+
 }
+declare module "babylonjs-loaders/FBX/interpreter/animation" {
+import { FBXDocument } from "babylonjs-loaders/FBX/types/fbxTypes";
+import { FBXObjectMap } from "babylonjs-loaders/FBX/interpreter/connections";
+import { FBXCurveData, FBXLayerBlend } from "babylonjs-loaders/FBX/interpreter/animationCurve";
+export { FBX_TIME_UNIT } from "babylonjs-loaders/FBX/interpreter/animationCurve";
+export type { FBXCurveData, FBXExtrapolation, FBXExtrapolationMode, FBXInterpolationType, FBXKeyframe, FBXLayerBlend } from "babylonjs-loaders/FBX/interpreter/animationCurve";
+export { combineLayerValue, evaluateCurve, eulerToQuat, quatToEuler } from "babylonjs-loaders/FBX/interpreter/animationCurve";
 /** An animation curve node (T/R/S for one bone) */
 export interface FBXCurveNodeData {
     /** Property type: "T" (translation), "R" (rotation), "S" (scale) */
@@ -12364,13 +13699,19 @@ export interface FBXCurveNodeData {
     targetModelId: number;
     /** Curves for each axis */
     curves: FBXCurveData[];
+    /** Index of the owning layer within the stack's layer list */
+    layerIndex: number;
+    /** Default channel values (`d|X`, `d|Y`, `d|Z`) used for channels without a curve */
+    defaultValues?: [number, number, number];
 }
-/** Unsupported animation curve node preserved for diagnostics and future support. */
+/** Non-transform animation curve node (property animation), evaluated by the loader when a Babylon mapping exists. */
 export interface FBXUnsupportedCurveNodeData {
     /** Raw AnimationCurveNode property type/name */
     type: string;
     /** CurveNode object ID */
     id: number;
+    /** Index of the owning layer within the stack's layer list */
+    layerIndex: number;
     /** Target object ID if the curve node is connected to an object/property */
     targetId: number | null;
     /** OP connection property name on the target, e.g. Visibility */
@@ -12409,6 +13750,10 @@ export interface FBXAnimationLayerData {
     normalizedWeight: number;
     /** Blend mode: 0=Additive, 1=Override, 2=OverridePassthrough */
     blendMode: number;
+    /** Resolved blend semantics used by the evaluator */
+    blend: FBXLayerBlend;
+    /** Animated layer weight (0-100), when the Weight property carries a curve */
+    weightCurve?: FBXCurveData;
     /** Curve nodes in this layer */
     curveNodes: FBXCurveNodeData[];
     /** Unsupported/non-TRS curve nodes preserved for diagnostics */
@@ -12416,6 +13761,14 @@ export interface FBXAnimationLayerData {
     /** Recoverable layer diagnostics */
     diagnostics: FBXAnimationDiagnostic[];
 }
+/** Options for animation extraction. */
+export interface FBXAnimationExtractOptions {
+    /**
+     * Shift each clip so its first key sits at time 0 (default true). False keeps the times authored in the file, so
+     * clips of one file stay aligned with each other and with the declared stack range.
+     */
+    rebaseKeyframes?: boolean;
+}
 /** One animation clip (AnimationStack) */
 export interface FBXAnimationStackData {
     /** Animation name */
@@ -12438,13 +13791,7 @@ export interface FBXAnimationStackData {
 /**
  * Extract all animation stacks from the FBX scene.
  */
-export function extractAnimations(objectMap: FBXObjectMap): FBXAnimationStackData[];
-/**
- * Determines whether a key sequence appears to be a uniformly frame-baked sampled curve.
- * @param keys - Keyframes to inspect
- * @returns true if the keys look like sampled frame data rather than authored interpolation
- */
-export function isFrameBakedSampledCurve(keys: readonly FBXKeyframe[]): boolean;
+export function extractAnimations(objectMap: FBXObjectMap, doc?: FBXDocument, options?: FBXAnimationExtractOptions): FBXAnimationStackData[];
 /**
  * Samples an FBX animation curve at a specific time.
  * @param curveData - Curve data to sample
@@ -12452,6 +13799,54 @@ export function isFrameBakedSampledCurve(keys: readonly FBXKeyframe[]): boolean;
  * @returns The sampled value, or null when the curve has no keys
  */
 export function sampleFBXCurveAtTime(curveData: FBXCurveData | undefined, time: number): number | null;
+/**
+ * Pre-7000 files store animation in a top-level `Takes` block instead of AnimationStack/Layer/CurveNode objects:
+ *
+ *   Takes: { Take: "name" { LocalTime: start, stop
+ *     Model: "Model::joint1" { Channel: "Transform" { Channel: "T" { Channel: "X" { Default, KeyVer, KeyCount, Key } } } } } }
+ *
+ * Each take becomes one animation stack with a single layer. Models are matched through the same legacy string ids
+ * that the connection resolver synthesizes for 6.x objects.
+ */
+export function extractLegacyTakes(doc: FBXDocument, objectMap: FBXObjectMap, rebaseKeyframes?: boolean): FBXAnimationStackData[];
+/**
+ * Evaluates one transform channel (T, R or S) of a target at `time`, blending every animation layer of the stack the
+ * way the FBX SDK does: the first layer animating the channel replaces the static value, later layers are combined
+ * according to their blend mode, weight and accumulation modes.
+ * @param curveNodes - Curve nodes targeting this model (any layers, any types)
+ * @param layers - Stack layers, in order
+ * @param type - Channel to evaluate
+ * @param staticValue - Value when nothing animates the channel
+ * @param rotationOrder - Rotation order of the target (for rotation composition)
+ * @param time - Time in seconds
+ */
+export function evaluateLayeredChannel(curveNodes: readonly FBXCurveNodeData[], layers: readonly FBXAnimationLayerData[], type: "T" | "R" | "S", staticValue: readonly [number, number, number], rotationOrder: number, time: number): [number, number, number];
+/** Curves of one animated property (or blend shape weight) contributed by one animation layer. */
+export interface FBXLayeredPropertySource {
+    /** Index of the owning layer within the stack's layer list */
+    layerIndex: number;
+    /** Curves of the property, keyed by channel name (`d|X`, `d|DeformPercent`, ...) */
+    curves: readonly FBXCurveData[];
+    /** Default channel values stored on the curve node */
+    defaultValues?: Record<string, number>;
+}
+/**
+ * Evaluates an animated property through the animation layers: the base layer replaces the static value, every
+ * further layer blends onto the running result according to its blend mode and (possibly animated) weight, like
+ * `evaluateLayeredChannel` does for transforms.
+ * @param sources - Per-layer curves of the property
+ * @param layers - Stack layers, in order
+ * @param channels - Channel names to evaluate, in output order
+ * @param staticValue - Value per channel when nothing animates it
+ * @param time - Time in seconds
+ * @returns One value per channel
+ */
+export function evaluateLayeredProperty(sources: readonly FBXLayeredPropertySource[], layers: readonly FBXAnimationLayerData[], channels: readonly string[], staticValue: readonly number[], time: number): number[];
+/**
+ * True when every curve of the given channel is inside a constant (stepped) segment at `time`, so a baked key at
+ * that time should hold its value instead of interpolating towards the next sample.
+ */
+export function isChannelSteppedAt(curveNodes: readonly FBXCurveNodeData[], type: "T" | "R" | "S", time: number): boolean;
 
 }
 declare module "babylonjs-loaders/BVH/pure" {
@@ -21468,28 +22863,446 @@ declare namespace BABYLON.GLTF1 {
         loadShaderStringAsync(gltfRuntime: BABYLON.GLTF1.IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void): boolean;
     }
     /**
-     * Registers the KHR_binary_glTF extension.
+     * Registers the KHR_binary_glTF extension.
+     * Safe to call multiple times; only the first call has an effect.
+     */
+    export function RegisterGLTFBinaryExtension(): void;
+
+
+
+}
+declare namespace BABYLON {
+
+
+}
+declare namespace BABYLON.GLTF1 {
+        /**
+     * Re-exports the pure implementation and applies the runtime registration side effect.
+     * Import "./glTFBinaryExtension.pure" for tree-shakeable, side-effect-free usage.
+     */
+
+
+
+}
+declare namespace BABYLON {
+
+    export interface WorkerAsset {
+        bytes: Uint8Array;
+        fileName: string;
+        files?: Record<string, Uint8Array>;
+        resolveByFileName: boolean;
+        glueUrl?: string;
+        wasmUrl?: string;
+        dataUrl?: string;
+    }
+    export interface ExtractRequest {
+        type: "extract";
+        requestId: number;
+        asset: WorkerAsset;
+    }
+    export interface WorkerTimings {
+        totalMs: number;
+        stageOpenMs: number;
+        stageReadMs: number;
+        preparationMs: number;
+        packingMs: number;
+        heapCopyMs: number;
+    }
+    export interface WorkerStatistics {
+        nodes: number;
+        meshes: number;
+        analyticPrimitives: number;
+        instances: number;
+        materials: number;
+        vertices: number;
+        triangles: number;
+        commandBytes: number;
+        dataBytes: number;
+    }
+    export type WorkerResponse = {
+        type: "progress";
+        requestId: number;
+        progress: USDLoadProgress;
+    } | {
+        type: "log";
+        requestId: number;
+        level: number;
+        message: string;
+    } | {
+        type: "result";
+        requestId: number;
+        commands: ArrayBuffer;
+        data: ArrayBuffer;
+        timings: WorkerTimings;
+        statistics: WorkerStatistics;
+        missingAssets: string[];
+    } | {
+        type: "error";
+        requestId: number;
+        message: string;
+        stack?: string;
+    };
+
+
+    export interface MaterializationResult {
+        container: AbstractAssetContainer & {
+            dispose(): void;
+        };
+        materializeMs: number;
+    }
+    export function materializeCommandBuffers(scene: Scene, commandBuffer: ArrayBuffer, dataBuffer: ArrayBuffer, addToScene: boolean, signal?: AbortSignal): Promise<MaterializationResult>;
+
+
+    /**
+     * Binary input accepted for supporting USD layers and assets.
+     */
+    export type USDBinaryInput = ArrayBuffer | ArrayBufferView;
+    /**
+     * Virtual files supplied alongside the root USD layer, keyed by their path relative to the
+     * root layer.
+     */
+    export type USDVirtualFiles = Readonly<Record<string, USDBinaryInput>>;
+    /**
+     * Progress phases reported by the USD worker and Babylon materializer.
+     */
+    export interface USDLoadProgress {
+        /**
+         * Current importer phase.
+         */
+        phase: "initializing" | "staging" | "extracting" | "materializing";
+        /**
+         * Human-readable phase description.
+         */
+        message: string;
+    }
+    /**
+     * Options for the OpenUSD scene loader.
+     */
+    export interface USDFileLoaderOptions {
+        /**
+         * Virtual path used to stage the root layer. Set this when supporting files need
+         * to resolve relative to a directory hierarchy.
+         */
+        rootFileName?: string;
+        /**
+         * Supporting layers, payloads, and textures keyed by virtual path in the same
+         * virtual file system as `rootFileName`.
+         */
+        files?: USDVirtualFiles;
+        /**
+         * Enables conservative file-name fallback for unresolved absolute references.
+         * Defaults to true.
+         */
+        resolveByFileName?: boolean;
+        /**
+         * URL of the module worker. Defaults to the protocol-versioned worker hosted on the Babylon.js CDN.
+         */
+        workerUrl?: string | URL;
+        /**
+         * URL of the generated Emscripten JavaScript module.
+         */
+        glueUrl?: string;
+        /**
+         * URL of the OpenUSD WebAssembly binary.
+         */
+        wasmUrl?: string;
+        /**
+         * URL of the OpenUSD preloaded resource bundle.
+         */
+        dataUrl?: string;
+        /**
+         * Called when the importer moves to a new processing phase.
+         */
+        onProgress?: (progress: USDLoadProgress) => void;
+        /**
+         * Called for OpenUSD diagnostic messages.
+         */
+        onLog?: (level: "info" | "warning" | "error", message: string) => void;
+        /**
+         * Called after extraction and Babylon.js object creation complete.
+         */
+        onComplete?: (diagnostics: USDImportDiagnostics) => void;
+    }
+    /**
+     * Timing data measured by the OpenUSD worker and Babylon materializer.
+     */
+    export interface USDImportTimings {
+        /** Total extraction time, including the final Wasm heap copy. */
+        totalMs: number;
+        /** Time spent opening and composing the USD stage. */
+        stageOpenMs: number;
+        /** Time spent traversing the composed stage. */
+        stageReadMs: number;
+        /** Time spent preparing renderable vertex streams. */
+        preparationMs: number;
+        /** Time spent packing the command and raw-data buffers. */
+        packingMs: number;
+        /** Time spent copying command and data buffers from the Wasm heap. */
+        heapCopyMs: number;
+        /** Time spent creating Babylon.js objects. */
+        materializeMs: number;
+    }
+    /**
+     * Statistics reported for an imported USD stage.
+     */
+    export interface USDImportStatistics {
+        /** Number of transform nodes extracted from the composed stage. */
+        nodes: number;
+        /** Number of polygonal `UsdGeomMesh` sources. */
+        meshes: number;
+        /** Number of analytic cube, sphere, cylinder, and cone sources. */
+        analyticPrimitives: number;
+        /** Number of native Babylon instances created from shared USD geometry. */
+        instances: number;
+        /** Number of authored USD materials translated. */
+        materials: number;
+        /** Number of unique vertices in polygonal source meshes. */
+        vertices: number;
+        /** Number of unique triangles in polygonal source meshes. */
+        triangles: number;
+        /** Size of the command buffer in bytes. */
+        commandBytes: number;
+        /** Size of the raw-data buffer in bytes. */
+        dataBytes: number;
+    }
+    /**
+     * Diagnostics reported after a USD import completes.
+     */
+    export interface USDImportDiagnostics {
+        /** Timing data for extraction and Babylon.js object creation. */
+        timings: USDImportTimings;
+        /** Counts and buffer sizes reported by the OpenUSD extractor. */
+        statistics: USDImportStatistics;
+        /** Asset references OpenUSD could not resolve from the supplied virtual files. */
+        missingAssets: readonly string[];
+    }
+
+
+        interface SceneLoaderPluginOptions {
+            /**
+             * Defines options for the USD loader.
+             */
+            [USDFileLoaderMetadata.name]: Partial<USDFileLoaderOptions>;
+        }
+
+
+    /** This file must only contain pure code and pure imports */
+    /**
+     * OpenUSD scene loader backed by a WebAssembly command-buffer extractor.
+     */
+    export class USDFileLoader implements ISceneLoaderPluginAsync, ISceneLoaderPluginFactory {
+        /**
+         * Default URLs for the prebuilt OpenUSD importer assets.
+         */
+        static DefaultConfiguration: {
+            glueUrl: string;
+            wasmUrl: string;
+            dataUrl: string;
+            workerUrl: string;
+        };
+        /**
+         * Defines the name of the plugin.
+         */
+        readonly name: "usd";
+        /**
+         * Defines the extensions the plugin can load.
+         */
+        readonly extensions: {
+            readonly ".usd": {
+                readonly isBinary: true;
+            };
+            readonly ".usda": {
+                readonly isBinary: true;
+            };
+            readonly ".usdc": {
+                readonly isBinary: true;
+            };
+            readonly ".usdz": {
+                readonly isBinary: true;
+            };
+        };
+        private readonly _options;
+        private _worker;
+        private _workerUrl;
+        private _workerBlobUrl;
+        private _nextRequestId;
+        private readonly _pending;
+        private readonly _activeLoads;
+        /**
+         * Creates a USD loader.
+         * @param options Options controlling worker assets, supporting files, and diagnostics.
+         */
+        constructor(options?: Partial<USDFileLoaderOptions>);
+        /**
+         * Creates a configured plugin instance for a SceneLoader operation.
+         * @param options SceneLoader plugin options.
+         * @returns The configured USD loader.
+         */
+        createPlugin(options: SceneLoaderPluginOptions): ISceneLoaderPluginAsync;
+        /**
+         * Imports all objects from a USD stage into a scene.
+         * @param _meshesNames Mesh name filtering is not currently supported.
+         * @param scene The scene receiving the imported objects.
+         * @param data The USD, USDA, USDC, or USDZ bytes.
+         * @param rootUrl The source root URL.
+         * @param onProgress SceneLoader progress callback.
+         * @param fileName Name of the root USD layer.
+         * @returns The imported Babylon.js objects.
+         */
+        importMeshAsync(_meshesNames: string | readonly string[] | null | undefined, scene: Scene, data: unknown, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<ISceneLoaderAsyncResult>;
+        /**
+         * Loads a USD stage into a scene.
+         * @param scene The scene receiving the imported objects.
+         * @param data The USD, USDA, USDC, or USDZ bytes.
+         * @param rootUrl The source root URL.
+         * @param onProgress SceneLoader progress callback.
+         * @param fileName Name of the root USD layer.
+         */
+        loadAsync(scene: Scene, data: unknown, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
+        /**
+         * Loads a USD stage into an asset container.
+         * @param scene The scene used to create imported objects.
+         * @param data The USD, USDA, USDC, or USDZ bytes.
+         * @param rootUrl The source root URL.
+         * @param onProgress SceneLoader progress callback.
+         * @param fileName Name of the root USD layer.
+         * @returns The populated asset container.
+         */
+        loadAssetContainerAsync(scene: Scene, data: unknown, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<AssetContainer>;
+        /**
+         * Releases the worker and rejects pending loads.
+         */
+        dispose(): void;
+        private _loadAsync;
+        private _getWorker;
+        private _terminateWorker;
+    }
+    /** @internal */
+    export function _RegisterUSDLoaderDependencies(): void;
+    /**
+     * Registers the USD scene loader plugin and its Babylon.js runtime dependencies.
      * Safe to call multiple times; only the first call has an effect.
      */
-    export function RegisterGLTFBinaryExtension(): void;
+    export function RegisterUSDFileLoader(): void;
 
 
-
-}
-declare namespace BABYLON {
+    /**
+     * Defines the USD loader plugin metadata.
+     */
+    export var USDFileLoaderMetadata: {
+        readonly name: "usd";
+        readonly extensions: {
+            readonly ".usd": {
+                readonly isBinary: true;
+            };
+            readonly ".usda": {
+                readonly isBinary: true;
+            };
+            readonly ".usdc": {
+                readonly isBinary: true;
+            };
+            readonly ".usdz": {
+                readonly isBinary: true;
+            };
+        };
+    };
 
 
-}
-declare namespace BABYLON.GLTF1 {
-        /**
+    /**
      * Re-exports the pure implementation and applies the runtime registration side effect.
-     * Import "./glTFBinaryExtension.pure" for tree-shakeable, side-effect-free usage.
-     */
+     * Import "./usdFileLoader.pure" for tree-shakeable, side-effect-free usage.
+     */
+
+
+    export const COMMAND_MAGIC = 1111774037;
+    export const PROTOCOL_VERSION = 5;
+    export const MISSING_OFFSET = 4294967295;
+    export enum Command {
+        Scene = 1,
+        Texture = 2,
+        Material = 3,
+        TransformNode = 4,
+        Skeleton = 5,
+        Geometry = 6,
+        Mesh = 7,
+        Instance = 8,
+        Animation = 9,
+        AnalyticPrimitive = 10,
+        ThinInstances = 11,
+        MorphTarget = 12
+    }
+    export enum AnalyticPrimitiveType {
+        Cube = 0,
+        Sphere = 1,
+        Cylinder = 2,
+        Cone = 3
+    }
+    export enum PrimitiveAxis {
+        X = 0,
+        Y = 1,
+        Z = 2
+    }
+    export enum AnimationTarget {
+        Node = 0,
+        Bone = 1,
+        MorphTarget = 2
+    }
+    export enum AnimationProperty {
+        Position = 0,
+        RotationQuaternion = 1,
+        Scaling = 2,
+        Matrix = 3,
+        Influence = 4
+    }
+    export enum MaterialFlags {
+        DoubleSided = 1,
+        Unlit = 2,
+        AlphaBlend = 4
+    }
+    export enum TextureOutputChannel {
+        R = 0,
+        G = 1,
+        B = 2,
+        A = 3,
+        RGB = 4
+    }
+    export enum USDTextureColorSpace {
+        Auto = 0,
+        Raw = 1,
+        SRGB = 2
+    }
+    export enum MeshFlags {
+        DoubleSided = 1,
+        LeftHanded = 2
+    }
+    export enum GeometryFlags {
+        Normals = 1,
+        Tangents = 2,
+        Uv0 = 4,
+        Colors = 8,
+        Skin0 = 16,
+        Skin1 = 32
+    }
+    export interface CommandRecord {
+        opcode: Command;
+        flags: number;
+        payloadOffset: number;
+        payloadLength: number;
+    }
+    export function readCommands(buffer: ArrayBuffer): CommandRecord[];
+    export class PayloadReader {
+        #private;
+        offset: number;
+        constructor(buffer: ArrayBuffer, offset: number, length: number);
+        u32(): number;
+        f32(): number;
+    }
+
+
+    /** Pure barrel — re-exports only side-effect-free modules */
 
 
 
-}
-declare namespace BABYLON {
 
         interface SceneLoaderPluginOptions {
             /**
@@ -22459,6 +24272,18 @@ declare namespace BABYLON {
      * Selects which LOD value drives the {@link GaussianSplattingStream} debug wireframe colors.
      */
     export type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
+    /**
+     * Immutable metadata-resolution state for a stream's total number of finest-LOD splats.
+     * @experimental
+     */
+    export type GaussianSplattingStreamLod0SplatCount = Readonly<{
+        status: "pending";
+    }> | Readonly<{
+        status: "available";
+        count: number;
+    }> | Readonly<{
+        status: "unavailable";
+    }>;
     /**
      * Options for {@link GaussianSplattingStream}.
      */
@@ -22578,6 +24403,7 @@ declare namespace BABYLON {
         private readonly _rootUrl;
         private readonly _streamOptions;
         private readonly _leafNodes;
+        private _lod0SplatCount;
         private _lodBaseDistance;
         private _lodMultiplier;
         private _lodBehindPenalty;
@@ -22742,6 +24568,19 @@ declare namespace BABYLON {
          * @experimental
          */
         get effectiveSplatBudget(): number;
+        /**
+         * The resolved maximum number of splats kept resident in the work buffer. This combines
+         * {@link IGaussianSplattingStreamOptions.maxResidentSplats} and {@link IGaussianSplattingStreamOptions.memoryBudgetMb},
+         * taking the smaller limit when both are configured. `0` means the resident budget is disabled.
+         * @experimental
+         */
+        get residentSplatBudget(): number;
+        /**
+         * The total number of splats represented by valid level-0 leaf entries. This remains pending while source
+         * metadata is loading and is unavailable when no applicable level-0 entries exist or required metadata fails.
+         * @experimental
+         */
+        get lod0SplatCount(): GaussianSplattingStreamLod0SplatCount;
         /**
          * Resolves the raw {@link splatBudget} option to a concrete cap: `undefined` ⇒ 0 (disabled), `"auto"` ⇒ a
          * device-tiered default, a positive number ⇒ itself (floored).
@@ -22911,6 +24750,11 @@ declare namespace BABYLON {
          * @returns sorted unique file indices
          */
         private _collectAllFileIds;
+        /**
+         * Settles the level-0 diagnostic from normalized renderable leaf entries after their source metadata resolves.
+         * A file may back several leaf ranges, so its source count is deliberately not used in the total.
+         */
+        private _resolveLod0SplatCount;
         /**
          * Fetches the environment bundle and every referenced file's metadata to learn splat counts, caching
          * each file's parsed metadata for the later on-demand decode. Metadata fetches run in parallel.
@@ -24068,12 +25912,83 @@ declare namespace BABYLON {
      * Defines options for the FBX loader.
      */
     export interface FBXFileLoaderOptions {
+        /**
+         * Bundle of defaults for the options that change what the loaded scene looks like.
+         * - "compatible" (default): the behaviour of the loader as first shipped: StandardMaterial for every material,
+         *   one Babylon geometry per model, curve geometry skipped, constraints recorded as metadata only, clips rebased
+         *   to start at frame 0, cameras and lights placed in world space.
+         * - "full": everything the loader can do: PBRMaterial for physically based shaders, geometry shared between
+         *   instances, curves as lines meshes, constraints solved at runtime, authored clip times, cameras and lights
+         *   parented to their nodes so they animate.
+         * An option set explicitly always wins over the preset.
+         */
+        preset?: "compatible" | "full";
         /**
          * Source convention for tangent-space normal maps connected through FBX normal-map slots.
          * FBX does not standardize this convention, so the loader defaults to the glTF/USD-style Y-up convention.
          * Set to "y-down" for assets authored with inverted green/Y normal maps.
          */
         normalMapCoordinateSystem?: FBXNormalMapCoordinateSystem;
+        /**
+         * Which Babylon material to build.
+         * - "standard" (default, "full" preset: "auto"): always StandardMaterial (PBR parameters are approximated).
+         * - "auto": PBRMaterial for physically based FBX materials (Standard Surface, Arnold, 3ds Max Physical,
+         *   3ds Max PBR, glTF, OpenPBR, Stingray PBS) and StandardMaterial for classic Lambert/Phong materials.
+         * - "pbr": always PBRMaterial (Lambert/Phong parameters are converted).
+         */
+        materials?: "auto" | "standard" | "pbr";
+        /**
+         * Unit conversion applied at the root of the loaded hierarchy.
+         * - "preserve" (default): keep the file's units (1 Babylon unit = 1 FBX unit).
+         * - "meters": scale so that 1 Babylon unit is 1 meter, using the file's UnitScaleFactor.
+         * - a number: centimeters per Babylon unit (100 = meters, 1 = centimeters, 2.54 = inches).
+         */
+        unitScale?: "preserve" | "meters" | number;
+        /**
+         * Share vertex data between models that reference the same FBX geometry (default false, "full" preset: true).
+         * Skinned meshes are never shared.
+         */
+        shareGeometry?: boolean;
+        /**
+         * Called for every recoverable issue found while loading (unsupported features, malformed data that was
+         * skipped, approximations). The same list is stored on the root node's metadata as `fbxDiagnostics`.
+         */
+        onWarning?: (warning: FBXLoaderWarning) => void;
+        /**
+         * Segments per knot span when tessellating NURBS surfaces. Zero or undefined uses the subdivision stored in
+         * the file (usually 4), capped at 16.
+         */
+        nurbsSubdivision?: number;
+        /** How curve geometry (Line, NurbsCurve) is imported: skipped (default) or as lines meshes ("full" preset). */
+        curves?: "lines" | "skip";
+        /**
+         * Constraints (aim, parent, position, rotation, scale): "metadata" (default) only records them on the nodes,
+         * "apply" ("full" preset) attaches an `FBXConstraintBehavior` to each constrained node so it is solved before
+         * every render. IK chains are always metadata only.
+         */
+        constraints?: "apply" | "metadata";
+        /**
+         * Shift every clip so its first keyframe sits at frame 0 (default true). With false ("full" preset) keys keep
+         * the times authored in the file, so clips of one file stay aligned with each other and with their declared
+         * ranges.
+         */
+        rebaseAnimations?: boolean;
+        /**
+         * Parent cameras and lights to their FBX node so they follow its animation (default false, "full" preset:
+         * true). Otherwise they are created at the node's world position and orientation, unparented.
+         */
+        attachCamerasAndLights?: boolean;
+    }
+    /** A recoverable issue reported while loading an FBX file. */
+    export interface FBXLoaderWarning {
+        /** Which part of the loader reported the issue */
+        source: "scene" | "model" | "geometry" | "skin" | "rig" | "animation" | "blendShape" | "camera" | "light";
+        /** Human readable description */
+        message: string;
+        /** Name of the affected object, when known */
+        objectName?: string;
+        /** Structured details from the interpreter, when any */
+        details?: unknown;
     }
     /**
      * FBX file loader plugin for Babylon.js.
@@ -24096,6 +26011,22 @@ declare namespace BABYLON {
         private readonly _bindRestBones;
         private readonly _sourceBonesBySkeleton;
         private readonly _scaleCompensationHelpersBySkeleton;
+        /** Frame rate of the file being loaded (GlobalSettings TimeMode); animation is baked at this rate. */
+        private _frameRate;
+        /** Layers of the animation stack currently being converted; used by the transform samplers. */
+        private _activeLayers;
+        /** Parent model per model id, for inherit-mode aware sampling. */
+        private _parentModelById;
+        /** Curve nodes per model id for the stack currently being converted. */
+        private _curveNodesByModelId;
+        /** Helper nodes inserted above models whose InheritType is not RSrs. */
+        private _inheritScaleHelpers;
+        /** First mesh built per (geometry, geometric transform), for geometry sharing between instances. */
+        private _meshByGeometryKey;
+        /** Instance mesh -> source mesh whose geometry it shares. */
+        private _instanceSource;
+        /** Property curve nodes that were mapped onto Babylon animations; their "not evaluated" diagnostics are dropped. */
+        private _evaluatedCurveNodeIds;
         /**
          * Creates a new FBX loader.
          * @param options - Options controlling FBX loading behavior
@@ -24138,6 +26069,11 @@ declare namespace BABYLON {
          * @returns A promise containing the loaded asset container
          */
         loadAssetContainerAsync(scene: Scene, data: unknown, rootUrl: string, _onProgress?: (event: ISceneLoaderProgressEvent) => void, _fileName?: string): Promise<AssetContainer>;
+        /**
+         * Parses and interprets the file. Parsing is synchronous, so no progress events are emitted: the scene loader's
+         * progress callback reports download bytes and must not be fed synthetic counts.
+         */
+        private _parseAndInterpret;
         private _parse;
         private _parseFromArrayBuffer;
         private _buildScene;
@@ -24149,6 +26085,15 @@ declare namespace BABYLON {
         private _linkSkeletonsToTransformNodes;
         private static _modelSubtreeMatchesNameFilter;
         private static _applyModelMetadata;
+        /**
+         * Wires a LodGroup's children as Babylon LOD levels: the first child holds the highest detail; every further
+         * child replaces it beyond the group's threshold distance (or screen coverage when thresholds are percentages).
+         * Each child's display mode is honoured first: level 1 (show) stays visible outside the LOD chain, level 2
+         * (hide) is disabled, and only level 0 (use LOD) children take part in the distance switching.
+         */
+        private static _applyLodGroup;
+        /** Builds a lines mesh from Line or tessellated NurbsCurve geometry, applying the model's geometric transform. */
+        private _createLinesMesh;
         private _createMesh;
         /**
          * Apply multi-material to a mesh by creating sub-meshes grouped by material index.
@@ -24172,6 +26117,11 @@ declare namespace BABYLON {
          */
         private _buildSkinningData;
         private _createMaterial;
+        private _createPbrMaterial;
+        /** Alpha of a classic Lambert/Phong material: Opacity when present, otherwise 1 - TransparentColor * TransparencyFactor. */
+        private static _alphaFromClassicTransparency;
+        private static _applyTextureSettings;
+        private _createStandardMaterial;
         private _configureNormalTexture;
         private _getNormalMapTangentHandednessScale;
         private static _isSupportedMaterialTextureSlot;
@@ -24195,11 +26145,27 @@ declare namespace BABYLON {
         private _createCamera;
         private _createLight;
         private _createSkeleton;
+        private _rigBoneModelIds;
+        private _isRigBone;
         private _getSourceBone;
         private _getScaleCompensationHelper;
         private static _computeFBXAbsoluteMatrices;
+        /**
+         * Effective ("inherit") scale of every bone, following the FBX SDK: the local scale for RSrs bones, and for
+         * RrSs / Rrs bones the local scale multiplied by the scale of the bone's inherit-scale node (the parent for RrSs,
+         * the parent's inherit-scale node for Rrs). Bones are ordered parents first.
+         */
+        private static _computeBoneInheritScales;
+        private static _getBoneInheritScaleNode;
+        /** Scale a bone inherits into its own scale (RrSs chains), or unit scale. */
+        private static _getBoneInheritedScale;
         private static _computeFBXRuntimeLocalMatrix;
         private static _applyParentScaleCompensation;
+        /**
+         * Splits a bone's FBX local matrix into a helper (which cancels the parent scale and carries the translation,
+         * so the translation still follows the parent scale as the SDK does) and the bone's own rotation/scale. For RrSs
+         * bones the inherited scale is folded into the bone scale.
+         */
         private static _splitParentScaleCompensatedLocalMatrix;
         private static _safeInverseScale;
         private static _getInverseScaleVector;
@@ -24216,13 +26182,8 @@ declare namespace BABYLON {
          * In row-vector convention: v' = v * M
          */
         private static _computeFBXLocalMatrix;
-        /**
-         * Apply the FBX transform chain to a Babylon TransformNode or Mesh.
-         * Decomposes the full local matrix into position/rotation/scale.
-         */
-        private static _applyFBXTransform;
+        private _applyRestTRS;
         private static _computeFBXModelLocalMatrix;
-        private static _getBoneReferenceWorldMatrix;
         private static _applyMatrixToTransform;
         private _createAnimationGroup;
         private _buildInheritedRigBoneAnimations;
@@ -24232,9 +26193,61 @@ declare namespace BABYLON {
          * Computes the full FBX transform matrix at each keyframe and decomposes into TRS.
          */
         private _buildNodeAnimations;
+        /**
+         * Baked keys are interpolated linearly by Babylon. Between two frames an FBX cubic segment can deviate from that
+         * line, so sample times are refined (midpoints inserted, up to two levels) wherever the interpolated transform
+         * differs noticeably from the curve. Flat and linear segments stay at frame resolution.
+         */
+        private static _refineSampleTimes;
+        /**
+         * Keys of a scalar property animated by one or more layers: the authored keys when a single layer drives it,
+         * otherwise the frame grid evaluated through the layer stack.
+         * @param sources - Per-layer curves of the property (each with at least one curve)
+         * @param animStack - Stack being converted
+         * @param mapValue - Conversion from the FBX value to the Babylon property value
+         * @returns Animation keys
+         */
+        private _layeredScalarKeys;
+        /**
+         * Maps an animated FBX property (anything other than node transforms and blend shape weights) onto the Babylon
+         * property that carries it: mesh visibility, camera field of view and clip planes, light intensity, colour and
+         * cone angles, and material colours, alpha, roughness and metalness. `group` holds the curve nodes of every
+         * layer animating that property, in layer order; several layers are evaluated through the layer stack.
+         */
+        private _buildPropertyAnimations;
+        /** Records constraints on their nodes and, unless disabled, attaches the runtime behavior that solves them. */
+        private _applyConstraints;
+        /** Collects every recoverable issue the interpreter recorded, stores it on the root node and notifies the caller. */
+        private _reportDiagnostics;
+        /** Curve nodes affecting the inherit scale of a model: its own scale curves and those of its inherit-scale chain. */
+        private _collectInheritScaleCurves;
         private _isVector3KeysConstant;
+        /** Samples the animated Lcl Translation / Rotation / Scaling of a model, blending all layers of the active stack. */
+        private _sampleModelTRS;
+        /**
+         * Local position/rotation/scale of a model from FBX Lcl values. Without pivots and offsets the components map
+         * directly (rotation = pre * lcl * post⁻¹), which keeps zero and negative scales exact. With pivots the full
+         * matrix is built and decomposed.
+         */
+        private static _computeLocalTRS;
+        /** Applies inherit-mode adjustments to a local TRS (see _computeInheritAwareLocalMatrix). */
+        private _adjustTRSForInheritMode;
         private _sampleModelLocalMatrix;
         private _sampleModelScale;
+        /**
+         * Effective scale of a model for inherit-mode math (`inherit_scale` in ufbx terms): its own local scale, multiplied
+         * componentwise by the inherited scale when the model uses RrSs inheritance. `time` samples animation; undefined
+         * uses the rest pose.
+         */
+        private _getInheritScale;
+        /** RrSs nodes inherit scale from their parent; Rrs nodes skip their immediate parent (chaining through Rrs parents). */
+        private _getInheritScaleNode;
+        /**
+         * Local matrix of a model relative to its Babylon parent frame, accounting for inherit modes. For RSrs (the
+         * default) this is the FBX local matrix. For RrSs / Rrs the node sits under a helper that removes the parent's
+         * scale, so translation is pre-scaled by the parent scale and (for RrSs) scale accumulates componentwise.
+         */
+        private _computeInheritAwareLocalMatrix;
         /**
          * Build matrix-baked bone animation from full FBX local transforms.
          * The bind matrix carries the skinning offset, so animation curves drive
@@ -24269,6 +26282,189 @@ declare namespace BABYLON {
      */
 
 
+    /**
+     * Runtime evaluation of FBX constraints. An `FBXConstraintBehavior` is attached to each constrained node; all
+     * behaviors of a scene register with one `FBXConstraintSolver`, which solves them in dependency order (a constraint
+     * whose target or parent is driven by another constraint is solved after it) and reuses scratch objects, so solving
+     * allocates nothing per frame.
+     *
+     * The solver brackets the scene's animation phase: before animations run it writes each node's unconstrained
+     * transform back, after they ran it captures the result as the new unconstrained transform and solves. A partial
+     * weight therefore always blends from what animation (or nothing) produced this frame, never from the previous
+     * solve's output, so a 50% weight stays a 50% blend instead of converging on the target.
+     *
+     * All maths happen in FBX space, i.e. relative to the loader's root node, so the handedness conversion applied
+     * at the root never enters the solve.
+     */
+    /** Resolved target of a constraint. */
+    export interface FBXConstraintBehaviorTarget {
+        /** Target node */
+        node: TransformNode;
+        /** Normalized target weight (0..1) */
+        weight: number;
+        /** Offset matrix for parent constraints (in the target's space) */
+        offset: Matrix;
+    }
+    /** Options resolved by the loader when creating the behavior. */
+    export interface FBXConstraintBehaviorOptions {
+        /** Root of the loaded asset; world matrices are made relative to it */
+        root: TransformNode;
+        /** Resolved targets of the constraint, in file order */
+        targets: FBXConstraintBehaviorTarget[];
+        /** World up object of an aim constraint, when it has one */
+        upNode: Nullable<TransformNode>;
+        /** Scene up axis in FBX space */
+        sceneUp: Vector3;
+    }
+    /**
+     * Solves every FBX constraint of a scene once per frame, in dependency order, from the scene's animation phase
+     * observers (`beginFrame` before animations, `solve` after them). Created on demand by the first
+     * `FBXConstraintBehavior` attached in the scene and removed with the last one.
+     */
+    export class FBXConstraintSolver {
+        private readonly _scene;
+        private readonly _behaviors;
+        private _ordered;
+        private _cyclic;
+        private _dirty;
+        private _beforeAnimations;
+        private _afterAnimations;
+        private constructor();
+        /**
+         * Solver of a scene, if any constraint behavior is attached in it.
+         * @param scene - Scene to look up
+         * @returns The solver, or undefined
+         */
+        static Get(scene: Scene): FBXConstraintSolver | undefined;
+        /**
+         * Solver of a scene, created when missing.
+         * @param scene - Scene to look up
+         * @returns The solver
+         */
+        static GetOrCreate(scene: Scene): FBXConstraintSolver;
+        /** Registered behaviors in solve order (a target's constraint before the constraints that read it). */
+        get constraints(): readonly FBXConstraintBehavior[];
+        /**
+         * Behaviors that take part in a dependency cycle (A targets B while B targets A). They are solved after all
+         * acyclic constraints, in registration order, so each sees the other's result from the previous solve.
+         */
+        get cyclicConstraints(): readonly FBXConstraintBehavior[];
+        /**
+         * Adds a behavior to the solve set.
+         * @param behavior - Behavior to add
+         */
+        register(behavior: FBXConstraintBehavior): void;
+        /**
+         * Removes a behavior from the solve set; the solver disposes itself with the last one.
+         * @param behavior - Behavior to remove
+         */
+        unregister(behavior: FBXConstraintBehavior): void;
+        /** Marks the solve order stale, e.g. after re-parenting a constrained node. */
+        invalidateOrder(): void;
+        /**
+         * Start of a frame, before animations run: every constrained node gets its unconstrained transform back, so
+         * that animation either overwrites it or leaves it untouched.
+         */
+        beginFrame(): void;
+        /**
+         * End of the animation phase: takes every constrained node's current transform as its unconstrained value,
+         * then solves every registered constraint once, in dependency order.
+         */
+        solve(): void;
+        private _ensureOrder;
+        private static _IsAncestorOrSelf;
+    }
+    /** Babylon behavior evaluating an FBX aim, parent, position, rotation or scale constraint. */
+    export class FBXConstraintBehavior implements Behavior<TransformNode> {
+        /** Constraint data extracted from the file */
+        readonly constraint: FBXConstraintData;
+        private readonly _options;
+        /** Behavior name (`fbxConstraint:` followed by the constraint name) */
+        readonly name: string;
+        /** Node the behavior is attached to */
+        attachedNode: Nullable<TransformNode>;
+        /** Set to false to pause the constraint without detaching it */
+        enabled: boolean;
+        private readonly _offsetTranslation;
+        private readonly _offsetRotation;
+        private readonly _offsetScale;
+        private readonly _localBasisTransposed;
+        /** Unconstrained transform of the current frame (what animation produced), blended towards the constraint's result. */
+        private readonly _base;
+        private _hasBase;
+        /**
+         * Creates the behavior.
+         * @param constraint - Constraint data extracted from the file
+         * @param _options - Resolved targets and scene information
+         */
+        constructor(
+        /** Constraint data extracted from the file */
+        constraint: FBXConstraintData, _options: FBXConstraintBehaviorOptions);
+        /** Nothing to initialize */
+        init(): void;
+        /**
+         * Registers the behavior with the scene's solver, takes the node's current transform as the unconstrained
+         * value and solves the constraint once.
+         * @param target - Node to constrain
+         */
+        attach(target: TransformNode): void;
+        /** Unregisters the behavior; the node keeps its last solved transform. */
+        detach(): void;
+        /**
+         * Takes the node's current transform as the unconstrained value the next solve blends from. The solver calls
+         * this after the scene's animations ran; call it yourself after writing a transform by hand.
+         */
+        captureBase(): void;
+        /**
+         * Writes the unconstrained transform back to the node. The solver calls this before the scene's animations
+         * run, so a node nothing animates keeps its unconstrained value between frames instead of the solved one.
+         */
+        restoreBase(): void;
+        /**
+         * Nodes whose world transform the solve reads: the targets, the up node and the constrained node's parent.
+         * @returns The nodes, used by the solver to order constraints
+         */
+        dependencyNodes(): Nullable<Node>[];
+        /**
+         * Solves the constraint from the captured unconstrained transform and writes the node's local transform.
+         * Blends are relative to the value captured by `captureBase`, not to whatever the node holds now.
+         */
+        evaluate(): void;
+        /**
+         * World matrix of a node relative to the asset root (FBX space).
+         * @param node - node to evaluate
+         * @param out - matrix receiving the result
+         * @returns `out`
+         */
+        private _fbxWorld;
+        /**
+         * Weighted blend of the targets' world transforms (relative to the root).
+         * @param position - Receives the blended translation
+         * @param rotation - Receives the blended rotation
+         * @param scale - Receives the blended scale
+         * @returns The total target weight, 0 when no target contributes
+         */
+        private _blendTargets;
+        private _applyWeighted;
+        private _applyRotation;
+        private _writePosition;
+        private _writeScaling;
+        private _solvePosition;
+        private _solveRotation;
+        private _solveScale;
+        private _solveParent;
+        private _solveAim;
+        /**
+         * Builds a rotation matrix whose rows are `first`, `second` made orthogonal to it, and their cross product.
+         * @param first - primary axis
+         * @param second - secondary axis
+         * @param out - matrix receiving the basis
+         * @returns false when the axes are parallel or degenerate (`out` is then unchanged)
+         */
+        private static _OrthonormalBasisToRef;
+    }
+
+
     /**
      * Intermediate representation for parsed FBX data.
      * Both binary and ASCII parsers produce this same structure.
@@ -24283,6 +26479,11 @@ declare namespace BABYLON {
         type: FBXPropertyType;
         /** Parsed property value. */
         value: FBXPropertyValue;
+        /**
+         * Exact decimal text of an int64 whose magnitude exceeds 2^53; `value` then holds the rounded double. Object
+         * ids are the only int64 values where the last bits matter, and `resolveConnections` keys them by this text.
+         */
+        raw?: string;
     }
     /** A node in the FBX document tree */
     export interface FBXNode {
@@ -24309,11 +26510,22 @@ declare namespace BABYLON {
     /** Extract a property value by index, with type narrowing */
     export function getPropertyValue<T extends FBXPropertyValue>(node: FBXNode, index: number): T | undefined;
     /**
-     * Converts an FBX object ID value to a safe JavaScript number.
+     * Validates an FBX object ID value: IDs are 64-bit integers, so anything non-numeric, non-finite or fractional is
+     * rejected. IDs beyond 2^53 are carried losslessly through the property's `raw` text by `resolveConnections`.
      * @param value - Parsed FBX object ID value
-     * @returns The object ID, or undefined when the value is not numeric
+     * @returns The object ID, or undefined when the value cannot be an ID
      */
     export function getSafeFBXObjectId(value: unknown): number | undefined;
+    /** Typed array payload types produced by the parsers. */
+    export type FBXArrayValue = Float32Array | Float64Array | Int32Array | Uint8Array;
+    /**
+     * Returns the array payload of a node.
+     * FBX 7.x stores arrays as a single array property. FBX 6.x (and some 7.x ASCII exporters) store them as a run of
+     * scalar properties, and a one-element array degenerates to a single scalar. All of these are coalesced here.
+     * @param node - Node whose properties hold the array
+     * @returns The array, or null when the node has no numeric payload
+     */
+    export function getNodeArray(node: FBXNode | undefined | null): FBXArrayValue | null;
     /** Get the numeric ID from a node (first property is typically the int64 UID) */
     export function getNodeId(node: FBXNode): number | undefined;
     /**
@@ -24441,25 +26653,9 @@ declare namespace BABYLON {
         /** Recoverable skinning/bind diagnostics */
         diagnostics: FBXSkinDiagnostic[];
     }
-    /**
-     * Extract all skin deformers from the FBX scene.
-     * Returns skin data including bone hierarchy and vertex weights.
-     */
-    export function extractSkins(objectMap: FBXObjectMap): FBXSkinData[];
+    export function extractSkins(objectMap: FBXObjectMap, propertyTemplates?: FBXPropertyTemplateMap): FBXSkinData[];
     export function isSkeletonModel(modelNode: FBXNode): boolean;
-    export function extractBoneTransform(modelNode: FBXNode): {
-        translation: [number, number, number];
-        rotation: [number, number, number];
-        preRotation: [number, number, number];
-        postRotation: [number, number, number];
-        rotationPivot: [number, number, number];
-        scalingPivot: [number, number, number];
-        rotationOffset: [number, number, number];
-        scalingOffset: [number, number, number];
-        scale: [number, number, number];
-        rotationOrder: number;
-        inheritType: number;
-    };
+    export function extractBoneTransform(modelNode: FBXNode, template?: FBXPropertyTemplate): FBXNodeTransformData;
 
 
     export type FBXSceneDiagnosticType = "unsupported-constraint" | "unsupported-helper" | "unsupported-deformer" | "unsupported-node-attribute" | "unsupported-pose" | "unsupported-layered-texture" | "connection-graph";
@@ -24518,6 +26714,160 @@ declare namespace BABYLON {
     export function resolveVector2Property(node: FBXNode, template: FBXPropertyTemplate | undefined, propertyName: string, fallback: [number, number]): [number, number];
     export function resolveVector3Property(node: FBXNode, template: FBXPropertyTemplate | undefined, propertyName: string, fallback: [number, number, number]): [number, number, number];
     export function resolvePropertyValues(node: FBXNode, template: FBXPropertyTemplate | undefined, propertyName: string): FBXPropertyValue[] | undefined;
+    /** A property from a Properties70 ("P") or Properties60 ("Property") block. */
+    export interface FBXPropertyEntry {
+        name: string;
+        type: string;
+        flags: string;
+        values: FBXPropertyValue[];
+    }
+    /**
+     * Lists the properties declared directly on an object, from both the 7.x and 6.x property blocks.
+     * @param node - Object node
+     * @returns Property entries in declaration order (empty when the node has no property block)
+     */
+    export function getPropertyEntries(node: FBXNode | undefined): FBXPropertyEntry[];
+    /** Value of a user property: scalars as-is, vectors and colours as number arrays. */
+    export type FBXUserPropertyValue = string | number | boolean | number[];
+    /**
+     * User-defined properties of an object: those flagged "U" (user) in the property flags. Every DCC exports custom
+     * attributes this way (Maya extra attributes, 3ds Max user properties, Blender custom properties).
+     * @param node - Object node
+     * @returns Map of property name to value, or undefined when the object has none
+     */
+    export function extractUserProperties(node: FBXNode): Record<string, FBXUserPropertyValue> | undefined;
+    export function userPropertyValue(values: FBXPropertyValue[], typeName?: string): FBXUserPropertyValue | undefined;
+
+
+    /**
+     * NURBS curves and surfaces, and polyline ("Line") geometry.
+     *
+     * The basis evaluation and tessellation follow the FBX SDK conventions as implemented by ufbx: knot spans are
+     * subdivided uniformly, closed and periodic curves wrap their control points, and surfaces are tessellated into
+     * quads (degenerate quads at poles become triangles) with welded positions along the wrapped edges.
+     */
+    export type FBXNurbsTopology = "open" | "closed" | "periodic";
+    /** Knot vector and derived data of one parametric direction. */
+    export interface FBXNurbsBasis {
+        order: number;
+        topology: FBXNurbsTopology;
+        knots: Float64Array;
+        /** Parameter range that the curve is defined on */
+        tMin: number;
+        tMax: number;
+        /** Distinct knot values inside [tMin, tMax], i.e. the boundaries of the non-empty spans */
+        spans: Float64Array;
+        /** False when the knot vector is too short or not monotonic */
+        valid: boolean;
+    }
+    /** NURBS curve: homogeneous control points (x, y, z, w) and a basis. */
+    export interface FBXNurbsCurveData {
+        basis: FBXNurbsBasis;
+        /** Control points as x,y,z,w */
+        controlPoints: Float64Array;
+        numControlPoints: number;
+    }
+    /** NURBS surface: control points laid out as `v * numU + u`. */
+    export interface FBXNurbsSurfaceData {
+        basisU: FBXNurbsBasis;
+        basisV: FBXNurbsBasis;
+        numU: number;
+        numV: number;
+        /** Control points as x,y,z,w */
+        controlPoints: Float64Array;
+        flipNormals: boolean;
+        /** Span subdivision stored in the file (Step), 0 when absent */
+        stepU: number;
+        stepV: number;
+    }
+    /** Polyline geometry ready for a lines mesh: one or more open or closed point runs. */
+    export interface FBXCurveGeometryData {
+        id: number;
+        name: string;
+        kind: "line" | "nurbsCurve";
+        /** Each polyline as x,y,z triples; closed runs repeat their first point at the end */
+        polylines: Float64Array[];
+        /** Display colour from the geometry's Color property */
+        color: [number, number, number] | null;
+        diagnostics: FBXGeometryDiagnostic[];
+    }
+    export function createNurbsBasis(order: number, form: string | undefined, knots: Float64Array): FBXNurbsBasis;
+    /**
+     * Evaluates the basis functions (and their derivatives) that are non-zero at `u`.
+     * @returns index of the first influencing control point, or -1 when the basis cannot be evaluated
+     */
+    export function evaluateNurbsBasis(basis: FBXNurbsBasis, u: number, weights: Float64Array, derivatives: Float64Array | null): number;
+    /** Evaluates a curve point; `out` receives position (0..2) and derivative (3..5). */
+    export function evaluateNurbsCurve(curve: FBXNurbsCurveData, u: number, out: Float64Array, weights: Float64Array, derivs: Float64Array): boolean;
+    /** Evaluates a surface point; `out` receives position (0..2), du (3..5) and dv (6..8). */
+    export function evaluateNurbsSurface(surface: FBXNurbsSurfaceData, u: number, v: number, out: Float64Array, scratch: {
+        wu: Float64Array;
+        wv: Float64Array;
+        du: Float64Array;
+        dv: Float64Array;
+    }): boolean;
+    /**
+     * Tessellates a curve into a polyline with `subdivision` segments per knot span. Closed and periodic curves
+     * end on a copy of their first point.
+     */
+    export function tessellateNurbsCurve(curve: FBXNurbsCurveData, subdivision?: number): Float64Array | null;
+    /** Span subdivision to use for a surface direction: an explicit override, else the file's Step, else 4. */
+    export function resolveSpanSubdivision(fileStep: number, override: number | undefined): number;
+    /**
+     * Tessellates a surface into triangles. Positions on wrapped (closed/periodic) edges and at poles are welded
+     * exactly like the FBX SDK does, so degenerate quads collapse into triangles.
+     */
+    export function tessellateNurbsSurface(surface: FBXNurbsSurfaceData, subU: number, subV: number): {
+        positions: Float64Array;
+        indices: Uint32Array;
+        normals: Float64Array;
+        uvs: Float64Array;
+    } | null;
+    /** Reads a NurbsCurve geometry node. */
+    export function extractNurbsCurve(node: FBXNode): FBXNurbsCurveData | null;
+    /** Reads a NurbsSurface geometry node. */
+    export function extractNurbsSurface(node: FBXNode): FBXNurbsSurfaceData | null;
+    /** Tessellates a NurbsSurface geometry node into mesh geometry. */
+    export function nurbsSurfaceToGeometry(node: FBXNode, geometryId: number, subdivisionOverride: number | undefined): FBXGeometryData | null;
+    /** Reads a NurbsCurve geometry node into a tessellated polyline. */
+    export function extractNurbsCurveGeometry(node: FBXNode, geometryId: number, subdivision?: number): FBXCurveGeometryData;
+    /**
+     * Reads a Line geometry node: Points plus PointsIndex where a negative index (~index) ends a segment, as in
+     * polygon vertex indices.
+     */
+    export function extractLineGeometry(node: FBXNode, geometryId: number): FBXCurveGeometryData;
+
+
+    /** Transform properties resolved from an FBX Model, with template defaults applied. */
+    export interface FBXNodeTransformData {
+        translation: [number, number, number];
+        rotation: [number, number, number];
+        scale: [number, number, number];
+        preRotation: [number, number, number];
+        postRotation: [number, number, number];
+        rotationPivot: [number, number, number];
+        scalingPivot: [number, number, number];
+        rotationOffset: [number, number, number];
+        scalingOffset: [number, number, number];
+        geometricTranslation: [number, number, number];
+        geometricRotation: [number, number, number];
+        geometricScaling: [number, number, number];
+        /** Rotation order: 0=XYZ, 1=XZY, 2=YZX, 3=YXZ, 4=ZXY, 5=ZYX, 6=SphericXYZ */
+        rotationOrder: number;
+        /** FBX transform inheritance mode. 0=RrSs, 1=RSrs, 2=Rrs */
+        inheritType: number;
+        /** Whether the rotation space (rotation order, pre/post rotation) is active for this node */
+        rotationActive: boolean;
+        diagnostics: string[];
+    }
+    /**
+     * Resolves the transform properties of a Model node the way the FBX SDK evaluates them.
+     *
+     * `RotationActive` gates the whole rotation space: when it is false (the FbxNode template default), the SDK
+     * composes `Lcl Rotation` in plain XYZ order and ignores `RotationOrder`, `PreRotation` and `PostRotation`.
+     * `RotationSpaceForLimitOnly` restricts the rotation space to limits, which has the same effect for us.
+     */
+    export function extractNodeTransform(modelNode: FBXNode, template?: FBXPropertyTemplate): FBXNodeTransformData;
 
 
     /** Parsed material data */
@@ -24527,6 +26877,10 @@ declare namespace BABYLON {
         type: "Lambert" | "Phong";
         properties: FBXMaterialProperties;
         textures: FBXTextureRef[];
+        /** Unified classic + PBR parameter model resolved from whichever shader flavour the file uses */
+        model: FBXMaterialModel<FBXTextureRef>;
+        /** User-defined properties */
+        userProperties?: Record<string, FBXUserPropertyValue>;
     }
     export interface FBXMaterialProperties {
         diffuseColor?: [number, number, number];
@@ -24562,11 +26916,102 @@ declare namespace BABYLON {
         uvSetIndex?: number;
         /** Which named UV set this texture uses */
         uvSetName?: string;
+        /** WrapModeU: 0 = repeat, 1 = clamp */
+        wrapU?: number;
+        /** WrapModeV: 0 = repeat, 1 = clamp */
+        wrapV?: number;
+        /** Set when the texture came from a LayeredTexture (only the first layer is used) */
+        layeredTextureId?: number;
     }
     /**
      * Extract material data from an FBX Material node.
      */
     export function extractMaterial(materialNode: FBXNode, materialId: number, objectMap: FBXObjectMap, templates?: FBXPropertyTemplateMap): FBXMaterialData;
+    export function extractTextureRef(id: number, node: FBXNode, propertyName: string | undefined, objectMap: FBXObjectMap, template?: FBXPropertyTemplate): FBXTextureRef;
+
+
+    /**
+     * Unified material model.
+     *
+     * FBX materials come in many vendor flavours: the classic FbxSurfaceLambert / FbxSurfacePhong, Autodesk Standard
+     * Surface (OSL), Arnold aiStandardSurface, 3ds Max Physical Material, 3ds Max PBR (metal/rough and spec/gloss),
+     * the 3ds Max glTF material, OpenPBR, and Maya's Stingray PBS ShaderFX graph. Each stores its parameters under
+     * different property names, sometimes behind a shader binding table.
+     *
+     * This module resolves any of them into two parameter sets, mirroring how the FBX SDK / ufbx expose materials:
+     * `fbx` (the classic Lambert/Phong parameters) and `pbr` (a physically based parameter set), plus feature flags.
+     */
+    export type FBXShaderType = "unknown" | "fbxLambert" | "fbxPhong" | "oslStandardSurface" | "arnoldStandardSurface" | "3dsMaxPhysicalMaterial" | "3dsMaxPbrMetalRough" | "3dsMaxPbrSpecGloss" | "gltfMaterial" | "openPbrMaterial" | "shaderFxGraph";
+    /** One resolved material parameter: a constant value and/or a texture. */
+    export interface FBXMaterialMap<TTexture> {
+        /** Constant value (r,g,b,a for colours, x for scalars) */
+        value?: number[];
+        /** Number of meaningful components in `value` (1 for scalars, 3 or 4 for colours) */
+        valueComponents: number;
+        /** Texture bound to the parameter */
+        texture?: TTexture;
+        /** Whether the texture is enabled (some vendors carry an explicit toggle) */
+        textureEnabled: boolean;
+    }
+    export type FBXFbxMapName = "diffuseFactor" | "diffuseColor" | "specularFactor" | "specularColor" | "specularExponent" | "reflectionFactor" | "reflectionColor" | "transparencyFactor" | "transparencyColor" | "emissionFactor" | "emissionColor" | "ambientFactor" | "ambientColor" | "normalMap" | "bump" | "bumpFactor" | "displacement" | "displacementFactor" | "vectorDisplacement" | "vectorDisplacementFactor";
+    export type FBXPbrMapName = "baseFactor" | "baseColor" | "roughness" | "metalness" | "diffuseRoughness" | "specularFactor" | "specularColor" | "specularIor" | "specularAnisotropy" | "specularRotation" | "transmissionFactor" | "transmissionColor" | "transmissionDepth" | "transmissionScatter" | "transmissionScatterAnisotropy" | "transmissionDispersion" | "transmissionRoughness" | "transmissionExtraRoughness" | "transmissionPriority" | "transmissionEnableInAov" | "subsurfaceFactor" | "subsurfaceColor" | "subsurfaceRadius" | "subsurfaceScale" | "subsurfaceAnisotropy" | "subsurfaceTintColor" | "subsurfaceType" | "sheenFactor" | "sheenColor" | "sheenRoughness" | "coatFactor" | "coatColor" | "coatRoughness" | "coatIor" | "coatAnisotropy" | "coatRotation" | "coatNormal" | "coatAffectBaseColor" | "coatAffectBaseRoughness" | "thinFilmFactor" | "thinFilmThickness" | "thinFilmIor" | "emissionFactor" | "emissionColor" | "opacity" | "indirectDiffuse" | "indirectSpecular" | "normalMap" | "tangentMap" | "displacementMap" | "matteFactor" | "matteColor" | "ambientOcclusion" | "glossiness" | "coatGlossiness" | "transmissionGlossiness";
+    export type FBXMaterialFeatureName = "pbr" | "metalness" | "diffuse" | "specular" | "emission" | "transmission" | "coat" | "sheen" | "opacity" | "ambientOcclusion" | "matte" | "unlit" | "ior" | "diffuseRoughness" | "transmissionRoughness" | "thinWalled" | "caustics" | "exitToBackground" | "internalReflections" | "doubleSided" | "roughnessAsGlossiness" | "coatRoughnessAsGlossiness" | "transmissionRoughnessAsGlossiness";
+    export interface FBXMaterialModel<TTexture> {
+        shaderType: FBXShaderType;
+        /** Prefix material property names carry for this shader (e.g. "3dsMax|Parameters|") */
+        shaderPropPrefix: string;
+        fbx: Partial<Record<FBXFbxMapName, FBXMaterialMap<TTexture>>>;
+        pbr: Partial<Record<FBXPbrMapName, FBXMaterialMap<TTexture>>>;
+        features: Partial<Record<FBXMaterialFeatureName, {
+            enabled: boolean;
+            explicit: boolean;
+        }>>;
+    }
+    /** Inputs needed to resolve a material, independent of the parse representation. */
+    export interface FBXMaterialSource<TTexture> {
+        /** "lambert", "phong", "unknown", ... as written in the file */
+        shadingModelName: string;
+        /** Property values by full property name (e.g. "DiffuseColor", "Maya|baseColor", "3dsMax|Parameters|roughness") */
+        props: Map<string, {
+            type: string;
+            values: FBXPropertyValue[];
+        }>;
+        /** Textures connected to the material by property name (OP connection property) */
+        texturesByProp: Map<string, TTexture>;
+        /** Connected shader implementation, when any */
+        shader?: {
+            renderApi: string;
+            /** shader semantic name -> material property names */
+            bindings: Map<string, string[]>;
+        };
+    }
+    /** Shader types whose parameters are physically based; the loader emits PBR materials for them by default. */
+    export function isPbrShaderType(type: FBXShaderType): boolean;
+    /** Detects the shader flavour of a material from its shading model name, connected shader and 3ds Max class ids. */
+    export function detectShaderType<T>(source: FBXMaterialSource<T>): {
+        shaderType: FBXShaderType;
+        shaderPropPrefix: string;
+    };
+    /**
+     * Resolves the unified material model from raw material data.
+     */
+    export function resolveMaterialModel<T>(source: FBXMaterialSource<T>): FBXMaterialModel<T>;
+    /** Colour (first three components) of a map, or undefined. */
+    export function mapColor<T>(map: FBXMaterialMap<T> | undefined): [number, number, number] | undefined;
+    /** Scalar (first component) of a map, or undefined. */
+    export function mapScalar<T>(map: FBXMaterialMap<T> | undefined): number | undefined;
+
+
+    /**
+     * FBX 5.x (and older) documents store everything at the top level: one `Model` node per object with inline
+     * geometry, materials, skin links, lights and cameras, and `Children` lists instead of connections. This module
+     * rewrites such a document into the 6.x layout (`Objects`, `Connections`, `Takes`) so the rest of the importer
+     * can treat both the same way. The rules follow the FBX SDK's legacy reader as implemented by ufbx.
+     */
+    /** True for pre-6000 files: no `Objects` section but top-level `Model` nodes. */
+    export function isLegacyDocument(doc: FBXDocument): boolean;
+    /** Rewrites a legacy document into the 6.x object/connection layout. */
+    export function upgradeLegacyDocument(doc: FBXDocument): FBXDocument;
 
 
     /** A named UV set */
@@ -24579,7 +27024,7 @@ declare namespace BABYLON {
     /** Recoverable geometry import issue. */
     export interface FBXGeometryDiagnostic {
         /** Diagnostic category. */
-        type: "degenerate-polygon" | "triangulation-fallback" | "layer-index-out-of-bounds" | "layer-data-too-short";
+        type: "degenerate-polygon" | "triangulation-fallback" | "layer-index-out-of-bounds" | "layer-data-too-short" | "nurbs-invalid" | "nurbs-trim-ignored" | "nurbs-deformer-ignored";
         /** Human-readable diagnostic message. */
         message: string;
         /** Polygon index associated with the diagnostic, if applicable. */
@@ -24630,8 +27075,10 @@ declare namespace BABYLON {
         id: number;
         name: string;
         subType: string;
-        /** Geometry attached to this model (if it's a Mesh type) */
+        /** Geometry attached to this model (meshes and tessellated NURBS surfaces) */
         geometry?: FBXGeometryData;
+        /** Curve geometry attached to this model (Line and NurbsCurve) */
+        curve?: FBXCurveGeometryData;
         /** Materials assigned to this model */
         materials: FBXMaterialData[];
         /** Child models */
@@ -24663,18 +27110,68 @@ declare namespace BABYLON {
         /** Whether backface culling is disabled ("CullingOff") */
         cullingOff: boolean;
         /** User-defined custom properties from Properties70 */
-        customProperties?: Record<string, string | number | boolean>;
+        customProperties?: Record<string, FBXUserPropertyValue>;
+        /** LOD group settings when this model is a LodGroup; children are the levels in order */
+        lodGroup?: FBXLodGroupData;
+        /** Display layer (CollectionExclusive) the model belongs to */
+        displayLayer?: FBXDisplayLayerData;
         /** Recoverable model import diagnostics */
         diagnostics: string[];
     }
+    /** LOD group settings (NodeAttribute "LodGroup") */
+    export interface FBXLodGroupData {
+        /** Switch distance for level i+1 (level 0 has none). In scene units, or percent of screen when `relative`. */
+        thresholds: number[];
+        /** ThresholdsUsedAsPercentage */
+        relative: boolean;
+        /** DisplayLevels|LevelN: 0 use LOD, 1 show, 2 hide */
+        displayLevels: number[];
+    }
+    /** Display layer (CollectionExclusive "DisplayLayer") */
+    export interface FBXDisplayLayerData {
+        id: number;
+        name: string;
+        show: boolean;
+        freeze: boolean;
+        color: [number, number, number];
+        modelIds: number[];
+    }
+    /** One member of a selection set: a model, optionally with a component selection on its mesh */
+    export interface FBXSelectionNodeData {
+        modelId: number;
+        /** IsTheNodeInSet: the whole node is selected (as opposed to only components) */
+        includeNode: boolean;
+        /** Selected control point indices (VertexIndexArray) */
+        vertices?: number[];
+        /** Selected edge indices (EdgeIndexArray) */
+        edges?: number[];
+        /** Selected polygon indices (PolygonIndexArray) */
+        faces?: number[];
+    }
+    /** Selection set (Collection "SelectionSet") */
+    export interface FBXSelectionSetData {
+        id: number;
+        name: string;
+        members: FBXSelectionNodeData[];
+    }
     /** Camera data extracted from FBX */
     export interface FBXCameraData {
         /** Model ID this camera is attached to */
         modelId: number;
+        /** NodeAttribute object ID (animation curves target this) */
+        attributeId: number;
         /** Camera name */
         name: string;
-        /** Field of view in degrees */
+        /** Vertical field of view in degrees */
         fieldOfView: number;
+        /** Horizontal field of view in degrees */
+        fieldOfViewX: number;
+        /** ApertureMode: 0 horizontal and vertical, 1 horizontal, 2 vertical, 3 focal length */
+        apertureMode: number;
+        /** Aperture (film gate after gate fit) size in inches */
+        apertureSizeInch: [number, number];
+        /** Orthographic view size (width, height) in scene units */
+        orthographicSize: [number, number];
         /** Near clip plane */
         nearPlane: number;
         /** Far clip plane */
@@ -24693,6 +27190,8 @@ declare namespace BABYLON {
         orthoZoom?: number;
         /** Camera roll in degrees when present */
         roll?: number;
+        /** User-defined properties on the camera attribute */
+        userProperties?: Record<string, FBXUserPropertyValue>;
         /** Known unsupported or unrecognized camera properties */
         unknownProperties: string[];
         /** Recoverable camera import diagnostics */
@@ -24702,6 +27201,8 @@ declare namespace BABYLON {
     export interface FBXLightData {
         /** Model ID this light is attached to */
         modelId: number;
+        /** NodeAttribute object ID (animation curves target this) */
+        attributeId: number;
         /** Light name */
         name: string;
         /** Light type: 0=Point, 1=Directional, 2=Spot */
@@ -24726,6 +27227,15 @@ declare namespace BABYLON {
         enableFarAttenuation?: boolean;
         /** Whether the source light requested shadow casting */
         castShadows?: boolean;
+        /** Near/far attenuation ranges in scene units (when enabled) */
+        nearAttenuationStart?: number;
+        nearAttenuationEnd?: number;
+        farAttenuationStart?: number;
+        farAttenuationEnd?: number;
+        /** Area light shape: 0 rectangle, 1 sphere */
+        areaLightShape?: number;
+        /** User-defined properties on the light attribute */
+        userProperties?: Record<string, FBXUserPropertyValue>;
         /** Known unsupported or unrecognized light properties */
         unknownProperties: string[];
         /** Recoverable light import diagnostics */
@@ -24737,6 +27247,8 @@ declare namespace BABYLON {
         rootModels: FBXModelData[];
         /** All geometries in the scene */
         geometries: FBXGeometryData[];
+        /** All curve geometries (lines and tessellated NURBS curves) */
+        curves: FBXCurveGeometryData[];
         /** All materials in the scene */
         materials: FBXMaterialData[];
         /** Skin deformers (skeletons + vertex weights) */
@@ -24753,6 +27265,12 @@ declare namespace BABYLON {
         lights: FBXLightData[];
         /** Scene-level unsupported feature diagnostics */
         diagnostics: FBXSceneDiagnostic[];
+        /** Constraints (aim, parent, position, rotation, scale, IK) */
+        constraints: FBXConstraintData[];
+        /** Display layers */
+        displayLayers: FBXDisplayLayerData[];
+        /** Selection sets */
+        selectionSets: FBXSelectionSetData[];
         /** Global settings */
         upAxis: number;
         upAxisSign: number;
@@ -24761,11 +27279,89 @@ declare namespace BABYLON {
         coordAxis: number;
         coordAxisSign: number;
         unitScaleFactor: number;
+        /** Scene frame rate derived from GlobalSettings TimeMode / CustomFrameRate */
+        frameRate: number;
     }
     /**
      * Interpret a parsed FBX document into scene data.
      */
-    export function interpretFBX(doc: FBXDocument): FBXSceneData;
+    /** Options controlling how the document is interpreted. */
+    export interface FBXInterpretOptions {
+        /** Segments per knot span when tessellating NURBS surfaces; defaults to the Step stored in the file */
+        nurbsSubdivision?: number;
+        /** Shift every clip so its first key sits at time 0 (default true); false keeps the authored times */
+        rebaseKeyframes?: boolean;
+    }
+    export function interpretFBX(doc: FBXDocument, options?: FBXInterpretOptions): FBXSceneData;
+
+
+    export type FBXConstraintType = "aim" | "parent" | "position" | "rotation" | "scale" | "singleChainIK" | "unknown";
+    export type Vec3 = [number, number, number];
+    export type Bool3 = [boolean, boolean, boolean];
+    /** One weighted target of a constraint. */
+    export interface FBXConstraintTarget {
+        /** Model id of the target node */
+        modelId: number;
+        /** Normalized weight (file value / 100, or as-is for IK pole targets) */
+        weight: number;
+        /** Parent constraint translation offset expressed in the target's space */
+        offsetTranslation: Vec3;
+        /** Parent constraint rotation offset in degrees, expressed in the target's space */
+        offsetRotation: Vec3;
+        /** Parent constraint scale offset expressed in the target's space */
+        offsetScale: Vec3;
+    }
+    /** A constraint object of the file, with its targets and parameters resolved. */
+    export interface FBXConstraintData {
+        /** Constraint object id */
+        id: number;
+        /** Constraint name */
+        name: string;
+        /** Resolved constraint kind */
+        type: FBXConstraintType;
+        /** Constraint type name as written in the file (e.g. "Parent-Child") */
+        typeName: string;
+        /** Constrained model */
+        nodeId?: number;
+        /** Weighted targets in file order */
+        targets: FBXConstraintTarget[];
+        /** Global weight (file value / 100) */
+        weight: number;
+        /** False when the constraint is switched off in the file */
+        active: boolean;
+        /** Which translation axes the constraint drives */
+        affectTranslation: Bool3;
+        /** Which rotation axes the constraint drives */
+        affectRotation: Bool3;
+        /** Which scale axes the constraint drives */
+        affectScale: Bool3;
+        /** Translation offset of the constrained node */
+        offsetTranslation: Vec3;
+        /** Rotation offset of the constrained node, in degrees */
+        offsetRotation: Vec3;
+        /** Scale offset of the constrained node */
+        offsetScale: Vec3;
+        /** Aim: local axis that points at the target */
+        aimVector: Vec3;
+        /** Aim: local axis aligned with the up direction */
+        upVector: Vec3;
+        /** Aim: world up direction (world up modes 2 and 3) */
+        worldUpVector: Vec3;
+        /** Aim: 0 scene up, 1 aim up node, 2 align to node, 3 vector, 4 none */
+        worldUpType: number;
+        /** Aim: model id of the world up object (world up modes 1 and 2) */
+        worldUpNodeId?: number;
+        /** Single chain IK: model id of the first joint of the chain */
+        ikFirstJointId?: number;
+        /** Single chain IK: model id of the last joint of the chain */
+        ikEndJointId?: number;
+        /** Single chain IK: model id of the effector */
+        ikEffectorId?: number;
+        /** Single chain IK: pole vector */
+        ikPoleVector: Vec3;
+    }
+    /** Reads every constraint object of the scene. */
+    export function extractConstraints(objectMap: FBXObjectMap): FBXConstraintData[];
 
 
     /** Connection type: OO = object-to-object, OP = object-to-property */
@@ -24788,7 +27384,7 @@ declare namespace BABYLON {
         /** Object node. */
         node: FBXNode;
         /** Source of the object entry. */
-        source: "Objects" | "legacySyntheticGeometry";
+        source: "Objects" | "legacySyntheticGeometry" | "legacySyntheticAttribute" | "legacySyntheticBlendShape";
         /** Legacy string object name, when applicable. */
         legacyName?: string;
         /** True if the object was synthesized for legacy compatibility. */
@@ -24909,7 +27505,23 @@ declare namespace BABYLON {
     export function extractBlendShapes(objectMap: FBXObjectMap): FBXBlendShapeData[];
 
 
+    /**
+     * FBX animation curve model and evaluator.
+     *
+     * Keys carry cubic Bezier tangents expressed the way the FBX SDK stores them: a left and right tangent with a time
+     * extent (dx, as a fraction of the segment scaled by the tangent weight) and a value extent (dy). Linear and constant
+     * segments are represented the same way so that a single evaluator handles every case, including the weighted
+     * tangents Maya and MotionBuilder write, TCB keys, and the pre/post extrapolation modes.
+     */
+    /** FBX time units: 46186158000 ticks per second */
+    export const FBX_TIME_UNIT = 46186158000;
     export type FBXInterpolationType = "constant" | "linear" | "cubic";
+    export type FBXExtrapolationMode = "constant" | "repeat" | "mirror" | "slope" | "repeatRelative";
+    export interface FBXExtrapolation {
+        mode: FBXExtrapolationMode;
+        /** Number of repetitions, or -1 for infinite */
+        repeatCount: number;
+    }
     /** A single keyframe */
     export interface FBXKeyframe {
         /** Time in seconds */
@@ -24920,9 +27532,15 @@ declare namespace BABYLON {
         interpolation: FBXInterpolationType;
         /** Constant interpolation variant */
         constantMode?: "standard" | "next";
-        /** Cubic outgoing slope in value units per second */
+        /** Left (incoming) tangent: time extent in seconds and value extent */
+        leftDx: number;
+        leftDy: number;
+        /** Right (outgoing) tangent: time extent in seconds and value extent */
+        rightDx: number;
+        rightDy: number;
+        /** Cubic outgoing slope in value units per second (derived, kept for consumers that export hermite keys) */
         rightSlope?: number;
-        /** Cubic incoming slope for the next key, in value units per second */
+        /** Cubic incoming slope for the next key, in value units per second (derived) */
         nextLeftSlope?: number;
     }
     /** An animation curve (one axis of one property) */
@@ -24933,7 +27551,53 @@ declare namespace BABYLON {
         keys: FBXKeyframe[];
         /** True for baked sample curves that should be connected as linear samples */
         isSampled?: boolean;
+        preExtrapolation?: FBXExtrapolation;
+        postExtrapolation?: FBXExtrapolation;
+    }
+    /** Raw key attribute data for one key, after run-length decoding. */
+    export interface FBXKeyAttributes {
+        flags: number;
+        data: [number, number, number, number];
+    }
+    /**
+     * Builds keyframes from parallel time/value arrays and their (run-length encoded) attributes, resolving every
+     * tangent mode the FBX SDK writes: user, broken, auto (with clamp / progressive clamp / time-independent flags and
+     * auto bias), TCB, weighted, linear and constant.
+     */
+    export function buildKeyframes(times: ArrayLike<number>, values: ArrayLike<number>, attributes: (index: number) => FBXKeyAttributes): FBXKeyframe[];
+    /** Auto tangent as the FBX SDK computes it, including clamping and auto bias. */
+    export function solveAutoTangent(prevTime: number, time: number, nextTime: number, prevValue: number, value: number, nextValue: number, weightLeft: number, weightRight: number, autoBias: number, flags: number): number;
+    /** Builds a keyframe list from explicit per-key slopes (legacy Takes and synthetic curves). */
+    export function keyframesFromSlopes(times: number[], values: number[], interpolation: FBXInterpolationType[], constantNext: boolean[], leftSlope: number[], rightSlope: number[], leftWeight?: number[], rightWeight?: number[]): FBXKeyframe[];
+    /** Reads a `Pre-Extrapolation` / `Post-Extrapolation` block: `Type` is a character code, `Repetition` a count. */
+    export function parseExtrapolation(typeValue: unknown, repetitionValue: unknown): FBXExtrapolation;
+    export function evaluateCurve(curve: FBXCurveData | undefined, time: number, defaultValue: number, noExtrapolation?: boolean): number;
+    export type Vec3 = [number, number, number];
+    export type Quat = [number, number, number, number];
+    /** Euler angles in degrees with an FBX rotation order (0=XYZ ... 5=ZYX; spheric falls back to XYZ) to a quaternion. */
+    export function eulerToQuat(v: Vec3, order: number): Quat;
+    /** Quaternion to Euler angles in degrees for an FBX rotation order (inverse of eulerToQuat). */
+    export function quatToEuler(q: Quat, order: number): Vec3;
+    /** Blend semantics of an animation layer, derived from its BlendMode and accumulation modes. */
+    export interface FBXLayerBlend {
+        /** Layer participates in blending (BlendMode Additive or Override Passthrough) */
+        blended: boolean;
+        /** Layer adds onto the result instead of replacing it (BlendMode Additive) */
+        additive: boolean;
+        /** Rotations compose as quaternions (RotationAccumulationMode ByLayer) */
+        composeRotation: boolean;
+        /** Scales compose multiplicatively (ScaleAccumulationMode Multiply) */
+        composeScale: boolean;
+        /** Layer weight in [0, 1] */
+        weight: number;
     }
+    /**
+     * Combines one animation layer's value into the running result, exactly as the FBX SDK evaluator does.
+     * `kind` selects the accumulation rule: "R" rotations (degrees, rotation order given), "S" scales, anything else linear.
+     */
+    export function combineLayerValue(result: Vec3, value: Vec3, layer: FBXLayerBlend, kind: "T" | "R" | "S" | "other", rotationOrder: number): Vec3;
+
+
     /** An animation curve node (T/R/S for one bone) */
     export interface FBXCurveNodeData {
         /** Property type: "T" (translation), "R" (rotation), "S" (scale) */
@@ -24942,13 +27606,19 @@ declare namespace BABYLON {
         targetModelId: number;
         /** Curves for each axis */
         curves: FBXCurveData[];
+        /** Index of the owning layer within the stack's layer list */
+        layerIndex: number;
+        /** Default channel values (`d|X`, `d|Y`, `d|Z`) used for channels without a curve */
+        defaultValues?: [number, number, number];
     }
-    /** Unsupported animation curve node preserved for diagnostics and future support. */
+    /** Non-transform animation curve node (property animation), evaluated by the loader when a Babylon mapping exists. */
     export interface FBXUnsupportedCurveNodeData {
         /** Raw AnimationCurveNode property type/name */
         type: string;
         /** CurveNode object ID */
         id: number;
+        /** Index of the owning layer within the stack's layer list */
+        layerIndex: number;
         /** Target object ID if the curve node is connected to an object/property */
         targetId: number | null;
         /** OP connection property name on the target, e.g. Visibility */
@@ -24987,6 +27657,10 @@ declare namespace BABYLON {
         normalizedWeight: number;
         /** Blend mode: 0=Additive, 1=Override, 2=OverridePassthrough */
         blendMode: number;
+        /** Resolved blend semantics used by the evaluator */
+        blend: FBXLayerBlend;
+        /** Animated layer weight (0-100), when the Weight property carries a curve */
+        weightCurve?: FBXCurveData;
         /** Curve nodes in this layer */
         curveNodes: FBXCurveNodeData[];
         /** Unsupported/non-TRS curve nodes preserved for diagnostics */
@@ -24994,6 +27668,14 @@ declare namespace BABYLON {
         /** Recoverable layer diagnostics */
         diagnostics: FBXAnimationDiagnostic[];
     }
+    /** Options for animation extraction. */
+    export interface FBXAnimationExtractOptions {
+        /**
+         * Shift each clip so its first key sits at time 0 (default true). False keeps the times authored in the file, so
+         * clips of one file stay aligned with each other and with the declared stack range.
+         */
+        rebaseKeyframes?: boolean;
+    }
     /** One animation clip (AnimationStack) */
     export interface FBXAnimationStackData {
         /** Animation name */
@@ -25016,13 +27698,7 @@ declare namespace BABYLON {
     /**
      * Extract all animation stacks from the FBX scene.
      */
-    export function extractAnimations(objectMap: FBXObjectMap): FBXAnimationStackData[];
-    /**
-     * Determines whether a key sequence appears to be a uniformly frame-baked sampled curve.
-     * @param keys - Keyframes to inspect
-     * @returns true if the keys look like sampled frame data rather than authored interpolation
-     */
-    export function isFrameBakedSampledCurve(keys: readonly FBXKeyframe[]): boolean;
+    export function extractAnimations(objectMap: FBXObjectMap, doc?: FBXDocument, options?: FBXAnimationExtractOptions): FBXAnimationStackData[];
     /**
      * Samples an FBX animation curve at a specific time.
      * @param curveData - Curve data to sample
@@ -25030,6 +27706,54 @@ declare namespace BABYLON {
      * @returns The sampled value, or null when the curve has no keys
      */
     export function sampleFBXCurveAtTime(curveData: FBXCurveData | undefined, time: number): number | null;
+    /**
+     * Pre-7000 files store animation in a top-level `Takes` block instead of AnimationStack/Layer/CurveNode objects:
+     *
+     *   Takes: { Take: "name" { LocalTime: start, stop
+     *     Model: "Model::joint1" { Channel: "Transform" { Channel: "T" { Channel: "X" { Default, KeyVer, KeyCount, Key } } } } } }
+     *
+     * Each take becomes one animation stack with a single layer. Models are matched through the same legacy string ids
+     * that the connection resolver synthesizes for 6.x objects.
+     */
+    export function extractLegacyTakes(doc: FBXDocument, objectMap: FBXObjectMap, rebaseKeyframes?: boolean): FBXAnimationStackData[];
+    /**
+     * Evaluates one transform channel (T, R or S) of a target at `time`, blending every animation layer of the stack the
+     * way the FBX SDK does: the first layer animating the channel replaces the static value, later layers are combined
+     * according to their blend mode, weight and accumulation modes.
+     * @param curveNodes - Curve nodes targeting this model (any layers, any types)
+     * @param layers - Stack layers, in order
+     * @param type - Channel to evaluate
+     * @param staticValue - Value when nothing animates the channel
+     * @param rotationOrder - Rotation order of the target (for rotation composition)
+     * @param time - Time in seconds
+     */
+    export function evaluateLayeredChannel(curveNodes: readonly FBXCurveNodeData[], layers: readonly FBXAnimationLayerData[], type: "T" | "R" | "S", staticValue: readonly [number, number, number], rotationOrder: number, time: number): [number, number, number];
+    /** Curves of one animated property (or blend shape weight) contributed by one animation layer. */
+    export interface FBXLayeredPropertySource {
+        /** Index of the owning layer within the stack's layer list */
+        layerIndex: number;
+        /** Curves of the property, keyed by channel name (`d|X`, `d|DeformPercent`, ...) */
+        curves: readonly FBXCurveData[];
+        /** Default channel values stored on the curve node */
+        defaultValues?: Record<string, number>;
+    }
+    /**
+     * Evaluates an animated property through the animation layers: the base layer replaces the static value, every
+     * further layer blends onto the running result according to its blend mode and (possibly animated) weight, like
+     * `evaluateLayeredChannel` does for transforms.
+     * @param sources - Per-layer curves of the property
+     * @param layers - Stack layers, in order
+     * @param channels - Channel names to evaluate, in output order
+     * @param staticValue - Value per channel when nothing animates it
+     * @param time - Time in seconds
+     * @returns One value per channel
+     */
+    export function evaluateLayeredProperty(sources: readonly FBXLayeredPropertySource[], layers: readonly FBXAnimationLayerData[], channels: readonly string[], staticValue: readonly number[], time: number): number[];
+    /**
+     * True when every curve of the given channel is inside a constant (stepped) segment at `time`, so a baked key at
+     * that time should hold its value instead of interpolating towards the next sample.
+     */
+    export function isChannelSteppedAt(curveNodes: readonly FBXCurveNodeData[], type: "T" | "R" | "S", time: number): boolean;
 
 
     /** Pure barrel — re-exports only side-effect-free modules */