babylonjs-loaders 9.26.0 → 9.26.2

package/babylonjs.loaders.module.d.ts

@@ -2946,8 +2946,9 @@ export interface IGLTFLoaderExtension extends IGLTFBaseLoaderExtension, IDisposa
     onLoading?(): void;
     /**
      * Called after the loader state changes to READY.
+     * @returns a promise when the extension has asynchronous readiness work
      */
-    onReady?(): void;
+    onReady?(): void | Promise<void>;
     /**
      * Define this method to modify the default behavior when loading scenes.
      * @param context The context when loading the asset
@@ -3548,7 +3549,7 @@ export class GLTFLoader implements IGLTFLoader {
     private _forEachExtensions;
     private _applyExtensions;
     private _extensionsOnLoading;
-    private _extensionsOnReady;
+    private _extensionsOnReadyAsync;
     private _extensionsLoadSceneAsync;
     private _extensionsLoadNodeAsync;
     private _extensionsLoadCameraAsync;
@@ -4237,9 +4238,10 @@ export interface IGLTFObjectModelTreeExtensionsObject {
 /**
  * get a path-to-object converter for the given glTF tree
  * @param gltf the glTF tree to use
+ * @param configure optional callback for adding asset-local accessors to this converter
  * @returns a path-to-object converter for the given glTF tree
  */
-export function GetPathToObjectConverter(gltf: IGLTF): GLTFPathToObjectConverter<unknown, unknown, unknown>;
+export function GetPathToObjectConverter(gltf: IGLTF, configure?: (mapping: object) => void): GLTFPathToObjectConverter<unknown, unknown, unknown>;
 /**
  * This function will return the object accessor for the given key in the object model
  * If the key is not found, it will return undefined
@@ -4258,8 +4260,9 @@ export function SetInterpolationForKey(key: string, interpolation?: IInterpolati
  * Note that this will NOT change the typescript types. To do that you will need to change the interface itself (extending it in the module that uses it)
  * @param key the key to add the object accessor at. For example /cameras/\{\}/perspective/aspectRatio
  * @param accessor the object accessor to add
+ * @param mapping object-model mapping to update; defaults to the process-wide mapping used as the template for new converters
  */
-export function AddObjectAccessorToKey<GLTFTargetType = any, BabylonTargetType = any, BabylonValueType = any>(key: string, accessor: IObjectAccessor<GLTFTargetType, BabylonTargetType, BabylonValueType>): void;
+export function AddObjectAccessorToKey<GLTFTargetType = any, BabylonTargetType = any, BabylonValueType = any>(key: string, accessor: IObjectAccessor<GLTFTargetType, BabylonTargetType, BabylonValueType>, mapping?: object): void;
 export {};
 
 }
@@ -5173,6 +5176,8 @@ export class KHR_node_selectability implements IGLTFLoaderExtension {
      * The name of this extension.
      */
     readonly name: string;
+    /** Applies node state before KHR_interactivity graphs start. */
+    readonly order: number;
     /**
      * Defines whether this extension is enabled.
      */
@@ -5230,6 +5235,8 @@ export class KHR_node_hoverability implements IGLTFLoaderExtension {
      * The name of this extension.
      */
     readonly name: string;
+    /** Applies node state before KHR_interactivity graphs start. */
+    readonly order: number;
     /**
      * Defines whether this extension is enabled.
      */
@@ -6615,7 +6622,24 @@ module "babylonjs-loaders/glTF/glTFFileLoader" {
         /**
          * Defines options for the KHR_interactivity extension.
          */
-        ["KHR_interactivity"]: {};
+        ["KHR_interactivity"]: {
+            /**
+             * Whether the selected default graph starts automatically after import.
+             * Defaults to true.
+             */
+            autoStart?: boolean;
+            /**
+             * Whether to retain only the canonical source model and executable
+             * FlowGraph serialization without constructing runtime graphs.
+             * Defaults to false.
+             */
+            parseOnly?: boolean;
+            /**
+             * Whether to enforce the ratified graph validation rules.
+             * Defaults to true. Set to false only for pre-ratification assets.
+             */
+            strictValidation?: boolean;
+        };
     }
 }
 
@@ -6623,7 +6647,58 @@ module "babylonjs-loaders/glTF/glTFFileLoader" {
 declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity.pure" {
 import { GLTFLoader } from "babylonjs-loaders/glTF/2.0/glTFLoader.pure";
 import { IGLTFLoaderExtension } from "babylonjs-loaders/glTF/2.0/glTFLoaderExtension";
+import { FlowGraphCoordinator } from "babylonjs/FlowGraph/flowGraphCoordinator";
 import { Scene } from "babylonjs/scene";
+import { CompositePathToObjectConverter } from "babylonjs-loaders/glTF/2.0/Extensions/compositePathToObjectConverter";
+import { InteractivityHostResolver } from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityHostResolver";
+import { IObjectAccessor, ISerializedFlowGraph } from "babylonjs/FlowGraph/typeDefinitions";
+import { IKHRInteractivityDiagnostic, IKHRInteractivityDocument, IKHRInteractivityGraphModel } from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphModel";
+import { FlowGraph } from "babylonjs/FlowGraph/flowGraph";
+/**
+ * Runtime projection of one canonical KHR_interactivity graph.
+ */
+export interface IKHRInteractivityGraphImportResult {
+    /** Canonical source graph and diagnostics. */
+    graph: IKHRInteractivityGraphModel;
+    /** Executable FlowGraph serialization when lowering succeeded. */
+    serializedFlowGraph?: ISerializedFlowGraph;
+    /** Runtime FlowGraph when runtime construction was requested. */
+    flowGraph?: FlowGraph;
+    /** Coordinator that owns the runtime FlowGraph. */
+    coordinator?: FlowGraphCoordinator;
+    /** Additional lowering/runtime diagnostics. */
+    diagnostics: IKHRInteractivityDiagnostic[];
+}
+/**
+ * Completed KHR_interactivity import result associated with a loaded scene.
+ */
+export interface IKHRInteractivityImportResult {
+    /** Stable zero-based identity of this interactivity asset among assets appended to the scene. */
+    assetIndex: number;
+    /** Canonical, lossless source document. */
+    document: IKHRInteractivityDocument;
+    /** Graph import results in source order. */
+    graphs: IKHRInteractivityGraphImportResult[];
+    /** Shared path converter required by pointer blocks. */
+    pathConverter: CompositePathToObjectConverter<IObjectAccessor>;
+    /** Live glTF loader data used by glTF data-provider blocks. */
+    glTF: GLTFLoader["gltf"];
+    /** Host resolver that supplies KHR reference semantics to executable graphs. */
+    hostResolver: InteractivityHostResolver;
+}
+/**
+ * Gets the completed KHR_interactivity import result for a loaded scene.
+ * @param scene scene loaded from the glTF asset
+ * @returns the import result, or undefined when the scene has no KHR_interactivity data
+ */
+export function GetKHRInteractivityImportResult(scene: Scene): IKHRInteractivityImportResult | undefined;
+/**
+ * Gets every completed KHR_interactivity import result appended to a loaded scene.
+ * Results remain in asset load order and each result has a stable {@link IKHRInteractivityImportResult.assetIndex}.
+ * @param scene scene containing the loaded glTF assets
+ * @returns the scene's import results, or an empty array when it has no KHR_interactivity data
+ */
+export function GetKHRInteractivityImportResults(scene: Scene): readonly IKHRInteractivityImportResult[];
 /**
  * Loader extension for KHR_interactivity
  */
@@ -6633,6 +6708,8 @@ export class KHR_interactivity implements IGLTFLoaderExtension {
      * The name of this extension.
      */
     readonly name: string;
+    /** Runs after extensions that contribute interactivity operations and object state. */
+    readonly order: number;
     /**
      * Defines whether this extension is enabled.
      */
@@ -6644,6 +6721,7 @@ export class KHR_interactivity implements IGLTFLoaderExtension {
      * @param _loader
      */
     constructor(_loader: GLTFLoader);
+    private _initializePathConverter;
     dispose(): void;
     onReady(): Promise<void>;
 }
@@ -6651,7 +6729,7 @@ export class KHR_interactivity implements IGLTFLoaderExtension {
  * @internal
  * populates the object model with the interactivity extension
  */
-export function _AddInteractivityObjectModel(scene: Scene): void;
+export function _AddInteractivityObjectModel(scene: Scene, targetFps: number, mapping: object): void;
 /**
  * @internal
  * Registers KHR_interactivity runtime dependencies without changing the extension registry.
@@ -7380,6 +7458,11 @@ declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/pure" {
 export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/declarationMapper";
 export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphParser";
 export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphGLTFDataProvider";
+export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphEventReferenceBlock";
+export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphObjectReferenceBlock";
+export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphUnsupportedInteractivityBlock";
+export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphModel";
+export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityNodeState";
 
 }
 declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityReferences" {
@@ -7428,6 +7511,33 @@ export function GetEventReferenceKey(reference: string): string | undefined;
  */
 export function IsEventReference(value: unknown): value is string;
 
+}
+declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityNodeState" {
+import { INode } from "babylonjs-loaders/glTF/2.0/glTFLoaderInterfaces";
+type InteractivityNodeState = "hoverable" | "selectable";
+/**
+ * Initializes authored and inherited selectability or hoverability state.
+ * @param nodes all nodes in the glTF asset
+ * @param state state kind to initialize
+ * @param getAuthoredState reads the extension-authored local state
+ */
+export function InitializeInteractivityNodeState(nodes: readonly INode[], state: InteractivityNodeState, getAuthoredState: (node: INode) => boolean | undefined): void;
+/**
+ * Gets the locally authored runtime state for a node.
+ * @param node glTF node
+ * @param state state kind
+ * @returns local state, defaulting to true
+ */
+export function GetInteractivityNodeState(node: INode, state: InteractivityNodeState): boolean;
+/**
+ * Updates local state and reapplies inherited state to the affected subtree.
+ * @param node glTF node
+ * @param state state kind
+ * @param value new local state
+ */
+export function SetInteractivityNodeState(node: INode, state: InteractivityNodeState, value: boolean): void;
+export {};
+
 }
 declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityHostResolver" {
 import { IFlowGraphHostResolver } from "babylonjs/FlowGraph/flowGraphHostResolver";
@@ -7450,9 +7560,10 @@ export class InteractivityHostResolver implements IFlowGraphHostResolver {
     decodeEventReference(reference: string): string | undefined;
     /**
      * @param reference the reference to decode
+     * @param collection optional glTF root collection the reference must address
      * @returns the index the reference denotes, or `undefined` when it is not an indexed JSON Pointer
      */
-    decodeIndexReference(reference: string): number | undefined;
+    decodeIndexReference(reference: string, collection?: string): number | undefined;
     /**
      * Maps a Babylon object loaded from the glTF back to a JSON Pointer addressing it.
      *
@@ -7475,6 +7586,7 @@ import { IGLTF } from "babylonjs-loaders/glTF/2.0/glTFLoaderInterfaces";
 import { IGLTFToFlowGraphMapping } from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/declarationMapper";
 import { ISerializedFlowGraph, ISerializedFlowGraphBlock } from "babylonjs/FlowGraph/typeDefinitions";
 import { FlowGraphTypes } from "babylonjs/FlowGraph/flowGraphRichTypes";
+import { IKHRInteractivityDeclarationModel } from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphModel";
 /**
  * Description of a KHR_interactivity custom event, as parsed from the
  * glTF `events` array. Used by the importer to register the event with the
@@ -7496,13 +7608,7 @@ export interface InteractivityEvent {
         value?: any;
     }[];
 }
-export const gltfTypeToBabylonType: {
-    [key: string]: {
-        length: number;
-        flowGraphType: FlowGraphTypes;
-        elementType: "number" | "boolean" | "string";
-    };
-};
+export { gltfTypeToBabylonType } from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphModel";
 /**
  * Parses a KHR_interactivity graph definition (the raw glTF JSON object) into
  * the serialized FlowGraph form consumed by {@link ParseFlowGraphAsync}.
@@ -7512,9 +7618,11 @@ export const gltfTypeToBabylonType: {
  * {@link serializeToFlowGraph}.
  */
 export class InteractivityGraphToFlowGraphParser {
-    private _interactivityGraph;
     private _gltf;
     _animationTargetFps: number;
+    private _graphIndex;
+    private _supportedExtensions?;
+    private _declarationModels?;
     /**
      * Note - the graph should be rejected if the same type is defined twice.
      * We currently don't validate that.
@@ -7532,16 +7640,22 @@ export class InteractivityGraphToFlowGraphParser {
      * the last block) is not disturbed, then concatenated into the serialized graph.
      */
     private _insertedBlocks;
-    constructor(_interactivityGraph: IKHRInteractivity_Graph, _gltf: IGLTF, _animationTargetFps?: number);
+    constructor(interactivityGraph: IKHRInteractivity_Graph, _gltf: IGLTF, _animationTargetFps?: number, _graphIndex?: number, _supportedExtensions?: ReadonlySet<string> | undefined, _declarationModels?: readonly IKHRInteractivityDeclarationModel[] | undefined);
+    private _interactivityGraph;
+    private get _strictValidation();
+    private _hasDefaultFlowInput;
+    private _getAllowedDynamicValueSockets;
+    private _getAllowedDynamicFlowSockets;
     get arrays(): {
         types: {
             length: number;
             flowGraphType: FlowGraphTypes;
-            elementType: "number" | "boolean" | "string";
+            elementType: "number" | "boolean" | "string" | "any";
         }[];
         mappings: {
             flowGraphMapping: IGLTFToFlowGraphMapping;
             fullOperationName: string;
+            declaration: IKHRInteractivityDeclarationModel;
         }[];
         staticVariables: {
             type: FlowGraphTypes;
@@ -7557,12 +7671,15 @@ export class InteractivityGraphToFlowGraphParser {
     private _parseDeclarations;
     private _parseVariables;
     private _parseVariable;
+    private _normalizeStaticReference;
     private _parseEvents;
     private _parseNodes;
     private _getEmptyBlock;
+    private _createUnsupportedExtensionBlock;
     private _parseNodeConfiguration;
     private _parseNodeConnections;
     private _createNewSocketConnection;
+    private _isUnsupportedExtensionBlock;
     /**
      * Wires an upstream data output into a downstream data input through a runtime multiply block that
      * scales the value by the animation target fps. This converts a KHR animation time (seconds),
@@ -7572,6 +7689,8 @@ export class InteractivityGraphToFlowGraphParser {
      * @param context the serialized flow graph context that stores literal socket values
      * @param upstreamOutput the data output socket providing the time value (in seconds)
      * @param downstreamInput the data input socket that expects the time in frames
+     * @param nodeIndex source node receiving the converted value
+     * @param declarationIndex source declaration used by the receiving node
      */
     private _connectWithSecondsToFramesConversion;
     private _connectFlowGraphNodes;
@@ -7591,11 +7710,202 @@ export class InteractivityGraphToFlowGraphParser {
     serializeToFlowGraph(): ISerializedFlowGraph;
 }
 
+}
+declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphModel" {
+import { IKHRInteractivity, IKHRInteractivity_Declaration, IKHRInteractivity_Graph } from "babylonjs-gltf2interface";
+import { FlowGraphTypes } from "babylonjs/FlowGraph/flowGraphRichTypes";
+/**
+ * Ratified KHR_interactivity specification baseline used by this importer.
+ */
+export const KHR_INTERACTIVITY_SPECIFICATION_COMMIT = "f798712c5685bc9223a628140fba707db8889300";
+/**
+ * Runtime representation of every ratified built-in KHR_interactivity type.
+ */
+export const gltfTypeToBabylonType: {
+    [key: string]: {
+        length: number;
+        flowGraphType: FlowGraphTypes;
+        elementType: "number" | "boolean" | "string" | "any";
+    };
+};
+/**
+ * Classification of a KHR_interactivity declaration.
+ */
+export type KHRInteractivityDeclarationSupport = "core" | "extension" | "unsupported-extension" | "unknown-core";
+/**
+ * A structured KHR_interactivity import diagnostic.
+ */
+export interface IKHRInteractivityDiagnostic {
+    /** JSON pointer identifying the source location. */
+    path: string;
+    /** Human-readable diagnostic text. */
+    message: string;
+    /** Diagnostic severity. */
+    severity: "error" | "warning";
+}
+/**
+ * Canonical declaration information retained during import.
+ */
+export interface IKHRInteractivityDeclarationModel {
+    /** Declaration index in the source graph. */
+    index: number;
+    /** Full operation name, including the defining extension when present. */
+    operation: string;
+    /** Whether Babylon can execute the declaration. */
+    support: KHRInteractivityDeclarationSupport;
+    /** Exact source declaration. */
+    source: IKHRInteractivity_Declaration;
+}
+/**
+ * Canonical graph information retained during import.
+ */
+export interface IKHRInteractivityGraphModel {
+    /** Graph index in the root extension. */
+    index: number;
+    /** Stable source path. */
+    path: string;
+    /** Human-readable graph name. */
+    name: string;
+    /** Exact source graph, including extension and extras payloads. */
+    source: IKHRInteractivity_Graph;
+    /** Executable graph with specification defaults and fallbacks applied. */
+    effectiveSource: IKHRInteractivity_Graph;
+    /** Canonical declarations in source order. */
+    declarations: IKHRInteractivityDeclarationModel[];
+    /** Validation diagnostics for this graph. */
+    diagnostics: IKHRInteractivityDiagnostic[];
+    /** Whether this graph is valid and can be lowered to FlowGraph. */
+    valid: boolean;
+}
+/**
+ * Lossless canonical representation of a KHR_interactivity root extension.
+ */
+export interface IKHRInteractivityDocument {
+    /** Ratified specification revision used for validation. */
+    specificationCommit: string;
+    /** Exact source extension, including unknown extensions and extras. */
+    source: IKHRInteractivity;
+    /** Default graph index, or -1 when the source selection is invalid. */
+    defaultGraphIndex: number;
+    /** Canonical graph models in source order. */
+    graphs: IKHRInteractivityGraphModel[];
+    /** Root-level validation diagnostics. */
+    diagnostics: IKHRInteractivityDiagnostic[];
+}
+/**
+ * Creates a detached JSON copy of a KHR_interactivity graph.
+ * @param graph source graph
+ * @returns a lossless JSON copy
+ */
+export function CloneKHRInteractivityGraph(graph: IKHRInteractivity_Graph): IKHRInteractivity_Graph;
+/**
+ * Creates the executable graph view with all ratified configuration defaults and fallback rules
+ * applied without modifying the lossless source graph.
+ * @param graph source graph
+ * @param declarations canonical declarations
+ * @param assetNodeCount number of glTF nodes in the containing asset
+ * @returns normalized executable graph
+ */
+export function CreateEffectiveKHRInteractivityGraph(graph: IKHRInteractivity_Graph, declarations: readonly IKHRInteractivityDeclarationModel[], assetNodeCount?: number): IKHRInteractivity_Graph;
+/**
+ * Creates and validates a canonical copy of one KHR_interactivity graph.
+ * @param graph source graph
+ * @param index graph index in the root extension
+ * @param supportedExtensions enabled extensions that may provide executable operations
+ * @param assetNodeCount number of nodes in the containing glTF asset
+ * @returns the canonical graph model
+ */
+export function CreateKHRInteractivityGraphModel(graph: IKHRInteractivity_Graph | null | undefined, index?: number, supportedExtensions?: ReadonlySet<string>, assetNodeCount?: number): IKHRInteractivityGraphModel;
+/**
+ * Creates an immutable canonical KHR_interactivity document and validates all graph-local references.
+ * @param extension source extension object from the glTF document
+ * @param supportedExtensions enabled extensions that may provide executable operations
+ * @param assetNodeCount number of nodes in the containing glTF asset
+ * @returns the canonical document
+ */
+export function CreateKHRInteractivityDocument(extension: IKHRInteractivity, supportedExtensions?: ReadonlySet<string>, assetNodeCount?: number): IKHRInteractivityDocument;
+
 }
 declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/index" {
 export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/declarationMapper";
 export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphParser";
 export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphGLTFDataProvider";
+export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphEventReferenceBlock";
+export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphObjectReferenceBlock";
+export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphUnsupportedInteractivityBlock";
+export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphModel";
+export * from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityNodeState";
+
+}
+declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphUnsupportedInteractivityBlock" {
+import { FlowGraphExecutionBlock } from "babylonjs/FlowGraph/flowGraphExecutionBlock";
+import { IFlowGraphBlockConfiguration } from "babylonjs/FlowGraph/flowGraphBlock";
+import { FlowGraphContext } from "babylonjs/FlowGraph/flowGraphContext";
+import { FlowGraphSignalConnection } from "babylonjs/FlowGraph/flowGraphSignalConnection.pure";
+/**
+ * Socket definition retained for an unsupported extension operation.
+ */
+export interface IFlowGraphUnsupportedInteractivitySocket {
+    /** Socket name. */
+    name: string;
+    /** FlowGraph runtime type name. */
+    type?: string;
+    /** Exact KHR_interactivity type signature. */
+    signature?: string;
+}
+/**
+ * Configuration for an unsupported KHR_interactivity extension operation.
+ */
+export interface IFlowGraphUnsupportedInteractivityBlockConfiguration extends IFlowGraphBlockConfiguration {
+    /** Full extension operation name. */
+    operation: string;
+    /** Input value sockets declared by the extension. */
+    inputValueSockets: IFlowGraphUnsupportedInteractivitySocket[];
+    /** Output value sockets declared by the extension. */
+    outputValueSockets: IFlowGraphUnsupportedInteractivitySocket[];
+    /** Input flow sockets used by the source graph. */
+    inputFlowSockets: string[];
+    /** Output flow sockets used by the source graph. */
+    outputFlowSockets: string[];
+}
+/**
+ * Inspectable runtime no-op for an operation owned by an unsupported glTF extension.
+ */
+export class FlowGraphUnsupportedInteractivityBlock extends FlowGraphExecutionBlock {
+    config: IFlowGraphUnsupportedInteractivityBlockConfiguration;
+    constructor(config: IFlowGraphUnsupportedInteractivityBlockConfiguration);
+    /** @internal */
+    _execute(_context: FlowGraphContext, _callingSignal: FlowGraphSignalConnection): void;
+    /** @returns the serialized class name */
+    getClassName(): string;
+}
+
+}
+declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphObjectReferenceBlock" {
+import { FlowGraphBlock, IFlowGraphBlockConfiguration } from "babylonjs/FlowGraph/flowGraphBlock";
+import { FlowGraphContext } from "babylonjs/FlowGraph/flowGraphContext";
+import { FlowGraphDataConnection } from "babylonjs/FlowGraph/flowGraphDataConnection.pure";
+/**
+ * Resolves a runtime object to its owning glTF node reference.
+ * @param context active FlowGraph context
+ * @param value runtime object, usually a picked primitive
+ * @returns the owning node reference or the null reference
+ */
+export function GetInteractivityObjectReference(context: FlowGraphContext, value: object | undefined): string;
+/**
+ * Converts a runtime object into the opaque reference used by KHR_interactivity.
+ */
+export class FlowGraphObjectReferenceBlock extends FlowGraphBlock {
+    /** Runtime object to encode. */
+    readonly object: FlowGraphDataConnection<object | undefined>;
+    /** Opaque KHR_interactivity reference. */
+    readonly value: FlowGraphDataConnection<string>;
+    constructor(config?: IFlowGraphBlockConfiguration);
+    /** @internal */
+    _updateOutputs(context: FlowGraphContext): void;
+    /** @returns the serialized class name */
+    getClassName(): string;
+}
 
 }
 declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphGLTFDataProvider" {
@@ -7611,7 +7921,7 @@ export interface IFlowGraphGLTFDataProviderBlockConfiguration extends IFlowGraph
     /**
      * the glTF object to provide data from
      */
-    glTF: IGLTF;
+    glTF?: IGLTF;
 }
 /**
  * a glTF-based FlowGraph block that provides arrays with babylon object, based on the glTF tree
@@ -7628,7 +7938,57 @@ export class FlowGraphGLTFDataProvider extends FlowGraphBlock {
      * Corresponds directly to the glTF nodes array
      */
     readonly nodes: FlowGraphDataConnection<TransformNode[]>;
-    constructor(config: IFlowGraphGLTFDataProviderBlockConfiguration);
+    constructor(config?: IFlowGraphGLTFDataProviderBlockConfiguration);
+    getClassName(): string;
+}
+
+}
+declare module "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/flowGraphEventReferenceBlock" {
+import { IFlowGraphBlockConfiguration } from "babylonjs/FlowGraph/flowGraphBlock";
+import { FlowGraphContext } from "babylonjs/FlowGraph/flowGraphContext";
+import { FlowGraphDataConnection } from "babylonjs/FlowGraph/flowGraphDataConnection.pure";
+import { FlowGraphExecutionBlock } from "babylonjs/FlowGraph/flowGraphExecutionBlock";
+import { Vector3 } from "babylonjs/Maths/math.vector.pure";
+import { FlowGraphSignalConnection } from "babylonjs/FlowGraph/flowGraphSignalConnection.pure";
+/**
+ * Configuration for a KHR event reference output.
+ */
+export interface IFlowGraphEventReferenceBlockConfiguration extends IFlowGraphBlockConfiguration {
+    /** Stable key shared by equivalent event operations. */
+    eventKey?: string;
+}
+/**
+ * Produces the opaque reference associated with a KHR event operation.
+ */
+export class FlowGraphEventReferenceBlock extends FlowGraphExecutionBlock {
+    config: IFlowGraphEventReferenceBlockConfiguration;
+    private readonly _assetInverse;
+    private readonly _selectionPointValue;
+    private readonly _selectionRayOriginValue;
+    /** Output flow activated after event values are captured. */
+    readonly out: FlowGraphSignalConnection;
+    /** Runtime node associated with the event. */
+    readonly node: FlowGraphDataConnection<object | undefined>;
+    /** Controller index associated with the event. */
+    readonly controllerIndexInput: FlowGraphDataConnection<number>;
+    /** Selection point associated with the event. */
+    readonly selectionPointInput: FlowGraphDataConnection<Vector3>;
+    /** Selection ray origin associated with the event. */
+    readonly selectionRayOriginInput: FlowGraphDataConnection<Vector3>;
+    /** Opaque node reference. */
+    readonly nodeReference: FlowGraphDataConnection<string>;
+    /** Retained controller index. */
+    readonly controllerIndex: FlowGraphDataConnection<number>;
+    /** Retained selection point. */
+    readonly selectionPoint: FlowGraphDataConnection<Vector3>;
+    /** Retained selection ray origin. */
+    readonly selectionRayOrigin: FlowGraphDataConnection<Vector3>;
+    /** Opaque event reference. */
+    readonly value: FlowGraphDataConnection<string>;
+    constructor(config: IFlowGraphEventReferenceBlockConfiguration);
+    /** @internal */
+    _execute(context: FlowGraphContext): void;
+    /** @returns the serialized class name */
     getClassName(): string;
 }
 
@@ -7639,11 +7999,21 @@ import { FlowGraphBlockNames } from "babylonjs/FlowGraph/Blocks/flowGraphBlockNa
 import { ISerializedFlowGraphBlock, ISerializedFlowGraphContext } from "babylonjs/FlowGraph/typeDefinitions";
 import { InteractivityGraphToFlowGraphParser } from "babylonjs-loaders/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphParser";
 import { IGLTF } from "babylonjs-loaders/glTF/2.0/glTFLoaderInterfaces";
-interface IGLTFToFlowGraphMappingObject {
+/**
+ * Describes how one KHR_interactivity configuration or socket property maps to FlowGraph.
+ *
+ * The same contract is used for fixed sockets, wildcard sockets, configuration validation,
+ * defaulting, and multi-block routing during strict graph lowering.
+ */
+export interface IGLTFToFlowGraphMappingObject {
     /**
      * The name of the property in the FlowGraph block.
      */
     name: string;
+    /**
+     * Whether this socket mapping exists only for pre-ratification compatibility input.
+     */
+    compatibilityOnly?: boolean;
     /**
      * The type of the property in the glTF specs.
      * If not provided will be inferred.
@@ -7676,7 +8046,7 @@ interface IGLTFToFlowGraphMappingObject {
      * This is used if we generate more than one block for a single glTF node.
      * Defaults to the first block in the mapping.
      */
-    toBlock?: FlowGraphBlockNames;
+    toBlock?: FlowGraphBlockNames | string;
     /**
      * Used in configuration values. If defined, this will be the default value, if no value is provided.
      */
@@ -7690,6 +8060,75 @@ interface IGLTFToFlowGraphMappingObject {
      * be fed by a `pointer/get` (e.g. the read-only `maxTime` animation pointer).
      */
     convertConnectedTimeToFrames?: boolean;
+    /**
+     * KHR configuration value type used by canonical validation.
+     */
+    configurationType?: "bool" | "int" | "int[]" | "string";
+    /**
+     * Whether this configuration entry exists only for canonical validation.
+     */
+    validationOnly?: boolean;
+    /**
+     * Whether an operation without a complete default configuration requires this property.
+     */
+    required?: boolean;
+    /**
+     * Graph array referenced by an integer configuration value.
+     */
+    indexSource?: "types" | "variables" | "events" | "nodes" | "assetNodes";
+    /**
+     * Minimum number of values required for an array configuration.
+     */
+    minItems?: number;
+    /**
+     * Whether the configured indices generate required input value sockets.
+     */
+    generatesInputValueSockets?: boolean;
+    /**
+     * Whether integer case values generate required input value sockets.
+     */
+    generatesCaseInputValueSockets?: boolean;
+    /**
+     * Whether this string configuration generates JSON Pointer Template sockets.
+     */
+    pointerTemplate?: boolean;
+    /**
+     * Whether an invalid value falls back to the operation's default configuration.
+     */
+    invalidUsesDefault?: boolean;
+    /**
+     * Allowed KHR type signatures for a type-index configuration.
+     */
+    allowedSignatures?: readonly ("bool" | "float" | "float2" | "float3" | "float4" | "float2x2" | "float3x3" | "float4x4" | "int" | "ref" | "custom")[];
+    /**
+     * Input socket whose effective type determines this output socket type.
+     */
+    typeSourceInput?: string;
+    /** Inclusive minimum for an integer configuration value. */
+    minimum?: number;
+    /** Inclusive maximum for an integer configuration value. */
+    maximum?: number;
+    /**
+     * Whether this configuration value generates numbered input flow sockets.
+     */
+    generatesInputFlowSockets?: boolean;
+    /**
+     * Whether this configuration array generates output flow sockets.
+     */
+    generatesOutputFlowSockets?: boolean;
+    /**
+     * Properties in the same group fall back to their defaults together when any member is
+     * missing or invalid.
+     */
+    configurationGroup?: string;
+    /**
+     * Whether duplicate array values are removed from the effective configuration.
+     */
+    uniqueValues?: boolean;
+    /**
+     * Whether a string configuration value is a `debug/log` message template.
+     */
+    debugLogTemplate?: boolean;
 }
 /**
  * Description of how a KHR_interactivity declaration (op such as
@@ -7704,6 +8143,13 @@ export interface IGLTFToFlowGraphMapping {
      * When adding blocks defined in this module use the KHR_interactivity prefix.
      */
     blocks: (FlowGraphBlockNames | string)[];
+    /**
+     * Exact value socket contract for an operation supplied by another extension.
+     */
+    declarationSchema?: {
+        inputValueSockets: Record<string, "bool" | "float" | "float2" | "float3" | "float4" | "float2x2" | "float3x3" | "float4x4" | "int" | "ref" | "custom">;
+        outputValueSockets: Record<string, "bool" | "float" | "float2" | "float3" | "float4" | "float2x2" | "float3x3" | "float4x4" | "int" | "ref" | "custom">;
+    };
     /**
      * The inputs of the glTF node mapped to the FlowGraph block.
      */
@@ -7812,6 +8258,12 @@ export interface IGLTFToFlowGraphMapping {
 }
 export function getMappingForFullOperationName(fullOperationName: string): IGLTFToFlowGraphMapping | undefined;
 export function getMappingForDeclaration(declaration: IKHRInteractivity_Declaration, returnNoOpIfNotAvailable?: boolean): IGLTFToFlowGraphMapping | undefined;
+/**
+ * Creates the typed no-op mapping required for an unsupported extension declaration.
+ * @param declaration unsupported extension declaration
+ * @returns a mapping that preserves the declared value sockets
+ */
+export function getNoOpMappingForDeclaration(declaration: IKHRInteractivity_Declaration): IGLTFToFlowGraphMapping;
 /**
  * This function will add new mapping to glTF interactivity.
  * Other extensions can define new types of blocks, this is the way to let interactivity know how to parse them.
@@ -7820,8 +8272,23 @@ export function getMappingForDeclaration(declaration: IKHRInteractivity_Declarat
  * @param mapping The mapping object. See documentation or examples below.
  */
 export function addNewInteractivityFlowGraphMapping(key: string, extension: string, mapping: IGLTFToFlowGraphMapping): void;
+/**
+ * Result of parsing a ratified `debug/log` message template.
+ */
+export interface IDebugLogTemplateParseResult {
+    /** Whether all literal braces are doubled and every parameter is well formed. */
+    valid: boolean;
+    /** Unique parameter socket ids in first-occurrence order. */
+    sockets: string[];
+}
+/**
+ * Parses a ratified `debug/log` message template.
+ * Literal braces must be doubled; non-empty text inside a single brace pair defines a socket id.
+ * @param message message template to parse
+ * @returns template validity and its exact dynamic socket ids
+ */
+export function ParseDebugLogTemplate(message: string): IDebugLogTemplateParseResult;
 export function getAllSupportedNativeNodeTypes(): string[];
-export {};
 /**
  *
  * These are the nodes from the specs:
@@ -9085,7 +9552,7 @@ export * from "babylonjs-loaders/USD/usdFileLoader.pure";
 }
 declare module "babylonjs-loaders/USD/usdCommandProtocol" {
 export const COMMAND_MAGIC = 1111774037;
-export const PROTOCOL_VERSION = 4;
+export const PROTOCOL_VERSION = 5;
 export const MISSING_OFFSET = 4294967295;
 export enum Command {
     Scene = 1,
@@ -9097,7 +9564,9 @@ export enum Command {
     Mesh = 7,
     Instance = 8,
     Animation = 9,
-    AnalyticPrimitive = 10
+    AnalyticPrimitive = 10,
+    ThinInstances = 11,
+    MorphTarget = 12
 }
 export enum AnalyticPrimitiveType {
     Cube = 0,
@@ -9112,19 +9581,33 @@ export enum PrimitiveAxis {
 }
 export enum AnimationTarget {
     Node = 0,
-    Bone = 1
+    Bone = 1,
+    MorphTarget = 2
 }
 export enum AnimationProperty {
     Position = 0,
     RotationQuaternion = 1,
     Scaling = 2,
-    Matrix = 3
+    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
@@ -10266,17 +10749,20 @@ export interface IGaussianSplattingStreamOptions {
     /** Number of times a failed file download is retried before giving up. PlayCanvas default `2`. */
     maxDownloadRetries?: number;
     /**
-     * GPU memory budget (in megabytes) for resident splats. When set (and smaller than the full dataset),
-     * LOD files are streamed through a fixed-size work buffer and unreferenced files are evicted to stay
-     * within budget, allowing datasets larger than a single full-dataset buffer. Converted to a splat count
-     * using the per-splat cost (core data plus any baked SH and rotation/scale textures). Combined with
-     * {@link maxResidentSplats} by taking the smaller of the two.
+     * Initial GPU/CPU memory estimate (in megabytes) for resident splats. It is converted to a splat count
+     * using the per-splat cost (core data plus any baked SH and rotation/scale textures), combined with
+     * {@link maxResidentSplats} by taking the smaller limit, then raised when necessary to fit the complete
+     * coarse layer. The work buffer has a fixed lifetime capacity; construct a new stream to use another limit.
+     * Finite non-positive values leave this limit unset; non-finite values are rejected.
      */
     memoryBudgetMb?: number;
     /**
-     * Maximum number of splats kept resident in the work buffer. When set (and smaller than the full
-     * dataset), enables eviction-based streaming (see {@link memoryBudgetMb}). Default unset = size the work
-     * buffer for the whole dataset (no eviction).
+     * Initial maximum number of splats kept resident in the fixed-size work buffer. It is raised when necessary
+     * to fit the complete coarse layer. When unset and the complete source size is known, streams retain the complete
+     * source. Streams that defer finer metadata use a bounded device-tiered default with coarse-derived refinement
+     * headroom.
+     * Finite non-positive values leave this limit unset; non-finite or unsafe positive counts are rejected.
+     * Positive fractional counts are floored to at least one splat before applying the coarse minimum.
      */
     maxResidentSplats?: number;
     /**
@@ -10306,10 +10792,10 @@ export interface IGaussianSplattingStreamOptions {
     /**
      * When true, higher-order spherical-harmonics carried by the SOG files (`shN`) are GPU-decoded into baked
      * packed-u32 SH textures so the streamed splats render with view-dependent lighting (matching the non-stream
-     * `.spz`/`.sog` path) instead of flat DC-only color. The SH degree is the max `shN.bands` across the streamed
-     * files (lower-band files neutral-fill). No effect when the files carry no `shN`. Defaults to `true`, matching
-     * the non-stream path's always-decode-if-present behavior; set to `false` to force flat DC-only color even
-     * when the data carries `shN` (e.g. to save the decode cost/texture memory).
+     * `.spz`/`.sog` path) instead of flat DC-only color. Streams with complete initial metadata use the maximum
+     * source SH degree. Streams that defer finer metadata reserve the supported degree-4 layout before it is known,
+     * even if the files ultimately carry no `shN`; lower-degree files neutral-fill the unused bands.
+     * Defaults to `true`; set to `false` to force flat DC-only color and avoid the SH decode cost/texture memory.
      */
     decodeSh?: boolean;
     /**
@@ -10354,6 +10840,7 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
     private _hostBudgetAllocation;
     private _frustumCulling;
     private readonly _frustumPlanes;
+    private readonly _cullCameraViewProj;
     private readonly _cullViewProj;
     private readonly _frustumScratch;
     private _workBuffer;
@@ -10367,6 +10854,7 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
     private _residency;
     private readonly _fileCounts;
     private readonly _fileMeta;
+    private readonly _baseFileIds;
     private readonly _decodedFiles;
     private readonly _loadingFiles;
     private readonly _decodeQueue;
@@ -10374,6 +10862,7 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
     private readonly _cancelledDecodes;
     private _evictionEnabled;
     private _residentBudget;
+    private _minimumResidentSplats;
     private _maxResidentSplats;
     private _memoryBudgetMb;
     private _evictionCooldownFrames;
@@ -10385,6 +10874,7 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
     private _environmentFiles;
     private _lodObserver;
     private _baseLayerReady;
+    private _metadataReady;
     private _framesSinceLodUpdate;
     private readonly _lastLodCamPositions;
     private _lastLodSignature;
@@ -10507,10 +10997,19 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
     /**
      * 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.
+     * taking the smaller positive limit and raising it to {@link minimumResidentSplats}. With neither limit set,
+     * the complete source size is retained when known; otherwise a bounded device-tiered default is used.
+     * The fixed capacity is capped at the device texture limit. `0` means initial capacity has not been resolved.
      * @experimental
      */
     get residentSplatBudget(): number;
+    /**
+     * Minimum fixed work-buffer capacity required for the complete coarse representation: one invisible padding
+     * splat, the included environment, and every unique whole coarse source file. It is `0` until the required
+     * coarse metadata has resolved. Initial residency options below this value are raised to it.
+     * @experimental
+     */
+    get minimumResidentSplats(): 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.
@@ -10585,14 +11084,14 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
     set debugLodSource(value: GaussianSplattingStreamDebugLodSource);
     dispose(doNotRecurse?: boolean): void;
     /**
-     * Disposes this stream (which tombstones its region) and then compacts the host once to actually reclaim the
-     * reserved rows. Used on a definitive load failure / empty result — a discrete, one-off reclaim, versus a bare
+     * Disposes this stream and, when hosted, compacts the host once to reclaim its tombstoned region's reserved
+     * rows. Used on a definitive load failure / empty result — a discrete, one-off reclaim, versus a bare
      * {@link dispose} that only tombstones so tearing down several parts doesn't rebuild the atlas repeatedly.
      */
     private _disposeAndReclaim;
     /**
      * The world matrix that actually places this stream's splats, used to map the camera into the space the
-     * node bounds live in (for LOD distance) and to build per-node world AABBs (for frustum culling). Standalone:
+     * node bounds live in (for LOD distance) and to build camera-local frusta (for frustum culling). Standalone:
      * this controller mesh carries the transform. Hosted: this controller is a hidden, unplaced node — the splats
      * are placed by the reserved part's proxy (SOG up-axis basis composed with the host's placement), so LOD and
      * culling MUST use the proxy's world matrix or they compute distances/frustum tests in the wrong space
@@ -10660,9 +11159,9 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
      */
     private _collectLodEntries;
     /**
-     * Streams the scene: learns every source file's splat count, allocates one unified GPU work buffer
-     * sized for all LOD files, decodes the environment and the coarsest LOD of every node as a permanent
-     * base layer, then installs the per-frame loop that streams finer LODs on demand.
+     * Streams the scene. Large streams fetch only required coarse metadata before allocating and decoding the
+     * complete coarse layer; finer metadata starts afterwards so it cannot occupy the download queue ahead of
+     * visible geometry. Small streams and streams containing only coarse files retain an exact all-file capacity upper bound.
      */
     private _streamAllAsync;
     /**
@@ -10675,26 +11174,47 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
      */
     private _waitForCanBackupAsync;
     /**
-     * Resolves the resident-splat budget from the raw options, sizing a memory (MB) budget with the actual per-splat
-     * GPU+CPU cost — core data plus the baked SH textures and rotation/scale textures when enabled — so SH/rotation
-     * assets don't silently consume up to double the configured budget. Requires the SH degree (from the metadata
-     * pre-pass) to be known. The smaller of the splat-count and memory budgets wins.
+     * Resolves the fixed initial work-buffer capacity. Explicit count/MB limits are combined by taking the smaller
+     * and then raised to the complete coarse minimum. Without an explicit limit, a known complete source retains
+     * legacy full residency. When finer metadata is deferred and the complete size is unknown, the device-tiered
+     * memory estimate is given at least one largest-coarse-file of headroom so one replacement file can refine
+     * while all coarse fallback files remain pinned.
+     * @param fullCapacity exact complete source capacity, or null when unavailable
+     * @param largestBaseFileCount largest whole coarse source file, used as modest replacement headroom
+     * @returns the fixed initial work-buffer capacity
      */
     private _resolveResidentBudget;
+    /**
+     * Returns the estimated combined GPU/CPU bytes occupied by one resident splat.
+     * @returns estimated bytes per resident splat
+     */
+    private _bytesPerResidentSplat;
     /**
      * Collects the unique set of source file indices referenced by any LOD of any leaf, sorted ascending.
      * @returns sorted unique file indices
      */
     private _collectAllFileIds;
+    /**
+     * Collects unique whole source files required by the coarsest entry of every valid leaf.
+     * @returns sorted unique coarse file indices
+     */
+    private _collectBaseFileIds;
+    /**
+     * Resolves the immutable minimum initial capacity from padding, environment, and unique whole coarse files.
+     * @param baseFileIds unique coarse source file indices
+     * @param environmentCount included environment splat count
+     */
+    private _resolveMinimumResidentSplats;
     /**
      * 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.
+     * Fetches the environment bundle and the supplied referenced files' metadata to learn splat counts, caching
+     * each file's parsed metadata for the later on-demand decode. File metadata fetches run in parallel.
      * @param fileIds file indices to fetch metadata for
+     * @param includeEnvironment whether to fetch the optional environment bundle in this phase
      * @returns the environment splat count (0 when there is no environment)
      */
     private _gatherCountsAsync;
@@ -10762,6 +11282,7 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
      * Concurrent or repeat requests for the same file are ignored. If the file is cancelled mid-flight
      * (because every node that wanted it retargeted), the decode bails cooperatively at the next checkpoint.
      * @param fileId file index to decode
+     * @returns whether the file was decoded and published successfully
      */
     private _decodeFileAsync;
     /**
@@ -10926,6 +11447,22 @@ export class GaussianSplattingStream extends GaussianSplattingMesh implements IG
      * @returns whether any node's in-frustum state changed
      */
     private _updateNodeFrustum;
+    /**
+     * Normalizes an initial residency option, preserving finite non-positive values as an unset limit.
+     * @param value option value
+     * @param name option name used in errors
+     * @param integer whether the normalized value must be an integer splat count
+     * @returns normalized value
+     */
+    private static _NormalizeResidentLimit;
+    /**
+     * Adds trusted non-negative integer counts without allowing unsafe capacity arithmetic.
+     * @param left first count
+     * @param right second count
+     * @param label capacity name used in errors
+     * @returns the safe integer sum
+     */
+    private static _SafeAddCounts;
     /**
      * Reads the splat count from SOG metadata, coerced to a finite non-negative integer (metadata is untrusted, so
      * `count` / `shape[0]` may be a string or malformed — a non-numeric value must not leak into count arithmetic).
@@ -11876,12 +12413,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" {
@@ -11910,12 +12451,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.
@@ -11938,6 +12550,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
@@ -11980,6 +12608,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;
@@ -11991,6 +12624,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.
@@ -12014,6 +12656,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;
@@ -12037,11 +12684,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;
@@ -12058,13 +12721,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;
@@ -12074,9 +12732,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
@@ -12114,6 +12824,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" {
 /**
@@ -12130,6 +13031,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 {
@@ -12156,11 +13062,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;
 /**
@@ -12224,6 +13141,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";
@@ -12298,25 +13217,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" {
@@ -12382,12 +13285,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;
@@ -12395,6 +13459,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];
@@ -12430,11 +13498,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" {
@@ -12449,7 +13612,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. */
@@ -12496,8 +13659,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";
@@ -12509,8 +13675,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 */
@@ -12542,18 +13710,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 */
@@ -12572,6 +13790,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 */
@@ -12581,6 +13801,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 */
@@ -12605,6 +13827,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 */
@@ -12616,6 +13847,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) */
@@ -12632,6 +13865,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;
@@ -12640,11 +13879,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" {
@@ -12669,7 +13988,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. */
@@ -12792,9 +14111,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 */
@@ -12805,9 +14139,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) */
@@ -12818,7 +14158,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) */
@@ -12827,13 +14220,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 */
@@ -12872,6 +14271,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 */
@@ -12879,6 +14282,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 */
@@ -12901,13 +14312,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
@@ -12915,6 +14320,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" {
@@ -15904,8 +17357,9 @@ declare namespace BABYLON.GLTF2 {
         onLoading?(): void;
         /**
          * Called after the loader state changes to READY.
+         * @returns a promise when the extension has asynchronous readiness work
          */
-        onReady?(): void;
+        onReady?(): void | Promise<void>;
         /**
          * Define this method to modify the default behavior when loading scenes.
          * @param context The context when loading the asset
@@ -16493,7 +17947,7 @@ declare namespace BABYLON.GLTF2 {
         private _forEachExtensions;
         private _applyExtensions;
         private _extensionsOnLoading;
-        private _extensionsOnReady;
+        private _extensionsOnReadyAsync;
         private _extensionsLoadSceneAsync;
         private _extensionsLoadNodeAsync;
         private _extensionsLoadCameraAsync;
@@ -17136,9 +18590,10 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
     /**
      * get a path-to-object converter for the given glTF tree
      * @param gltf the glTF tree to use
+     * @param configure optional callback for adding asset-local accessors to this converter
      * @returns a path-to-object converter for the given glTF tree
      */
-    export function GetPathToObjectConverter(gltf: BABYLON.GLTF2.Loader.IGLTF): BABYLON.GLTF2.Loader.Extensions.GLTFPathToObjectConverter<unknown, unknown, unknown>;
+    export function GetPathToObjectConverter(gltf: BABYLON.GLTF2.Loader.IGLTF, configure?: (mapping: object) => void): BABYLON.GLTF2.Loader.Extensions.GLTFPathToObjectConverter<unknown, unknown, unknown>;
     /**
      * This function will return the object accessor for the given key in the object model
      * If the key is not found, it will return undefined
@@ -17157,8 +18612,9 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
      * Note that this will NOT change the typescript types. To do that you will need to change the interface itself (extending it in the module that uses it)
      * @param key the key to add the object accessor at. For example /cameras/\{\}/perspective/aspectRatio
      * @param accessor the object accessor to add
+     * @param mapping object-model mapping to update; defaults to the process-wide mapping used as the template for new converters
      */
-    export function AddObjectAccessorToKey<GLTFTargetType = any, BabylonTargetType = any, BabylonValueType = any>(key: string, accessor: IObjectAccessor<GLTFTargetType, BabylonTargetType, BabylonValueType>): void;
+    export function AddObjectAccessorToKey<GLTFTargetType = any, BabylonTargetType = any, BabylonValueType = any>(key: string, accessor: IObjectAccessor<GLTFTargetType, BabylonTargetType, BabylonValueType>, mapping?: object): void;
 
 
 
@@ -18114,6 +19570,8 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
          * The name of this extension.
          */
         readonly name = "KHR_node_selectability";
+        /** Applies node state before KHR_interactivity graphs start. */
+        readonly order = 100;
         /**
          * Defines whether this extension is enabled.
          */
@@ -18181,6 +19639,8 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
          * The name of this extension.
          */
         readonly name = "KHR_node_hoverability";
+        /** Applies node state before KHR_interactivity graphs start. */
+        readonly order = 100;
         /**
          * Defines whether this extension is enabled.
          */
@@ -19721,12 +21181,74 @@ declare namespace BABYLON {
         /**
          * Defines options for the KHR_interactivity extension.
          */
-        ["KHR_interactivity"]: {};
+        ["KHR_interactivity"]: {
+            /**
+             * Whether the selected default graph starts automatically after import.
+             * Defaults to true.
+             */
+            autoStart?: boolean;
+            /**
+             * Whether to retain only the canonical source model and executable
+             * FlowGraph serialization without constructing runtime graphs.
+             * Defaults to false.
+             */
+            parseOnly?: boolean;
+            /**
+             * Whether to enforce the ratified graph validation rules.
+             * Defaults to true. Set to false only for pre-ratification assets.
+             */
+            strictValidation?: boolean;
+        };
     }
 
 }
 declare namespace BABYLON.GLTF2.Loader.Extensions {
         /**
+     * Runtime projection of one canonical KHR_interactivity graph.
+     */
+    export interface IKHRInteractivityGraphImportResult {
+        /** Canonical source graph and diagnostics. */
+        graph: BABYLON.GLTF2.Loader.Extensions.IKHRInteractivityGraphModel;
+        /** Executable FlowGraph serialization when lowering succeeded. */
+        serializedFlowGraph?: ISerializedFlowGraph;
+        /** Runtime FlowGraph when runtime construction was requested. */
+        flowGraph?: FlowGraph;
+        /** Coordinator that owns the runtime FlowGraph. */
+        coordinator?: FlowGraphCoordinator;
+        /** Additional lowering/runtime diagnostics. */
+        diagnostics: BABYLON.GLTF2.Loader.Extensions.IKHRInteractivityDiagnostic[];
+    }
+    /**
+     * Completed KHR_interactivity import result associated with a loaded scene.
+     */
+    export interface IKHRInteractivityImportResult {
+        /** Stable zero-based identity of this interactivity asset among assets appended to the scene. */
+        assetIndex: number;
+        /** Canonical, lossless source document. */
+        document: BABYLON.GLTF2.Loader.Extensions.IKHRInteractivityDocument;
+        /** Graph import results in source order. */
+        graphs: IKHRInteractivityGraphImportResult[];
+        /** Shared path converter required by pointer blocks. */
+        pathConverter: BABYLON.GLTF2.Loader.Extensions.CompositePathToObjectConverter<IObjectAccessor>;
+        /** Live glTF loader data used by glTF data-provider blocks. */
+        glTF: BABYLON.GLTF2.GLTFLoader["gltf"];
+        /** Host resolver that supplies KHR reference semantics to executable graphs. */
+        hostResolver: BABYLON.GLTF2.Loader.Extensions.InteractivityHostResolver;
+    }
+    /**
+     * Gets the completed KHR_interactivity import result for a loaded scene.
+     * @param scene scene loaded from the glTF asset
+     * @returns the import result, or undefined when the scene has no KHR_interactivity data
+     */
+    export function GetKHRInteractivityImportResult(scene: Scene): IKHRInteractivityImportResult | undefined;
+    /**
+     * Gets every completed KHR_interactivity import result appended to a loaded scene.
+     * Results remain in asset load order and each result has a stable {@link IKHRInteractivityImportResult.assetIndex}.
+     * @param scene scene containing the loaded glTF assets
+     * @returns the scene's import results, or an empty array when it has no KHR_interactivity data
+     */
+    export function GetKHRInteractivityImportResults(scene: Scene): readonly IKHRInteractivityImportResult[];
+    /**
      * Loader extension for KHR_interactivity
      */
     export class KHR_interactivity implements BABYLON.GLTF2.IGLTFLoaderExtension {
@@ -19735,6 +21257,8 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
          * The name of this extension.
          */
         readonly name = "KHR_interactivity";
+        /** Runs after extensions that contribute interactivity operations and object state. */
+        readonly order = 200;
         /**
          * Defines whether this extension is enabled.
          */
@@ -19746,6 +21270,7 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
          * @param _loader
          */
         constructor(_loader: BABYLON.GLTF2.GLTFLoader);
+        private _initializePathConverter;
         dispose(): void;
         onReady(): Promise<void>;
     }
@@ -19753,7 +21278,7 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
      * @internal
      * populates the object model with the interactivity extension
      */
-    export function _AddInteractivityObjectModel(scene: Scene): void;
+    export function _AddInteractivityObjectModel(scene: Scene, targetFps: number, mapping: object): void;
     /**
      * @internal
      * Registers KHR_interactivity runtime dependencies without changing the extension registry.
@@ -20625,6 +22150,37 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
 
 
 
+}
+declare namespace BABYLON {
+
+
+}
+declare namespace BABYLON.GLTF2.Loader.Extensions {
+        type InteractivityNodeState = "hoverable" | "selectable";
+    /**
+     * Initializes authored and inherited selectability or hoverability state.
+     * @param nodes all nodes in the glTF asset
+     * @param state state kind to initialize
+     * @param getAuthoredState reads the extension-authored local state
+     */
+    export function InitializeInteractivityNodeState(nodes: readonly BABYLON.GLTF2.Loader.INode[], state: InteractivityNodeState, getAuthoredState: (node: BABYLON.GLTF2.Loader.INode) => boolean | undefined): void;
+    /**
+     * Gets the locally authored runtime state for a node.
+     * @param node glTF node
+     * @param state state kind
+     * @returns local state, defaulting to true
+     */
+    export function GetInteractivityNodeState(node: BABYLON.GLTF2.Loader.INode, state: InteractivityNodeState): boolean;
+    /**
+     * Updates local state and reapplies inherited state to the affected subtree.
+     * @param node glTF node
+     * @param state state kind
+     * @param value new local state
+     */
+    export function SetInteractivityNodeState(node: BABYLON.GLTF2.Loader.INode, state: InteractivityNodeState, value: boolean): void;
+
+
+
 }
 declare namespace BABYLON {
 
@@ -20650,9 +22206,10 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
         decodeEventReference(reference: string): string | undefined;
         /**
          * @param reference the reference to decode
+         * @param collection optional glTF root collection the reference must address
          * @returns the index the reference denotes, or `undefined` when it is not an indexed JSON Pointer
          */
-        decodeIndexReference(reference: string): number | undefined;
+        decodeIndexReference(reference: string, collection?: string): number | undefined;
         /**
          * Maps a Babylon object loaded from the glTF back to a JSON Pointer addressing it.
          *
@@ -20697,13 +22254,6 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
             value?: any;
         }[];
     }
-    export var gltfTypeToBabylonType: {
-        [key: string]: {
-            length: number;
-            flowGraphType: FlowGraphTypes;
-            elementType: "number" | "boolean" | "string";
-        };
-    };
     /**
      * Parses a KHR_interactivity graph definition (the raw glTF JSON object) into
      * the serialized FlowGraph form consumed by {@link ParseFlowGraphAsync}.
@@ -20713,9 +22263,11 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
      * {@link serializeToFlowGraph}.
      */
     export class InteractivityGraphToFlowGraphParser {
-        private _interactivityGraph;
         private _gltf;
         _animationTargetFps: number;
+        private _graphIndex;
+        private _supportedExtensions?;
+        private _declarationModels?;
         /**
          * Note - the graph should be rejected if the same type is defined twice.
          * We currently don't validate that.
@@ -20733,16 +22285,22 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
          * the last block) is not disturbed, then concatenated into the serialized graph.
          */
         private _insertedBlocks;
-        constructor(_interactivityGraph: BABYLON.GLTF2.IKHRInteractivity_Graph, _gltf: BABYLON.GLTF2.Loader.IGLTF, _animationTargetFps?: number);
+        constructor(interactivityGraph: BABYLON.GLTF2.IKHRInteractivity_Graph, _gltf: BABYLON.GLTF2.Loader.IGLTF, _animationTargetFps?: number, _graphIndex?: number, _supportedExtensions?: ReadonlySet<string> | undefined, _declarationModels?: readonly BABYLON.GLTF2.Loader.Extensions.IKHRInteractivityDeclarationModel[] | undefined);
+        private _interactivityGraph;
+        private get _strictValidation();
+        private _hasDefaultFlowInput;
+        private _getAllowedDynamicValueSockets;
+        private _getAllowedDynamicFlowSockets;
         get arrays(): {
             types: {
                 length: number;
                 flowGraphType: FlowGraphTypes;
-                elementType: "number" | "boolean" | "string";
+                elementType: "number" | "boolean" | "string" | "any";
             }[];
             mappings: {
                 flowGraphMapping: BABYLON.GLTF2.Loader.Extensions.IGLTFToFlowGraphMapping;
                 fullOperationName: string;
+                declaration: BABYLON.GLTF2.Loader.Extensions.IKHRInteractivityDeclarationModel;
             }[];
             staticVariables: {
                 type: FlowGraphTypes;
@@ -20758,12 +22316,15 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
         private _parseDeclarations;
         private _parseVariables;
         private _parseVariable;
+        private _normalizeStaticReference;
         private _parseEvents;
         private _parseNodes;
         private _getEmptyBlock;
+        private _createUnsupportedExtensionBlock;
         private _parseNodeConfiguration;
         private _parseNodeConnections;
         private _createNewSocketConnection;
+        private _isUnsupportedExtensionBlock;
         /**
          * Wires an upstream data output into a downstream data input through a runtime multiply block that
          * scales the value by the animation target fps. This converts a KHR animation time (seconds),
@@ -20773,6 +22334,8 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
          * @param context the serialized flow graph context that stores literal socket values
          * @param upstreamOutput the data output socket providing the time value (in seconds)
          * @param downstreamInput the data input socket that expects the time in frames
+         * @param nodeIndex source node receiving the converted value
+         * @param declarationIndex source declaration used by the receiving node
          */
         private _connectWithSecondsToFramesConversion;
         private _connectFlowGraphNodes;
@@ -20794,6 +22357,125 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
 
 
 
+}
+declare namespace BABYLON {
+
+
+}
+declare namespace BABYLON.GLTF2.Loader.Extensions {
+        /**
+     * Ratified KHR_interactivity specification baseline used by this importer.
+     */
+    export const KHR_INTERACTIVITY_SPECIFICATION_COMMIT = "f798712c5685bc9223a628140fba707db8889300";
+    /**
+     * Runtime representation of every ratified built-in KHR_interactivity type.
+     */
+    export var gltfTypeToBabylonType: {
+        [key: string]: {
+            length: number;
+            flowGraphType: FlowGraphTypes;
+            elementType: "number" | "boolean" | "string" | "any";
+        };
+    };
+    /**
+     * Classification of a KHR_interactivity declaration.
+     */
+    export type KHRInteractivityDeclarationSupport = "core" | "extension" | "unsupported-extension" | "unknown-core";
+    /**
+     * A structured KHR_interactivity import diagnostic.
+     */
+    export interface IKHRInteractivityDiagnostic {
+        /** JSON pointer identifying the source location. */
+        path: string;
+        /** Human-readable diagnostic text. */
+        message: string;
+        /** Diagnostic severity. */
+        severity: "error" | "warning";
+    }
+    /**
+     * Canonical declaration information retained during import.
+     */
+    export interface IKHRInteractivityDeclarationModel {
+        /** Declaration index in the source graph. */
+        index: number;
+        /** Full operation name, including the defining extension when present. */
+        operation: string;
+        /** Whether Babylon can execute the declaration. */
+        support: KHRInteractivityDeclarationSupport;
+        /** Exact source declaration. */
+        source: BABYLON.GLTF2.IKHRInteractivity_Declaration;
+    }
+    /**
+     * Canonical graph information retained during import.
+     */
+    export interface IKHRInteractivityGraphModel {
+        /** Graph index in the root extension. */
+        index: number;
+        /** Stable source path. */
+        path: string;
+        /** Human-readable graph name. */
+        name: string;
+        /** Exact source graph, including extension and extras payloads. */
+        source: BABYLON.GLTF2.IKHRInteractivity_Graph;
+        /** Executable graph with specification defaults and fallbacks applied. */
+        effectiveSource: BABYLON.GLTF2.IKHRInteractivity_Graph;
+        /** Canonical declarations in source order. */
+        declarations: IKHRInteractivityDeclarationModel[];
+        /** Validation diagnostics for this graph. */
+        diagnostics: IKHRInteractivityDiagnostic[];
+        /** Whether this graph is valid and can be lowered to FlowGraph. */
+        valid: boolean;
+    }
+    /**
+     * Lossless canonical representation of a KHR_interactivity root extension.
+     */
+    export interface IKHRInteractivityDocument {
+        /** Ratified specification revision used for validation. */
+        specificationCommit: string;
+        /** Exact source extension, including unknown extensions and extras. */
+        source: BABYLON.GLTF2.IKHRInteractivity;
+        /** Default graph index, or -1 when the source selection is invalid. */
+        defaultGraphIndex: number;
+        /** Canonical graph models in source order. */
+        graphs: IKHRInteractivityGraphModel[];
+        /** Root-level validation diagnostics. */
+        diagnostics: IKHRInteractivityDiagnostic[];
+    }
+    /**
+     * Creates a detached JSON copy of a KHR_interactivity graph.
+     * @param graph source graph
+     * @returns a lossless JSON copy
+     */
+    export function CloneKHRInteractivityGraph(graph: BABYLON.GLTF2.IKHRInteractivity_Graph): BABYLON.GLTF2.IKHRInteractivity_Graph;
+    /**
+     * Creates the executable graph view with all ratified configuration defaults and fallback rules
+     * applied without modifying the lossless source graph.
+     * @param graph source graph
+     * @param declarations canonical declarations
+     * @param assetNodeCount number of glTF nodes in the containing asset
+     * @returns normalized executable graph
+     */
+    export function CreateEffectiveKHRInteractivityGraph(graph: BABYLON.GLTF2.IKHRInteractivity_Graph, declarations: readonly IKHRInteractivityDeclarationModel[], assetNodeCount?: number): BABYLON.GLTF2.IKHRInteractivity_Graph;
+    /**
+     * Creates and validates a canonical copy of one KHR_interactivity graph.
+     * @param graph source graph
+     * @param index graph index in the root extension
+     * @param supportedExtensions enabled extensions that may provide executable operations
+     * @param assetNodeCount number of nodes in the containing glTF asset
+     * @returns the canonical graph model
+     */
+    export function CreateKHRInteractivityGraphModel(graph: BABYLON.GLTF2.IKHRInteractivity_Graph | null | undefined, index?: number, supportedExtensions?: ReadonlySet<string>, assetNodeCount?: number): IKHRInteractivityGraphModel;
+    /**
+     * Creates an immutable canonical KHR_interactivity document and validates all graph-local references.
+     * @param extension source extension object from the glTF document
+     * @param supportedExtensions enabled extensions that may provide executable operations
+     * @param assetNodeCount number of nodes in the containing glTF asset
+     * @returns the canonical document
+     */
+    export function CreateKHRInteractivityDocument(extension: BABYLON.GLTF2.IKHRInteractivity, supportedExtensions?: ReadonlySet<string>, assetNodeCount?: number): IKHRInteractivityDocument;
+
+
+
 }
 declare namespace BABYLON {
 
@@ -20803,6 +22485,82 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
     
 
 
+}
+declare namespace BABYLON {
+
+
+}
+declare namespace BABYLON.GLTF2.Loader.Extensions {
+        /**
+     * Socket definition retained for an unsupported extension operation.
+     */
+    export interface IFlowGraphUnsupportedInteractivitySocket {
+        /** Socket name. */
+        name: string;
+        /** FlowGraph runtime type name. */
+        type?: string;
+        /** Exact KHR_interactivity type signature. */
+        signature?: string;
+    }
+    /**
+     * Configuration for an unsupported KHR_interactivity extension operation.
+     */
+    export interface IFlowGraphUnsupportedInteractivityBlockConfiguration extends IFlowGraphBlockConfiguration {
+        /** Full extension operation name. */
+        operation: string;
+        /** Input value sockets declared by the extension. */
+        inputValueSockets: IFlowGraphUnsupportedInteractivitySocket[];
+        /** Output value sockets declared by the extension. */
+        outputValueSockets: IFlowGraphUnsupportedInteractivitySocket[];
+        /** Input flow sockets used by the source graph. */
+        inputFlowSockets: string[];
+        /** Output flow sockets used by the source graph. */
+        outputFlowSockets: string[];
+    }
+    /**
+     * Inspectable runtime no-op for an operation owned by an unsupported glTF extension.
+     */
+    export class FlowGraphUnsupportedInteractivityBlock extends FlowGraphExecutionBlock {
+        config: IFlowGraphUnsupportedInteractivityBlockConfiguration;
+        constructor(config: IFlowGraphUnsupportedInteractivityBlockConfiguration);
+        /** @internal */
+        _execute(_context: FlowGraphContext, _callingSignal: FlowGraphSignalConnection): void;
+        /** @returns the serialized class name */
+        getClassName(): string;
+    }
+
+
+
+}
+declare namespace BABYLON {
+
+
+}
+declare namespace BABYLON.GLTF2.Loader.Extensions {
+        /**
+     * Resolves a runtime object to its owning glTF node reference.
+     * @param context active FlowGraph context
+     * @param value runtime object, usually a picked primitive
+     * @returns the owning node reference or the null reference
+     */
+    export function GetInteractivityObjectReference(context: FlowGraphContext, value: object | undefined): string;
+    /**
+     * Converts a runtime object into the opaque reference used by KHR_interactivity.
+     */
+    export class FlowGraphObjectReferenceBlock extends FlowGraphBlock {
+        /** Runtime object to encode. */
+        readonly object: FlowGraphDataConnection<object | undefined>;
+        /** Opaque KHR_interactivity reference. */
+        readonly value: FlowGraphDataConnection<string>;
+        constructor(config?: IFlowGraphBlockConfiguration);
+        /** @internal */
+        _updateOutputs(context: FlowGraphContext): void;
+        /** @returns the serialized class name */
+        getClassName(): string;
+    }
+
+
+
 }
 declare namespace BABYLON {
 
@@ -20816,7 +22574,7 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
         /**
          * the glTF object to provide data from
          */
-        glTF: BABYLON.GLTF2.Loader.IGLTF;
+        glTF?: BABYLON.GLTF2.Loader.IGLTF;
     }
     /**
      * a glTF-based FlowGraph block that provides arrays with babylon object, based on the glTF tree
@@ -20833,7 +22591,7 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
          * Corresponds directly to the glTF nodes array
          */
         readonly nodes: FlowGraphDataConnection<TransformNode[]>;
-        constructor(config: IFlowGraphGLTFDataProviderBlockConfiguration);
+        constructor(config?: IFlowGraphGLTFDataProviderBlockConfiguration);
         getClassName(): string;
     }
 
@@ -20845,20 +22603,80 @@ declare namespace BABYLON {
 
 }
 declare namespace BABYLON.GLTF2.Loader.Extensions {
-        interface IGLTFToFlowGraphMappingObject {
-        /**
-         * The name of the property in the FlowGraph block.
-         */
-        name: string;
         /**
-         * The type of the property in the glTF specs.
-         * If not provided will be inferred.
-         */
-        gltfType?: string;
-        /**
-         * The type of the property in the FlowGraph block.
-         * If not defined it equals the glTF type.
-         */
+     * Configuration for a KHR event reference output.
+     */
+    export interface IFlowGraphEventReferenceBlockConfiguration extends IFlowGraphBlockConfiguration {
+        /** Stable key shared by equivalent event operations. */
+        eventKey?: string;
+    }
+    /**
+     * Produces the opaque reference associated with a KHR event operation.
+     */
+    export class FlowGraphEventReferenceBlock extends FlowGraphExecutionBlock {
+        config: IFlowGraphEventReferenceBlockConfiguration;
+        private readonly _assetInverse;
+        private readonly _selectionPointValue;
+        private readonly _selectionRayOriginValue;
+        /** Output flow activated after event values are captured. */
+        readonly out: FlowGraphSignalConnection;
+        /** Runtime node associated with the event. */
+        readonly node: FlowGraphDataConnection<object | undefined>;
+        /** Controller index associated with the event. */
+        readonly controllerIndexInput: FlowGraphDataConnection<number>;
+        /** Selection point associated with the event. */
+        readonly selectionPointInput: FlowGraphDataConnection<Vector3>;
+        /** Selection ray origin associated with the event. */
+        readonly selectionRayOriginInput: FlowGraphDataConnection<Vector3>;
+        /** Opaque node reference. */
+        readonly nodeReference: FlowGraphDataConnection<string>;
+        /** Retained controller index. */
+        readonly controllerIndex: FlowGraphDataConnection<number>;
+        /** Retained selection point. */
+        readonly selectionPoint: FlowGraphDataConnection<Vector3>;
+        /** Retained selection ray origin. */
+        readonly selectionRayOrigin: FlowGraphDataConnection<Vector3>;
+        /** Opaque event reference. */
+        readonly value: FlowGraphDataConnection<string>;
+        constructor(config: IFlowGraphEventReferenceBlockConfiguration);
+        /** @internal */
+        _execute(context: FlowGraphContext): void;
+        /** @returns the serialized class name */
+        getClassName(): string;
+    }
+
+
+
+}
+declare namespace BABYLON {
+
+
+}
+declare namespace BABYLON.GLTF2.Loader.Extensions {
+        /**
+     * Describes how one KHR_interactivity configuration or socket property maps to FlowGraph.
+     *
+     * The same contract is used for fixed sockets, wildcard sockets, configuration validation,
+     * defaulting, and multi-block routing during strict graph lowering.
+     */
+    export interface IGLTFToFlowGraphMappingObject {
+        /**
+         * The name of the property in the FlowGraph block.
+         */
+        name: string;
+        /**
+         * Whether this socket mapping exists only for pre-ratification compatibility input.
+         */
+        compatibilityOnly?: boolean;
+        /**
+         * The type of the property in the glTF specs.
+         * If not provided will be inferred.
+         */
+        gltfType?: string;
+        /**
+         * The type of the property in the FlowGraph block.
+         * If not defined it equals the glTF type.
+         */
         flowGraphType?: string;
         /**
          * A function that transforms the data from the glTF to the FlowGraph block.
@@ -20882,7 +22700,7 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
          * This is used if we generate more than one block for a single glTF node.
          * Defaults to the first block in the mapping.
          */
-        toBlock?: FlowGraphBlockNames;
+        toBlock?: FlowGraphBlockNames | string;
         /**
          * Used in configuration values. If defined, this will be the default value, if no value is provided.
          */
@@ -20896,6 +22714,75 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
          * be fed by a `pointer/get` (e.g. the read-only `maxTime` animation pointer).
          */
         convertConnectedTimeToFrames?: boolean;
+        /**
+         * KHR configuration value type used by canonical validation.
+         */
+        configurationType?: "bool" | "int" | "int[]" | "string";
+        /**
+         * Whether this configuration entry exists only for canonical validation.
+         */
+        validationOnly?: boolean;
+        /**
+         * Whether an operation without a complete default configuration requires this property.
+         */
+        required?: boolean;
+        /**
+         * Graph array referenced by an integer configuration value.
+         */
+        indexSource?: "types" | "variables" | "events" | "nodes" | "assetNodes";
+        /**
+         * Minimum number of values required for an array configuration.
+         */
+        minItems?: number;
+        /**
+         * Whether the configured indices generate required input value sockets.
+         */
+        generatesInputValueSockets?: boolean;
+        /**
+         * Whether integer case values generate required input value sockets.
+         */
+        generatesCaseInputValueSockets?: boolean;
+        /**
+         * Whether this string configuration generates JSON Pointer Template sockets.
+         */
+        pointerTemplate?: boolean;
+        /**
+         * Whether an invalid value falls back to the operation's default configuration.
+         */
+        invalidUsesDefault?: boolean;
+        /**
+         * Allowed KHR type signatures for a type-index configuration.
+         */
+        allowedSignatures?: readonly ("bool" | "float" | "float2" | "float3" | "float4" | "float2x2" | "float3x3" | "float4x4" | "int" | "ref" | "custom")[];
+        /**
+         * Input socket whose effective type determines this output socket type.
+         */
+        typeSourceInput?: string;
+        /** Inclusive minimum for an integer configuration value. */
+        minimum?: number;
+        /** Inclusive maximum for an integer configuration value. */
+        maximum?: number;
+        /**
+         * Whether this configuration value generates numbered input flow sockets.
+         */
+        generatesInputFlowSockets?: boolean;
+        /**
+         * Whether this configuration array generates output flow sockets.
+         */
+        generatesOutputFlowSockets?: boolean;
+        /**
+         * Properties in the same group fall back to their defaults together when any member is
+         * missing or invalid.
+         */
+        configurationGroup?: string;
+        /**
+         * Whether duplicate array values are removed from the effective configuration.
+         */
+        uniqueValues?: boolean;
+        /**
+         * Whether a string configuration value is a `debug/log` message template.
+         */
+        debugLogTemplate?: boolean;
     }
     /**
      * Description of how a KHR_interactivity declaration (op such as
@@ -20910,6 +22797,13 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
          * When adding blocks defined in this module use the KHR_interactivity prefix.
          */
         blocks: (FlowGraphBlockNames | string)[];
+        /**
+         * Exact value socket contract for an operation supplied by another extension.
+         */
+        declarationSchema?: {
+            inputValueSockets: Record<string, "bool" | "float" | "float2" | "float3" | "float4" | "float2x2" | "float3x3" | "float4x4" | "int" | "ref" | "custom">;
+            outputValueSockets: Record<string, "bool" | "float" | "float2" | "float3" | "float4" | "float2x2" | "float3x3" | "float4x4" | "int" | "ref" | "custom">;
+        };
         /**
          * The inputs of the glTF node mapped to the FlowGraph block.
          */
@@ -21018,6 +22912,12 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
     }
     export function getMappingForFullOperationName(fullOperationName: string): IGLTFToFlowGraphMapping | undefined;
     export function getMappingForDeclaration(declaration: BABYLON.GLTF2.IKHRInteractivity_Declaration, returnNoOpIfNotAvailable?: boolean): IGLTFToFlowGraphMapping | undefined;
+    /**
+     * Creates the typed no-op mapping required for an unsupported extension declaration.
+     * @param declaration unsupported extension declaration
+     * @returns a mapping that preserves the declared value sockets
+     */
+    export function getNoOpMappingForDeclaration(declaration: BABYLON.GLTF2.IKHRInteractivity_Declaration): IGLTFToFlowGraphMapping;
     /**
      * This function will add new mapping to glTF interactivity.
      * Other extensions can define new types of blocks, this is the way to let interactivity know how to parse them.
@@ -21026,6 +22926,22 @@ declare namespace BABYLON.GLTF2.Loader.Extensions {
      * @param mapping The mapping object. See documentation or examples below.
      */
     export function addNewInteractivityFlowGraphMapping(key: string, extension: string, mapping: IGLTFToFlowGraphMapping): void;
+    /**
+     * Result of parsing a ratified `debug/log` message template.
+     */
+    export interface IDebugLogTemplateParseResult {
+        /** Whether all literal braces are doubled and every parameter is well formed. */
+        valid: boolean;
+        /** Unique parameter socket ids in first-occurrence order. */
+        sockets: string[];
+    }
+    /**
+     * Parses a ratified `debug/log` message template.
+     * Literal braces must be doubled; non-empty text inside a single brace pair defines a socket id.
+     * @param message message template to parse
+     * @returns template validity and its exact dynamic socket ids
+     */
+    export function ParseDebugLogTemplate(message: string): IDebugLogTemplateParseResult;
     export function getAllSupportedNativeNodeTypes(): string[];
     /**
      *
@@ -22283,7 +24199,7 @@ declare namespace BABYLON {
 
 
     export const COMMAND_MAGIC = 1111774037;
-    export const PROTOCOL_VERSION = 4;
+    export const PROTOCOL_VERSION = 5;
     export const MISSING_OFFSET = 4294967295;
     export enum Command {
         Scene = 1,
@@ -22295,7 +24211,9 @@ declare namespace BABYLON {
         Mesh = 7,
         Instance = 8,
         Animation = 9,
-        AnalyticPrimitive = 10
+        AnalyticPrimitive = 10,
+        ThinInstances = 11,
+        MorphTarget = 12
     }
     export enum AnalyticPrimitiveType {
         Cube = 0,
@@ -22310,19 +24228,33 @@ declare namespace BABYLON {
     }
     export enum AnimationTarget {
         Node = 0,
-        Bone = 1
+        Bone = 1,
+        MorphTarget = 2
     }
     export enum AnimationProperty {
         Position = 0,
         RotationQuaternion = 1,
         Scaling = 2,
-        Matrix = 3
+        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
@@ -23382,17 +25314,20 @@ declare namespace BABYLON {
         /** Number of times a failed file download is retried before giving up. PlayCanvas default `2`. */
         maxDownloadRetries?: number;
         /**
-         * GPU memory budget (in megabytes) for resident splats. When set (and smaller than the full dataset),
-         * LOD files are streamed through a fixed-size work buffer and unreferenced files are evicted to stay
-         * within budget, allowing datasets larger than a single full-dataset buffer. Converted to a splat count
-         * using the per-splat cost (core data plus any baked SH and rotation/scale textures). Combined with
-         * {@link maxResidentSplats} by taking the smaller of the two.
+         * Initial GPU/CPU memory estimate (in megabytes) for resident splats. It is converted to a splat count
+         * using the per-splat cost (core data plus any baked SH and rotation/scale textures), combined with
+         * {@link maxResidentSplats} by taking the smaller limit, then raised when necessary to fit the complete
+         * coarse layer. The work buffer has a fixed lifetime capacity; construct a new stream to use another limit.
+         * Finite non-positive values leave this limit unset; non-finite values are rejected.
          */
         memoryBudgetMb?: number;
         /**
-         * Maximum number of splats kept resident in the work buffer. When set (and smaller than the full
-         * dataset), enables eviction-based streaming (see {@link memoryBudgetMb}). Default unset = size the work
-         * buffer for the whole dataset (no eviction).
+         * Initial maximum number of splats kept resident in the fixed-size work buffer. It is raised when necessary
+         * to fit the complete coarse layer. When unset and the complete source size is known, streams retain the complete
+         * source. Streams that defer finer metadata use a bounded device-tiered default with coarse-derived refinement
+         * headroom.
+         * Finite non-positive values leave this limit unset; non-finite or unsafe positive counts are rejected.
+         * Positive fractional counts are floored to at least one splat before applying the coarse minimum.
          */
         maxResidentSplats?: number;
         /**
@@ -23422,10 +25357,10 @@ declare namespace BABYLON {
         /**
          * When true, higher-order spherical-harmonics carried by the SOG files (`shN`) are GPU-decoded into baked
          * packed-u32 SH textures so the streamed splats render with view-dependent lighting (matching the non-stream
-         * `.spz`/`.sog` path) instead of flat DC-only color. The SH degree is the max `shN.bands` across the streamed
-         * files (lower-band files neutral-fill). No effect when the files carry no `shN`. Defaults to `true`, matching
-         * the non-stream path's always-decode-if-present behavior; set to `false` to force flat DC-only color even
-         * when the data carries `shN` (e.g. to save the decode cost/texture memory).
+         * `.spz`/`.sog` path) instead of flat DC-only color. Streams with complete initial metadata use the maximum
+         * source SH degree. Streams that defer finer metadata reserve the supported degree-4 layout before it is known,
+         * even if the files ultimately carry no `shN`; lower-degree files neutral-fill the unused bands.
+         * Defaults to `true`; set to `false` to force flat DC-only color and avoid the SH decode cost/texture memory.
          */
         decodeSh?: boolean;
         /**
@@ -23470,6 +25405,7 @@ declare namespace BABYLON {
         private _hostBudgetAllocation;
         private _frustumCulling;
         private readonly _frustumPlanes;
+        private readonly _cullCameraViewProj;
         private readonly _cullViewProj;
         private readonly _frustumScratch;
         private _workBuffer;
@@ -23483,6 +25419,7 @@ declare namespace BABYLON {
         private _residency;
         private readonly _fileCounts;
         private readonly _fileMeta;
+        private readonly _baseFileIds;
         private readonly _decodedFiles;
         private readonly _loadingFiles;
         private readonly _decodeQueue;
@@ -23490,6 +25427,7 @@ declare namespace BABYLON {
         private readonly _cancelledDecodes;
         private _evictionEnabled;
         private _residentBudget;
+        private _minimumResidentSplats;
         private _maxResidentSplats;
         private _memoryBudgetMb;
         private _evictionCooldownFrames;
@@ -23501,6 +25439,7 @@ declare namespace BABYLON {
         private _environmentFiles;
         private _lodObserver;
         private _baseLayerReady;
+        private _metadataReady;
         private _framesSinceLodUpdate;
         private readonly _lastLodCamPositions;
         private _lastLodSignature;
@@ -23623,10 +25562,19 @@ declare namespace BABYLON {
         /**
          * 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.
+         * taking the smaller positive limit and raising it to {@link minimumResidentSplats}. With neither limit set,
+         * the complete source size is retained when known; otherwise a bounded device-tiered default is used.
+         * The fixed capacity is capped at the device texture limit. `0` means initial capacity has not been resolved.
          * @experimental
          */
         get residentSplatBudget(): number;
+        /**
+         * Minimum fixed work-buffer capacity required for the complete coarse representation: one invisible padding
+         * splat, the included environment, and every unique whole coarse source file. It is `0` until the required
+         * coarse metadata has resolved. Initial residency options below this value are raised to it.
+         * @experimental
+         */
+        get minimumResidentSplats(): 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.
@@ -23701,14 +25649,14 @@ declare namespace BABYLON {
         set debugLodSource(value: GaussianSplattingStreamDebugLodSource);
         dispose(doNotRecurse?: boolean): void;
         /**
-         * Disposes this stream (which tombstones its region) and then compacts the host once to actually reclaim the
-         * reserved rows. Used on a definitive load failure / empty result — a discrete, one-off reclaim, versus a bare
+         * Disposes this stream and, when hosted, compacts the host once to reclaim its tombstoned region's reserved
+         * rows. Used on a definitive load failure / empty result — a discrete, one-off reclaim, versus a bare
          * {@link dispose} that only tombstones so tearing down several parts doesn't rebuild the atlas repeatedly.
          */
         private _disposeAndReclaim;
         /**
          * The world matrix that actually places this stream's splats, used to map the camera into the space the
-         * node bounds live in (for LOD distance) and to build per-node world AABBs (for frustum culling). Standalone:
+         * node bounds live in (for LOD distance) and to build camera-local frusta (for frustum culling). Standalone:
          * this controller mesh carries the transform. Hosted: this controller is a hidden, unplaced node — the splats
          * are placed by the reserved part's proxy (SOG up-axis basis composed with the host's placement), so LOD and
          * culling MUST use the proxy's world matrix or they compute distances/frustum tests in the wrong space
@@ -23776,9 +25724,9 @@ declare namespace BABYLON {
          */
         private _collectLodEntries;
         /**
-         * Streams the scene: learns every source file's splat count, allocates one unified GPU work buffer
-         * sized for all LOD files, decodes the environment and the coarsest LOD of every node as a permanent
-         * base layer, then installs the per-frame loop that streams finer LODs on demand.
+         * Streams the scene. Large streams fetch only required coarse metadata before allocating and decoding the
+         * complete coarse layer; finer metadata starts afterwards so it cannot occupy the download queue ahead of
+         * visible geometry. Small streams and streams containing only coarse files retain an exact all-file capacity upper bound.
          */
         private _streamAllAsync;
         /**
@@ -23791,26 +25739,47 @@ declare namespace BABYLON {
          */
         private _waitForCanBackupAsync;
         /**
-         * Resolves the resident-splat budget from the raw options, sizing a memory (MB) budget with the actual per-splat
-         * GPU+CPU cost — core data plus the baked SH textures and rotation/scale textures when enabled — so SH/rotation
-         * assets don't silently consume up to double the configured budget. Requires the SH degree (from the metadata
-         * pre-pass) to be known. The smaller of the splat-count and memory budgets wins.
+         * Resolves the fixed initial work-buffer capacity. Explicit count/MB limits are combined by taking the smaller
+         * and then raised to the complete coarse minimum. Without an explicit limit, a known complete source retains
+         * legacy full residency. When finer metadata is deferred and the complete size is unknown, the device-tiered
+         * memory estimate is given at least one largest-coarse-file of headroom so one replacement file can refine
+         * while all coarse fallback files remain pinned.
+         * @param fullCapacity exact complete source capacity, or null when unavailable
+         * @param largestBaseFileCount largest whole coarse source file, used as modest replacement headroom
+         * @returns the fixed initial work-buffer capacity
          */
         private _resolveResidentBudget;
+        /**
+         * Returns the estimated combined GPU/CPU bytes occupied by one resident splat.
+         * @returns estimated bytes per resident splat
+         */
+        private _bytesPerResidentSplat;
         /**
          * Collects the unique set of source file indices referenced by any LOD of any leaf, sorted ascending.
          * @returns sorted unique file indices
          */
         private _collectAllFileIds;
+        /**
+         * Collects unique whole source files required by the coarsest entry of every valid leaf.
+         * @returns sorted unique coarse file indices
+         */
+        private _collectBaseFileIds;
+        /**
+         * Resolves the immutable minimum initial capacity from padding, environment, and unique whole coarse files.
+         * @param baseFileIds unique coarse source file indices
+         * @param environmentCount included environment splat count
+         */
+        private _resolveMinimumResidentSplats;
         /**
          * 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.
+         * Fetches the environment bundle and the supplied referenced files' metadata to learn splat counts, caching
+         * each file's parsed metadata for the later on-demand decode. File metadata fetches run in parallel.
          * @param fileIds file indices to fetch metadata for
+         * @param includeEnvironment whether to fetch the optional environment bundle in this phase
          * @returns the environment splat count (0 when there is no environment)
          */
         private _gatherCountsAsync;
@@ -23878,6 +25847,7 @@ declare namespace BABYLON {
          * Concurrent or repeat requests for the same file are ignored. If the file is cancelled mid-flight
          * (because every node that wanted it retargeted), the decode bails cooperatively at the next checkpoint.
          * @param fileId file index to decode
+         * @returns whether the file was decoded and published successfully
          */
         private _decodeFileAsync;
         /**
@@ -24042,6 +26012,22 @@ declare namespace BABYLON {
          * @returns whether any node's in-frustum state changed
          */
         private _updateNodeFrustum;
+        /**
+         * Normalizes an initial residency option, preserving finite non-positive values as an unset limit.
+         * @param value option value
+         * @param name option name used in errors
+         * @param integer whether the normalized value must be an integer splat count
+         * @returns normalized value
+         */
+        private static _NormalizeResidentLimit;
+        /**
+         * Adds trusted non-negative integer counts without allowing unsafe capacity arithmetic.
+         * @param left first count
+         * @param right second count
+         * @param label capacity name used in errors
+         * @returns the safe integer sum
+         */
+        private static _SafeAddCounts;
         /**
          * Reads the splat count from SOG metadata, coerced to a finite non-negative integer (metadata is untrusted, so
          * `count` / `shape[0]` may be a string or malformed — a non-numeric value must not leak into count arithmetic).
@@ -24964,12 +26950,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.
@@ -24992,6 +27049,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
@@ -25034,6 +27107,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;
@@ -25045,6 +27123,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.
@@ -25068,6 +27155,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;
@@ -25091,11 +27183,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;
@@ -25112,13 +27220,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;
@@ -25128,9 +27231,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
@@ -25165,6 +27320,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.
@@ -25179,6 +27517,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 {
@@ -25205,11 +27548,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;
     /**
@@ -25337,25 +27691,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";
@@ -25414,6 +27752,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 */
@@ -25423,6 +27915,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];
@@ -25458,11 +27954,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 */
@@ -25475,7 +28062,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. */
@@ -25526,8 +28113,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 */
@@ -25559,18 +28148,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 */
@@ -25589,6 +28228,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 */
@@ -25598,6 +28239,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 */
@@ -25622,6 +28265,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 */
@@ -25633,6 +28285,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) */
@@ -25649,6 +28303,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;
@@ -25657,11 +28317,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 */
@@ -25684,7 +28422,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. */
@@ -25805,7 +28543,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 */
@@ -25816,9 +28570,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) */
@@ -25829,7 +28589,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) */
@@ -25838,13 +28644,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 */
@@ -25883,6 +28695,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 */
@@ -25890,6 +28706,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 */
@@ -25912,13 +28736,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
@@ -25926,6 +28744,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 */