Vertex Color Feature only works in editor

With Unity 2021.3.25f1 (using URP) I use a Custom Vertex Colors Feature to generate Outlines for a shader. This works perfectly fine in the editor but breaks in the windows build.

Using the Frame debugger I can see the problem lies in the Vertex Color Prepass

What it should looks like:

What it looks like:

The ScriptableRendererFeature:

 // using Unity.VisualScripting;
 using UnityEngine;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.Universal;
 
 [System.Serializable]
 public class VertexColorsFeature : ScriptableRendererFeature
 {
 
     class VertexColorsPass : ScriptableRenderPass {
         int kDepthBufferBits = 32;
         private RenderTargetHandle depthAttachmentHandle { get; set; }
         internal RenderTextureDescriptor descriptor { get; private set; }
 
         private Material internalVertexColorsMaterial = null;
         
         private FilteringSettings m_FilteringSettings;
         string m_ProfilerTag = "Vertex Color Prepass";
         ShaderTagId m_ShaderTagId = new ShaderTagId("DepthOnly");
 
         public VertexColorsPass(RenderQueueRange renderQueueRange, LayerMask layerMask, Material material)
         {
             m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
             internalVertexColorsMaterial = material;
         }
 
         public void Setup(RenderTextureDescriptor baseDescriptor, RenderTargetHandle depthAttachmentHandle)
         {
             this.depthAttachmentHandle = depthAttachmentHandle;
             baseDescriptor.colorFormat = RenderTextureFormat.ARGB32;
             baseDescriptor.depthBufferBits = kDepthBufferBits;
             descriptor = baseDescriptor;
         }
 
         // This method is called before executing the render pass.
         // It can be used to configure render targets and their clear state. Also to create temporary render target textures.
         // When empty this render pass will render to the active camera render target.
         // You should never call CommandBuffer.SetRenderTarget. Instead call <c>ConfigureTarget</c> and <c>ConfigureClear</c>.
         // The render pipeline will ensure target setup and clearing happens in an performance manner.
         public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
         {
             cmd.GetTemporaryRT(depthAttachmentHandle.id, descriptor, FilterMode.Point);
             ConfigureTarget(depthAttachmentHandle.Identifier());
             ConfigureClear(ClearFlag.All, Color.black);
         }
 
         // Here you can implement the rendering logic.
         // Use <c>ScriptableRenderContext</c> to issue drawing commands or execute command buffers
         // https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
         // You don't have to call ScriptableRenderContext.submit, the render pipeline will call it at specific points in the pipeline.
         public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
         {
             CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
             ProfilingSampler sampler = new ProfilingSampler(m_ProfilerTag);
             using (new UnityEngine.Rendering.ProfilingScope(cmd, sampler))
             {
                 context.ExecuteCommandBuffer(cmd);
                 cmd.Clear();
 
                 var sortFlags = renderingData.cameraData.defaultOpaqueSortFlags;
                 // sortFlags = sortingFlags;
                 var drawSettings = CreateDrawingSettings(m_ShaderTagId, ref renderingData, sortFlags);
                 drawSettings.perObjectData = PerObjectData.None;
 
 
                 // ref CameraData cameraData = ref renderingData.cameraData;
                 // Camera camera = cameraData.camera;
                 // if (cameraData.isStereoEnabled)
                 //     context.StartMultiEye(camera);
 
 
                 drawSettings.overrideMaterial = internalVertexColorsMaterial;
 
 
                 context.DrawRenderers(renderingData.cullResults, ref drawSettings,
                     ref m_FilteringSettings);
 
                 cmd.SetGlobalTexture("_CameraVertexColorsTexture", depthAttachmentHandle.id);
             }
 
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
         }
 
         /// Cleanup any allocated resources that were created during the execution of this render pass.
         public override void FrameCleanup(CommandBuffer cmd)
         {
             if (depthAttachmentHandle != RenderTargetHandle.CameraTarget)
             {
                 cmd.ReleaseTemporaryRT(depthAttachmentHandle.id);
                 depthAttachmentHandle = RenderTargetHandle.CameraTarget;
             }
         }
     }
 
     VertexColorsPass vertexColorsPass;
     RenderTargetHandle vertexColorsTexture;
     [SerializeField] Material vertexColorsMaterial;
     [SerializeField] LayerMask layerMask;
     // [SerializeField] Shader vertexColorShader;
 
     private Material vertexMaterialCopy;
     public override void Create(){
         // try{
            vertexMaterialCopy = new Material(vertexColorsMaterial);
             // vertexColorsMaterial = CoreUtils.CreateEngineMaterial(vertexColorShader);//"Shader Graphs/VertexColor");
             // vertexColorsMaterial = CoreUtils.CreateEngineMaterial("Shader Graphs/VertexColor");
             vertexColorsPass = new VertexColorsPass(RenderQueueRange.opaque, layerMask, vertexMaterialCopy);
             vertexColorsPass.renderPassEvent = RenderPassEvent.AfterRenderingPrePasses;
             vertexColorsTexture.Init("_CameraVertexColorsTexture");
         // }catch (System.Exception){ 
         //     Debug.Log("mute boot error");
         // }
         
         
     }
 
 
     // Here you can inject one or multiple render passes in the renderer.
     // This method is called when setting up the renderer once per-camera.
     public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
     {
         vertexColorsPass.Setup(renderingData.cameraData.cameraTargetDescriptor, vertexColorsTexture);
         renderer.EnqueuePass(vertexColorsPass);
     }
 }