fixup! async_hooks: add using scopes to AsyncLocalStorage

Author: Qard

doc/api/async_context.md

@@ -540,6 +540,48 @@ with JavaScript's `using` syntax.
 The scope automatically restores the previous store value when the `using` block
 exits, whether through normal completion or by throwing an error.
 
+### `scope.dispose()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Explicitly ends the scope and restores the previous store value. This method
+is idempotent: calling it multiple times has the same effect as calling it once.
+
+The `[Symbol.dispose]()` method defers to `dispose()`.
+
+If `withScope()` is called without the `using` keyword, `dispose()` must be
+called manually to restore the previous store value. Forgetting to call
+`dispose()` will cause the store value to persist for the remainder of the
+current execution context:
+
+```mjs
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const storage = new AsyncLocalStorage();
+
+// Without using, the scope must be disposed manually
+const scope = storage.withScope('my-store');
+// storage.getStore() === 'my-store' here
+
+scope.dispose(); // Restore previous value
+// storage.getStore() === undefined here
+```
+
+```cjs
+const { AsyncLocalStorage } = require('node:async_hooks');
+
+const storage = new AsyncLocalStorage();
+
+// Without using, the scope must be disposed manually
+const scope = storage.withScope('my-store');
+// storage.getStore() === 'my-store' here
+
+scope.dispose(); // Restore previous value
+// storage.getStore() === undefined here
+```
+
 ## Class: `AsyncResource`
 
 <!-- YAML

lib/internal/async_local_storage/run_scope.js

@@ -15,13 +15,17 @@ class RunScope {
     storage.enterWith(store);
   }
 
-  [SymbolDispose]() {
+  dispose() {
     if (this.#disposed) {
       return;
     }
     this.#disposed = true;
     this.#storage.enterWith(this.#previousStore);
   }
+
+  [SymbolDispose]() {
+    this.dispose();
+  }
 }
 
 module.exports = RunScope;

test/parallel/test-async-local-storage-run-scope.js

@@ -77,25 +77,59 @@ const { AsyncLocalStorage } = require('node:async_hooks');
   assert.strictEqual(storage.getStore(), 'before');
 }
 
-// Test idempotent disposal
+// Test idempotent disposal via named dispose() method
 {
   const storage = new AsyncLocalStorage();
 
   const scope = storage.withScope('test');
   assert.strictEqual(storage.getStore(), 'test');
 
-  // Dispose via Symbol.dispose
-  scope[Symbol.dispose]();
+  // Dispose via named dispose() method
+  scope.dispose();
   assert.strictEqual(storage.getStore(), undefined);
 
   storage.enterWith('test2');
   assert.strictEqual(storage.getStore(), 'test2');
 
   // Double dispose should be idempotent
-  scope[Symbol.dispose]();
+  scope.dispose();
   assert.strictEqual(storage.getStore(), 'test2');
 }
 
+// Test withScope without using keyword (scope leaks until manually disposed)
+{
+  const storage = new AsyncLocalStorage();
+
+  const scope = storage.withScope('leaked');
+  assert.strictEqual(storage.getStore(), 'leaked');
+
+  // Without using, the scope persists
+  assert.strictEqual(storage.getStore(), 'leaked');
+
+  // Must manually dispose via named method
+  scope.dispose();
+  assert.strictEqual(storage.getStore(), undefined);
+}
+
+// Test that dispose undoes enterWith called inside scope
+{
+  const storage = new AsyncLocalStorage();
+
+  storage.enterWith('store1');
+  assert.strictEqual(storage.getStore(), 'store1');
+
+  {
+    using _ = storage.withScope('store2');
+    assert.strictEqual(storage.getStore(), 'store2');
+
+    storage.enterWith('store3');
+    assert.strictEqual(storage.getStore(), 'store3');
+  }
+
+  // Restores to store1, undoing both withScope and the enterWith inside scope
+  assert.strictEqual(storage.getStore(), 'store1');
+}
+
 // Test RunScope with defaultValue
 {
   const storage = new AsyncLocalStorage({ defaultValue: 'default' });