babylonjs-loaders 9.25.0 → 9.26.1

package/babylonjs.loaders.d.ts

@@ -8878,6 +8878,424 @@ declare namespace BABYLON.GLTF1 {
 }
 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 RegisterUSDFileLoader(): void;
+
+
+    /**
+     * 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;
+            };
+        };
+    };
+
+
+    /**
+     * Re-exports the pure implementation and applies the runtime registration side effect.
+     * 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 */
+
+
+
+
         interface SceneLoaderPluginOptions {
             /**
              * Defines options for the stl loader.
@@ -9846,6 +10264,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}.
      */
@@ -9965,6 +10395,7 @@ declare namespace BABYLON {
         private readonly _rootUrl;
         private readonly _streamOptions;
         private readonly _leafNodes;
+        private _lod0SplatCount;
         private _lodBaseDistance;
         private _lodMultiplier;
         private _lodBehindPenalty;
@@ -10129,6 +10560,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).
@@ -10298,6 +10742,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.
@@ -11455,12 +11904,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.
@@ -11483,6 +12003,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
@@ -11525,6 +12061,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;
@@ -11536,6 +12077,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.
@@ -11559,6 +12109,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;
@@ -11582,11 +12137,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;
@@ -11603,13 +12174,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;
@@ -11619,9 +12185,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
@@ -11656,6 +12274,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.
@@ -11670,6 +12471,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 {
@@ -11696,11 +12502,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;
     /**
@@ -11828,25 +12645,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";
@@ -11905,6 +12706,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 */
@@ -11914,6 +12869,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];
@@ -11949,11 +12908,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 */
@@ -11966,7 +13016,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. */
@@ -12017,8 +13067,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 */
@@ -12050,18 +13102,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 */
@@ -12080,6 +13182,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 */
@@ -12089,6 +13193,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 */
@@ -12113,6 +13219,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 */
@@ -12124,6 +13239,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) */
@@ -12140,6 +13257,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;
@@ -12148,11 +13271,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 */
@@ -12175,7 +13376,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. */
@@ -12296,7 +13497,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 */
@@ -12307,9 +13524,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) */
@@ -12320,7 +13543,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) */
@@ -12329,13 +13598,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 */
@@ -12374,6 +13649,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 */
@@ -12381,6 +13660,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 */
@@ -12403,13 +13690,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
@@ -12417,6 +13698,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 */