@ObservableState crashes snapshots with bad access

[aj2109]

Description

I am trying to write a unit test that will snapshot a View that has an observableState reducer, however doing so causes bad access. I have produced a simple example to reproduce this below:

View and Reducer:

public struct DummyViewCrashes: View {
    let store: StoreOf<DummyReducerCrashes>
    public init(store: StoreOf<DummyReducerCrashes>) {
        self.store = store
    }
    public var body: some View {
        return Text("")
    }
}
@Reducer
public struct DummyReducerCrashes {
    @ObservableState
    public struct State: Equatable {}
    public enum Action {}
    public var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            }
        }
    }
}

public struct DummyViewNoCrashes: View {
    let store: StoreOf<DummyReducerNoCrashes>
    public init(store: StoreOf<DummyReducerNoCrashes>){
        self.store = store
    }
    public var body: some View {
        return Text("")
    }    
}

@Reducer
public struct DummyReducerNoCrashes {
    
    public struct State: Equatable {}
    
    public enum Action {}
    public var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            }
        }
    }
}

Unit test:

    @MainActor
    func testCrash() async throws {
        let view = DummyViewCrashes(store: .init(initialState: .init(), reducer: {
            DummyReducerCrashes()
        }))
                
        assertSnapshot(of: view, as: .dump)
    }
    
    @MainActor
    func testNoCrash() async throws {
        let view = DummyViewNoCrashes(store: .init(initialState: .init(), reducer: {
            DummyReducerNoCrashes()
        }))
                
        assertSnapshot(of: view, as: .dump)
    }`
    
    
    By contrast, a vanilla Observable model and SwiftUI vanilla view, does not crash:
    
    View and model:
    `@available(iOS 17.0, *)
@Observable
public class ObservableModel {
    let someText = ""
}

@available(iOS 17.0, *)
public struct VanillaView: View {
    @State var observableModel: ObservableModel
    public init(observableModel: ObservableModel) {
        self.observableModel = observableModel
    }
    public var body: some View {
        return Text("")
    }
}

Test:

  @available(iOS 17.0, *)
   @MainActor
   func testVanillaObservable() async throws {
       let view = VanillaView(observableModel: .init())
               
       assertSnapshot(of: view, as: .dump)
   }

Checklist

• I have determined whether this bug is also reproducible in a vanilla SwiftUI project.
• If possible, I've reproduced the issue using the main branch of this package.
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

The test runs and passes or fails

Actual behavior

The test crashes with Thread 1: EXC_BAD_ACCESS (code=2, address=0x16cbdbbe8) on let mirror = Mirror(reflecting: value) in private func snap<T>(_ value: T, name: String? = nil, indent: Int = 0) -> String {... in the Snapshotting class

Reproducing project

No response

The Composable Architecture version information

1.16.1

Destination operating system

iOS 18 iPhone 16 Pro sim

Xcode version information

Xcode 16.2

Swift Compiler version information

No response