Normals in TEXCOORDS2 messed up, unless object inverted

I'm working on an outline shader what will be used as a URP render feature.

I'm doing this with the normal extrude method, where for the outline pass, all the vertices are shifted along their world normal. This works as expected, but I want to use custom, smoothed normals stored in a uv channel.

To sanity test the method, I am just passing the unmodified normals into TEXCOORD2. Code for this is:

 void Start()
 {
   var mf = GetComponent<MeshFilter>();
   var mesh = mf.mesh;
   mesh.SetUVs(2, mesh.normals);
 }

and shader is:

 Shader "Outlines/BackFaceOutlines" {
   Properties{
       _Thickness("Thickness", Float) = 1 // The amount to extrude the outline mesh
       _Color("Color", Color) = (1, 1, 1, 1) // The outline color
       // If enabled, this shader will use "smoothed" normals stored in TEXCOORD1 to extrude along
       [Toggle(USE_PRECALCULATED_OUTLINE_NORMALS)]_PrecalculateNormals("Use UV1 normals", Float) = 0
   }
 
   SubShader{
     Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" }
 
     Pass {
       Name "Outline"
       // Cull front faces
       Cull Front
       
       HLSLPROGRAM
       // Standard URP requirements
       #pragma prefer_hlslcc gles
       #pragma exclude_renderers d3d11_9x
 
       // Register our material keywords
       #pragma shader_feature USE_PRECALCULATED_OUTLINE_NORMALS
 
       // Register our functions
       #pragma vertex Vertex
       #pragma fragment Fragment
 
       // Include helper functions from URP
       #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
 
       // Data from the meshes
       struct Attributes {
         float4 positionOS       : POSITION; // Position in object space
         float3 normalOS         : NORMAL; // Normal vector in object space
       #ifdef USE_PRECALCULATED_OUTLINE_NORMALS
         float3 smoothNormalOS   : TEXCOORD2; // Calculated "smooth" normals to extrude along in object space
       #endif
       };
 
       // Output from the vertex function and input to the fragment function
       struct VertexOutput {
         float4 positionCS   : SV_POSITION; // Position in clip space
       };
 
       // Properties
       float _Thickness;
       float4 _Color;
 
       VertexOutput Vertex(Attributes input) {
         VertexOutput output;
 
         float3 normalOS;
       #ifdef USE_PRECALCULATED_OUTLINE_NORMALS
         normalOS = input.smoothNormalOS;
       #else
         normalOS = input.normalOS;
       #endif
 
         float4 worldPos = mul(unity_ObjectToWorld, input.positionOS);
         float4 worldNorm = mul(unity_ObjectToWorld, float4(normalOS, 0));
 
         worldPos += normalize(worldNorm) * _Thickness;
 
         // Convert this position to world and clip space
         output.positionCS = mul(UNITY_MATRIX_VP, worldPos);
 
         return output;
       }
 
       float4 Fragment(VertexOutput input) : SV_Target {
         return _Color;
       }
 
       ENDHLSL
     }
   }
 }

This is based on this example, btw

Using the normal channel, everything works as expected:

But using TEXCOORD2:

Now this very much confuses me, as surely the values should be the same; I'm copying the unmodified normal array to the uv array. All the handling of the values in the shader is the same, so somehow the values must be getting mangled in the uv array? Is something else targeting this channel?

Most confusing though, when the object is inverted (an odd number of axis' scale is negative), it works perfectly again. I'm out of attachments for this post, but trust me, it's outlining as expected

Any ideas on what is going on? How to fix this?