are there any edge cases where ref() is more beneficial than reactive() for nested objects

1. Handling Primitive Values: `ref()` can handle primitive values (e.g., strings, numbers, booleans) directly, whereas `reactive()` only works with objects and cannot handle primitives directly. This makes `ref()` more suitable for handling nested objects that contain primitive values[1][2][3].

2. Auto-unwrap in Templates: `ref()` automatically unwraps the value in templates, which can simplify code and reduce the need for `.value` property access. This can be beneficial when working with nested objects that contain primitive values[4].

3. Interoperability with Non-Reactive Objects: `ref()` can be used to create a reactive reference to a non-reactive object, which can be useful when working with legacy code or third-party libraries that do not use reactive objects. This interoperability can be beneficial in certain edge cases where `reactive()` might not be suitable[3].

4. Performance: In some cases, `ref()` might be more performant than `reactive()` because it does not create a proxy object for the entire nested object. This can be beneficial when working with large, deeply nested objects[2].

Here is an example of using `ref()` for nested objects with primitive values:

javascript
import { ref } from 'vue';

const user = ref({
  name: 'Michael Scott',
  address: {
    street: '123 Main St',
    city: 'Scranton',
    state: 'PA',
    zip: '12345'
  }
});

// Accessing nested properties
console.log(user.value.name); // logs Michael Scott
console.log(user.value.address.street); // logs 123 Main St

In summary, `ref()` is more beneficial than `reactive()` for nested objects in edge cases where handling primitive values, auto-unwrapping in templates, interoperability with non-reactive objects, and performance are important considerations.