ios – Image doesn’t fill entire widget

I am trying to build a widget for my app to show countdowns. In the background, it should have an image chosen by the user. Everything in the widget works mostly fine except that the image is not filling the entire widget. Initially, I thought the ZStack was only taking as much space as the VStack with the text needed, but I’ve tried commenting the VStack and it still has the space around it.
I have tried asking ChatGPT, Claude and Gemini, but all they tell me is to add .scaledToFill(), .frame(maxWidth: .infinity, maxHeight: .infinity), or .ignoresSafeArea(), but those don’t seem to work.
If I remove the .resizable(), the image gets way bigger than the widget.
This is the code I have:

struct SimpleEntry: TimelineEntry {
    let date: Date
    let configuration: ConfigurationAppIntent
}

let backgroundGradient = LinearGradient(
    colors: [Color.red, Color.blue],
    startPoint: .top, endPoint: .bottom)

struct CountdownsEntryView : View {
    var entry: Provider.Entry
    
    func daysLeftText(days_left: Int) -> String {
        var days_left_text: String = "\(days_left) days left"

        if days_left == 1 {
            days_left_text = "\(days_left) day left"
        }
        else if days_left == 0 {
            days_left_text = "Today!"
        }
        else if days_left < 0 {
            days_left_text = "\(abs(days_left)) days ago"
        }
        
        return days_left_text
    }

    var body: some View {
        ZStack {
            // Background image
            if let widgetImg = entry.configuration.countdown?.image,
               let uiImg = UIImage(data: widgetImg) {
                Image(uiImage: uiImg)
                    .resizable()
                    .scaledToFill()
            } else {
                // Fallback gradient if no image
                LinearGradient(
                    colors: [Color.purple, Color.blue],
                    startPoint: .top,
                    endPoint: .bottom
                )
            }
            
            // Text overlay
            VStack(spacing: 30) {
                Text(entry.configuration.countdown?.title ?? "Default")
                    .foregroundStyle(.white)
                    .font(.largeTitle)
                    .minimumScaleFactor(0.01)
                    .lineLimit(1)
                    .shadow(
                            color: Color.primary.opacity(0.5), /// shadow color
                            radius: 3, /// shadow radius
                            x: 0, /// x offset
                            y: 2 /// y offset
                        )

                Text(daysLeftText(days_left: daysLeft(date: entry.configuration.countdown?.date ?? Date())))
                    .foregroundStyle(.white)
                    .font(.title)
                    .minimumScaleFactor(0.01)
                    .lineLimit(1)
                    .shadow(
                            color: Color.primary.opacity(0.5), /// shadow color
                            radius: 3, /// shadow radius
                            x: 0, /// x offset
                            y: 2 /// y offset
                        )
            }
            .padding()
        }
    }
}

struct Countdowns: Widget {
    let kind: String = "Countdowns"

    var body: some WidgetConfiguration {
        AppIntentConfiguration(kind: kind, intent: ConfigurationAppIntent.self, provider: Provider()) { entry in
            CountdownsEntryView(entry: entry)
                .containerBackground(.fill, for: .widget)
//                .background(backgroundGradient)
        }
    }
}

When adding the image to the app, this is how I process it:

extension UIImage {
    func croppedToSquare() -> UIImage {
        // If image is already square, return as-is
        if size.width == size.height {
            return self
        }
        
        // Determine the side length (use the smaller dimension)
        let sideLength = min(size.width, size.height)
        
        // Calculate the crop rectangle (centered)
        let xOffset = (size.width - sideLength) / 2
        let yOffset = (size.height - sideLength) / 2
        let cropRect = CGRect(x: xOffset, y: yOffset, width: sideLength, height: sideLength)
        
        // Crop the image
        guard let cgImage = self.cgImage,
              let croppedCGImage = cgImage.cropping(to: cropRect) else {
            return self
        }
        
        return UIImage(cgImage: croppedCGImage, scale: self.scale, orientation: self.imageOrientation)
    }

    func resizedForWidget(maxWidth: CGFloat = 400) -> UIImage {
        // First crop to square
        let squareImage = croppedToSquare()
        
        // If already small enough, return as-is
        if squareImage.size.width <= maxWidth {
            return squareImage
        }
        
        // Resize to maxSize
        let newSize = CGSize(width: maxWidth, height: maxWidth)
        let renderer = UIGraphicsImageRenderer(size: newSize)
        return renderer.image { _ in
            squareImage.draw(in: CGRect(origin: .zero, size: newSize))
        }
    }
    
    // Alternative method with more aggressive compression for widgets
    func optimizedForWidget() -> UIImage {
        // Resize to maximum 300px for widgets (more conservative)
        let resized = resizedForWidget(maxWidth: 300)
        
        // Convert to JPEG and back to reduce file size
        guard let jpegData = resized.jpegData(compressionQuality: 0.8),
              let compressedImage = UIImage(data: jpegData) else {
            return resized
        }
        
        return compressedImage
    }
}

And this is how it looks in the widget:

Am I missing something? Could anyone help me with this?

Thanks.