I am adding another answer that more directly addresses your question and code, but which at the same time shows the problems with your approach.

There were several issues with your code, as follows:

• Your environment was set to use values of type Int, whereas a detent needs CGFloat
• Regardless, they were never used because MyDetent was returning a constant of 100 of the correct type, CGFloat, instead of returning the actual context.myValue
• You were setting the env value in many places, but you were never reading anywhere for actually passing it further to a view
• This is a problem since it means you can’t manipulate the value
• Even if you did read and adjusted the value, it wouldn’t change anything, because MyDetent would likely show the defaultValue
• To fix this and actually use the adjusted values, you’d need to read it again in the SheetPresenter, BUT use the .height parameter instead, which makes using a custom detent pointless (not that it made sense to use one in the first place).

So the conclusion is that for what you’re trying to achieve, you need the .height parameter anyway, and some kind of global value. And unless you have a specific reason for that to exist and be passed via environment, it would make much more sense for it to be a property of an observable object instead.

import SwiftUI

struct SheetCustomDetentRootView: View {
    
    @Environment(.myValue) private var myValue: CGFloat // <- Here, read the myValue from the environment

    var body: some View {
        SheetPresenterView()
            .environment(.myValue, myValue)
            // .environment(.myValue, myValue + 350) // <- Here, uncomment this (and comment out the line above) to pass a custom value via environment
    }
}

struct SheetPresenterView: View {
    
    @Environment(.myValue) private var myValue: CGFloat // <- Here, read the myValue from the environment
    @State private var shown = false
    
    var body: some View {
        Button("Show Sheet") {
            shown = true
        }
        .sheet(isPresented: $shown) {
            Text("My value from environment is: (Int(myValue))")
                .presentationDetents([.custom(MyDetent.self)])
                // .presentationDetents([.height(myValue)]) // <- Here, uncomment this (and comment out the line above) to use the value passed via environment
        }
    }
}

struct MyEnvKey: EnvironmentKey {
    static let defaultValue: CGFloat = 100
}

extension EnvironmentValues {
    var myValue: CGFloat {
        get { self[MyEnvKey.self] }
        set { self[MyEnvKey.self] = newValue }
    }
}

struct MyDetent: CustomPresentationDetent {
    static func height(in context: Context) -> CGFloat? {
        print(context.myValue)
        return context.myValue
    }
}

#Preview {
    SheetCustomDetentRootView()
}

Because I can’t wrap my mind around the need for a custom detent or environment values gymnastics, here’s a simpler example that uses:

• An observable class with a singleton to hold the max detent value
• A view that accepts optional parameters for adjusting the sheet height relative to the max detent value
• An internal state that allows further control if needed over the adjustment value

As such, you can:

• Define a general max detent value in the singleton class
• Update the max detent value as needed from anywhere (shown here as the textfield and stepper input of SomeTopView() )
• Call the view that has the sheet with an adjustment value or without one (in which case the sheet will have the max detent value height)
• Adjust the sheet height internally, if needed, in the same view as the sheet
• Lose less hair due to not having to worry about environment values or custom detents.

import SwiftUI

struct SheetDetentView: View {
    
    //State values
    @State private var settings = SomeObserverClass.settings
    
    var body: some View {
        
        VStack {
            SomeTopView()
                .background(.background.secondary)
                .frame(height: 100)
            
            SheetPresenter(adjustHeight: 20) //or simply SheetPresenter() if no adjustment needed
        }
    }
}

struct SomeTopView: View {
    
    //Bindings
    @Bindable private var settings = SomeObserverClass.settings
    
    var body: some View {
        
        Form {
            Section("Top View"){
                HStack {
                    Text("Set max height")
                        .fixedSize()
                    TextField("Height", value: $settings.maxDetentValue, formatter: NumberFormatter() )
                        .multilineTextAlignment(.center)
                        .background(.background.secondary)
                    Stepper("", value: $settings.maxDetentValue, in: 100...450, step: 50)
                }
            }
        }
        
    }
}

struct SheetPresenter: View {

    //Parameters
    var adjustHeight: CGFloat? = 0
    
    //Bindings
    @Bindable private var settings = SomeObserverClass.settings

    //State values
    @State private var adjustValue: CGFloat = 0
    @State private var shown = true
    
    var body: some View {
        
        Form {
            Section("Bottom Sheet Presenter View") {
                
                Text("Max height is: (settings.maxDetentValue, format: .number.precision(.fractionLength(0)) )")
                
                //Inputs
                HStack {
                    Text("Adjust height")
                        .fixedSize()
                    TextField("Height", value: $adjustValue, formatter: NumberFormatter() )
                        .multilineTextAlignment(.center)
                        .background(.background.secondary)
                    Stepper("", value: $adjustValue, in: 0...settings.maxDetentValue, step: 10)
                }
                
                Button("Toggle Sheet") {
                    shown.toggle()
                }
                .sheet(isPresented: $shown) {
                    let maxHeight = settings.maxDetentValue
                    let adjustedHeight = maxHeight - adjustValue
                    
                    Text("Adjust parameter is: (adjustValue, format: .number.precision(.fractionLength(0)) )")
                    .foregroundStyle(.secondary)
                    
                    Text("Adjusted height is: (adjustedHeight, format: .number.precision(.fractionLength(0)) )")
                    
                    Text("((Int(adjustValue)) below max detent value of (Int(maxHeight)) )")
                        .foregroundStyle(.secondary)
                        .padding(.top)

                        .interactiveDismissDisabled()
                        .presentationDragIndicator(.hidden)
                        .presentationBackgroundInteraction(.enabled)
                        .presentationDetents([.height(adjustedHeight), .large])
                        
                }
            }
        }
        .onAppear {
            //if a parameter is passed to the view, set the state value to the parameter value
            if let value = adjustHeight {
                adjustValue = value
            }
        }
    }
}


@Observable
class SomeObserverClass {
    
    var maxDetentValue: CGFloat = 350
    
    static let settings = SomeObserverClass() //singleton
    
    private init() {}
}

#Preview {
    SheetDetentView()
}

If you run the code above, you’ll get the following, which allows you to play around with the values and notice how sheet height changes thanks to the observable singleton: