Handling of shared objects (>1 object reference)

[joshkel]

According to #159:

Having more than one path from the root to the same node without introducing a cycle (i.e. a DAG with shared nodes) is fine and is something Mutative supports.

Internally, each underlying source object is drafted at most once, and all references to that object share the same draft. Mutating it through one path is reflected through any other path that points to the same object.

However, this doesn't seem to work in my testing:

  const obj = {};
  obj.color1 = obj.color2 = { name: 'Red' };
  console.log('Same object:', obj.color1 === obj.color2);
  const result = create(obj, (draft) => {
    draft.color1.name = 'Blue';
    console.log('Same object within mutate:', draft.color1 === draft.color2);
  });
  console.log('Same object after:', result.color1 === result.color2);
  console.log(result);

Output:

Same object: true
Same object within mutate: false
Same object after: false
{ color2: { name: 'Red' }, color1: { name: 'Blue' } }

Based on the discussion in #159, I expected it to be the same object each time, and I expected the result to be { color1: { name: 'Blue' }, color2: { name: 'Blue' } }.

It's also possible that I've misunderstood or am making some other mistake.

This issue isn't immediately affecting me, but it seems inconsistent with previous discussions, and I'd like to at least understand what's going on.

Thanks!

[unadlib]

Thank you for the detailed reproduction and apologies for the confusion caused by my previous statement in #159.

My previous description was inaccurate. I stated:

Internally, each underlying source object is drafted at most once, and all references to that object share the same draft.

This is not how Mutative (or Immer) actually works. Your test correctly demonstrates the actual behavior.

What Actually Happens

When the same object is referenced from multiple paths in the base state, Mutative creates independent drafts for each path:

const obj = {};
obj.color1 = obj.color2 = { name: 'Red' };

const result = create(obj, (draft) => {
  // draft.color1 and draft.color2 are DIFFERENT drafts
  // even though they reference the same original object
  draft.color1 === draft.color2;  // false
  
  draft.color1.name = 'Blue';
  draft.color2.name;  // still 'Red'
});

result.color1 === result.color2;  // false
// { color1: { name: 'Blue' }, color2: { name: 'Red' } }

This is by design and matches Immer's behavior. See Immer's own test case:

// From Immer's test suite
it('supports a base state with multiple references to an object', () => {
  const obj = {};
  const res = produce({ a: obj, b: obj }, (d) => {
    // "Two drafts are created for each occurrence of an object in the base state."
    expect(d.a).not.toBe(d.b);
    d.a.z = true;
    expect(d.b.z).toBeUndefined();
  });
});

What IS Supported

If you need shared references in the result, you can manually create them within the recipe:

const result = create(obj, (draft) => {
  draft.color1.name = 'Blue';
  draft.color2 = draft.color1;  // Explicitly share the reference
});

result.color1 === result.color2;  // true ✅
// { color1: { name: 'Blue' }, color2: { name: 'Blue' } }

Summary

Scenario	Behavior
Same object via multiple paths in base state	Each path gets independent draft
Manually assign draft.x = draft.y	✅ Creates shared reference in result
Expect automatic preservation of original sharing	❌ Not supported

I'll update the documentation and my previous response in #159 to reflect this accurately. Thanks for catching this inconsistency!