Post processing AO renders on top of material like it's transparent

Hi!

I have written a rim lighting shader that renders meshes twice, first pass offset a little offset look like rim lighting. It looks like this:

The issue I'm experiencing is that the unity post processing stack AO is rendering on top of the rim lighting pass. Here is how that look (with an expanded rim lighting width to better show the issue:

Im also using the HBAO unity asset (https://assetstore.unity.com/packages/vfx/shaders/fullscreen-camera-effects/horizon-based-ambient-occlusion-54780) and it has the same issue. The pass also has issues with the post processing DOF effect. It seems to be treating the rim lighting pass as transparency.

Here is the complete shader code.

 Shader "Rim Lighting"  {
     Properties {
         _Color ("Main Color", Color) = (.5,.5,.5,1)
         _MainTex ("Base (RGB)", 2D) = "white" { }
     }
     
     CGINCLUDE
     #include "UnityCG.cginc"
     
     
     struct appdata {
         float4 vertex : POSITION;
         float3 normal : NORMAL;
         float4 texcoord : TEXCOORD0; // texture coordinates
     };
 
     struct v2f {
         float4 pos : SV_POSITION;
         UNITY_FOG_COORDS(0)
         fixed4 color : COLOR;
         float4 screenPos : TEXCOORD0;//
     };
     
     uniform float _Outline, _XOffset, _YOffset, _OutlineZ, _Brightness;
     sampler2D _MainTex;
     
     v2f vert(appdata v) {
         v2f o;
         o.pos = UnityObjectToClipPos(v.vertex);
         o.screenPos = ComputeScreenPos(o.pos);//
 
         float3 norm = normalize(mul ((float3x3)UNITY_MATRIX_IT_MV, v.vertex));
         float2 offset = TransformViewToProjection(norm.xy) + (float2(_XOffset, _YOffset) * 20);
         float4 tex = tex2Dlod(_MainTex, float4(v.texcoord.xy, 0, 0));
         
         #ifdef UNITY_Z_0_FAR_FROM_CLIPSPACE //to handle recent standard asset package on older version of unity (before 5.5)
             o.pos.xy += offset * UNITY_Z_0_FAR_FROM_CLIPSPACE(o.pos.z) * _Outline;
         #else
             o.pos.xy += offset * o.pos.z * _Outline;
         #endif
         o.pos.z -= (o.screenPos.z * _OutlineZ);
 
 
         o.color = tex * _Brightness * 1.1 * (unity_AmbientGround + unity_AmbientSky + unity_AmbientEquator);
         
 
         UNITY_TRANSFER_FOG(o,o.pos);
         return o;
     }
     ENDCG
 
     SubShader {
         Tags { "RenderType"="Opaque" "Queue" = "Geometry" }
         UsePass "Base/FORWARD"
         Pass {
             Name "OUTLINE"
             Tags { "LightMode" = "Always" }
 
             ZWrite On
             ColorMask RGB
             Blend One Zero
 
             CGPROGRAM
             #pragma vertex vert
             #pragma fragment frag
             #pragma multi_compile_fog
             fixed4 frag(v2f i) : SV_Target
             {
                 UNITY_APPLY_FOG(i.fogCoord, i.color);
                 return i.color;
             }
             ENDCG
         }
     }
     
     Fallback "Diffuse"
 }

and the base shader code:

 Shader "Base" {
     Properties {
         _MainTex ("Texture", 2D) = "white" {}
         _Color("Main Color", Color) = (.5,.5,.5,1)
     }
     SubShader {
         Tags { "RenderType"="Opaque" "Queue"="Geometry"}
 
         CGPROGRAM
         
         #pragma surface surf Standard fullforwardshadows
         #pragma target 3.0
 
         sampler2D _MainTex;
         fixed4 _Color;
 
         struct Input {
             float2 uv_MainTex;
         };
 
         void surf (Input i, inout SurfaceOutputStandard  o) {
             half4 tex = tex2D (_MainTex, i.uv_MainTex);
             float3 color = tex.rgb * _Color; 
             o.Albedo = color;
         }
 
         ENDCG
     }
     Fallback "Legacy Shaders/Diffuse"
 }

I also have some other custom shaders that have the same issue, the AO is rendered on top of it.