Is it intended to be added as stable ?
Otherwise add > Stability: 1 - Experimental here.

I think it's not the previous context. It's that one seen at the time use() was called.
If use and the matching dispose are called in right order this is the same but if they are called in different order it's not.

e.g. a cast like this (condensed, in real world this would be distributed at independent locations):

const { AsyncLocalStorage } = require("node:async_hooks");

const als1 = new AsyncLocalStorage();
const als2 = new AsyncLocalStorage();

const d1 = als1.use(store1);
const d2 = als2.use(store2);
const d3 = als1.use(store3);
als1.getStore(); // Returns store3
als2.getStore(); // Returns store2

d1[Symbol.dispose]();
als1.getStore(); // Returns undefined
als2.getStore(); // Returns undefined

d2[Symbol.dispose]();
als1.getStore(); // Returns store1
als2.getStore(); // Returns undefined

d3[Symbol.dispose]();
als1.getStore(); // Returns store1
als2.getStore(); // Returns store2

Likely a user problem and once using is a thing harder to do.
But I think it should be clear documented what happens or avoid such cases.

In special that one ALS user might effect others is critical in my opinion.

Note that only the AsyncContextFrame variant shows side effects to all ALS users.

I think if folks are manually calling Symbol.dispose they're rather on their own at that point. It's a bit unfortunate that the ERM model gives them that ability but there's only do much we can do.

That said, we'll want to be sure that this works as expected when using DisposableStack when that is available.

I fully agree once using keyword is a thing. But until this is true users have to do it manually.

I notices that the side effect to other ALS instances is not bound to wrong usage of dispose:

const d1 = als1.use("store1");
als2.enterWith("store2");
console.log(als1.getStore()); // store1
console.log(als2.getStore()); // store2
d1[Symbol.dispose]();
console.log(als1.getStore()); // undefined
console.log(als2.getStore()); // undefined, but should be store2

I noticed that this global side effect is not new in the AsyncContextFrame variant. See #58149.

use() is intended to roughly mimic run(), and since that's been changed in #58149 to isolate the storage instances, I'll do that here as well in the next rev.

I guess by capturing/restoring only the owned store instead the complete frame the side effects to other ALS users could be avoided.

Agreed, an operation on an AsyncLocalStorage should not affect other instances. For reference: tc39/proposal-async-context-disposable#2

using works meanwhile on main (see #58154) therefore this should be updated accordingly.