fix(suppress-warnings): don't clobber concurrent suppressions in finally

`withSuppressedWarnings` snapshotted `process.emitWarning` at entry and
restored that snapshot in `finally`. If another caller had already
installed the suppression wrapper (via `suppressMaxListenersWarning()`
or a prior `suppressWarningType()`), the snapshot was the wrapper
itself — restoring it was a harmless no-op. But if this was the first
caller, the snapshot was the native `emitWarning` and the `finally`
uninstalled the wrapper we just put in place. Any later
`suppressWarningType()` calls would see `originalEmitWarning` already
set and skip the re-wrap, so subsequent suppressions silently stopped
working — a spooky-action regression that's hard to diagnose.

The wrapper is data-driven by the `suppressedWarnings` set, so
"restoring" simply means removing this type from the set. Drop the
`process.emitWarning` reassignment entirely.

Author: jdalton

src/suppress-warnings.ts

@@ -160,15 +160,19 @@ export async function withSuppressedWarnings<T>(
   callback: () => T | Promise<T>,
 ): Promise<T> {
   const wasAlreadySuppressed = suppressedWarnings.has(warningType)
-  const original = process.emitWarning
   suppressWarningType(warningType)
   try {
     return await callback()
   } finally {
-    // Only remove from suppressed set if we added it.
+    // The wrapper is driven by `suppressedWarnings` membership, so
+    // removing this type from the set is enough to stop suppressing it.
+    // Do NOT reassign `process.emitWarning` here: snapshotting the
+    // previous value at the top would either (a) capture the native
+    // function when the wrapper was already installed and then restore
+    // native — wiping every other active suppression — or (b) be the
+    // wrapper itself, in which case the restore is a no-op anyway.
     if (!wasAlreadySuppressed) {
       suppressedWarnings.delete(warningType)
     }
-    process.emitWarning = original
   }
 }

test/unit/suppress-warnings.test.mts

@@ -161,15 +161,24 @@ describe('suppress-warnings', () => {
   })
 
   describe('withSuppressedWarnings', () => {
-    it('should restore warnings after callback completes', async () => {
+    it('does not wipe concurrent suppressions on exit', async () => {
+      // Regression: the old implementation snapshotted
+      // `process.emitWarning` at the top and restored it in `finally`.
+      // If another caller had already installed a suppression wrapper,
+      // `withSuppressedWarnings` would uninstall it on exit, silently
+      // breaking the other caller's suppression. The fix is to not
+      // reassign `process.emitWarning` in `finally` at all — the
+      // wrapper is driven by the `suppressedWarnings` set.
       restoreWarnings()
-      const original = process.emitWarning
-
+      // Outer caller: install a long-lived suppression wrapper.
+      suppressWarningType('OtherWarning')
+      const wrapperAfterOuter = process.emitWarning
+      // Inner: withSuppressedWarnings runs and exits.
       await withSuppressedWarnings('TestWarning', () => {
-        // Nothing
+        // no-op
       })
-
-      expect(process.emitWarning).toBe(original)
+      // Wrapper must still be installed so OtherWarning stays suppressed.
+      expect(process.emitWarning).toBe(wrapperAfterOuter)
     })
 
     it('should handle callback errors', async () => {