Misaligned depth and rgb image truedepth from vga streaming

I'm currently streaming synchronised video and depth data from my iPhone 13, using AVFoundation, video set to AVCaptureSession.Preset.vga640x480. When looking at the corresponding images (with depth values mapped to a grey colour map), (both map and image are of size 640x480) it appears the two feeds have different fields of view, with the depth feed zoomed in and angled upwards, and the colour feed more zoomed out. I've looked at the intrinsics from both the depth map, and my colour sample buffer, they are identical. Does anyone know why this might be? My setup code is below (shortened):

import AVFoundation import CoreVideo class VideoCaptureManager {

private enum SessionSetupResult {
    case success
    case notAuthorized
    case configurationFailed
}

private enum ConfigurationError: Error {
    case cannotAddInput
    case cannotAddOutput
    case defaultDeviceNotExist
}

private let videoDeviceDiscoverySession = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInTrueDepthCamera],
                                                                           mediaType: .video,
                                                                           position: .front)


private let session = AVCaptureSession()
public let videoOutput = AVCaptureVideoDataOutput()
public let depthDataOutput = AVCaptureDepthDataOutput()
private var outputSynchronizer: AVCaptureDataOutputSynchronizer?
private var videoDeviceInput: AVCaptureDeviceInput!

private let sessionQueue = DispatchQueue(label: "session.queue")
private let videoOutputQueue = DispatchQueue(label: "video.output.queue")

private var setupResult: SessionSetupResult = .success

init() {
            sessionQueue.async {
        self.requestCameraAuthorizationIfNeeded()
    }

    sessionQueue.async {
        self.configureSession()
    }
    
    sessionQueue.async {
        self.startSessionIfPossible()
    }
}


private func requestCameraAuthorizationIfNeeded() {
    switch AVCaptureDevice.authorizationStatus(for: .video) {
    case .authorized:
        break
    case .notDetermined:
        AVCaptureSession
        sessionQueue.suspend()
        AVCaptureDevice.requestAccess(for: .video, completionHandler: { granted in
            if !granted {
                self.setupResult = .notAuthorized
            }
            self.sessionQueue.resume()
        })
    default:
        setupResult = .notAuthorized
    }
}
private func configureSession() {
    if setupResult != .success {
        return
    }
    
    let defaultVideoDevice: AVCaptureDevice? = videoDeviceDiscoverySession.devices.first
    
    guard let videoDevice = defaultVideoDevice else {
        print("Could not find any video device")
        setupResult = .configurationFailed
        return
    }
    
    do {
        videoDeviceInput = try AVCaptureDeviceInput(device: videoDevice)
    } catch {
        setupResult = .configurationFailed
        return
    }
    
    session.beginConfiguration()
    session.sessionPreset = AVCaptureSession.Preset.vga640x480
    
    guard session.canAddInput(videoDeviceInput) else {
        print("Could not add video device input to the session")
        setupResult = .configurationFailed
        session.commitConfiguration()
        return
    }
    session.addInput(videoDeviceInput)
    
    if session.canAddOutput(videoOutput) {
        session.addOutput(videoOutput)
        if let connection = videoOutput.connection(with: .video) {
            
            connection.isCameraIntrinsicMatrixDeliveryEnabled = true
        }
        else {
            print("Cannot setup camera intrinsics")
        }
        videoOutput.videoSettings = [kCVPixelBufferPixelFormatTypeKey as String: Int(kCVPixelFormatType_32BGRA)]
        
    } else {
        print("Could not add video data output to the session")
        setupResult = .configurationFailed
        session.commitConfiguration()
        return
    }
  
    if session.canAddOutput(depthDataOutput) {
        session.addOutput(depthDataOutput)
        depthDataOutput.isFilteringEnabled = false
        if let connection = depthDataOutput.connection(with: .depthData) {
            connection.isEnabled = true
        } else {
            print("No AVCaptureConnection")
        }
    } else {
        print("Could not add depth data output to the session")
        setupResult = .configurationFailed
        session.commitConfiguration()
        return
    }
    let depthFormats = videoDevice.activeFormat.supportedDepthDataFormats
    let filtered = depthFormats.filter({
        CMFormatDescriptionGetMediaSubType($0.formatDescription) == kCVPixelFormatType_DepthFloat16
    })
    let selectedFormat = filtered.max(by: {
        first, second in CMVideoFormatDescriptionGetDimensions(first.formatDescription).width < CMVideoFormatDescriptionGetDimensions(second.formatDescription).width
    })
    
    do {
        try videoDevice.lockForConfiguration()
        videoDevice.activeDepthDataFormat = selectedFormat
        videoDevice.unlockForConfiguration()
    } catch {
        print("Could not lock device for configuration: \(error)")
        setupResult = .configurationFailed
        session.commitConfiguration()
        return
    }

    session.commitConfiguration()
}    
private func addVideoDeviceInputToSession() throws {
    do {
        var defaultVideoDevice: AVCaptureDevice?

        defaultVideoDevice = AVCaptureDevice.default(
            .builtInTrueDepthCamera,
            for: .depthData,
            position: .front
            
        )
        guard let videoDevice = defaultVideoDevice else {
            print("Default video device is unavailable.")
            setupResult = .configurationFailed
            session.commitConfiguration()
            
            throw ConfigurationError.defaultDeviceNotExist
        }
        
        let videoDeviceInput = try AVCaptureDeviceInput(device: videoDevice)
        
        if session.canAddInput(videoDeviceInput) {
            session.addInput(videoDeviceInput)
        } else {
            setupResult = .configurationFailed
            session.commitConfiguration()
            
            throw ConfigurationError.cannotAddInput
        }
    }