diff --git a/doc/api/diagnostics_channel.md b/doc/api/diagnostics_channel.md
index e5ace9abcfdddc..4ca30bf0e21952 100644
--- a/doc/api/diagnostics_channel.md
+++ b/doc/api/diagnostics_channel.md
@@ -231,6 +231,150 @@ diagnostics_channel.subscribe('my-channel', onMessage);
 diagnostics_channel.unsubscribe('my-channel', onMessage);
 ```
 
+#### `diagnostics_channel.bypass(key, fn[, thisArg[, ...args]])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active development
+
+* `key` {symbol|Object} The bypass identity token. Subscribers and
+  stores registered with the same `bypassId` value will be skipped
+  while this function executes.
+* `fn` {Function} The function to run with bypass active.
+* `thisArg` {any} The receiver to use for the function call.
+* `...args` {any} Optional arguments to pass to the function.
+* Returns: {any} The return value of `fn`.
+
+Calls `fn` and skips any channel subscribers or bound stores that
+were registered with a matching `bypassId` key. The skip behavior
+also applies to any async continuations (Promises, timers,
+microtasks) within `fn`.
+
+```mjs
+import diagnostics_channel from 'node:diagnostics_channel';
+import { request } from 'node:http';
+
+const { channel, bypass } = diagnostics_channel;
+
+// A unique token identifying this APM tool
+const kMyTracer = Symbol('my-tracer');
+
+// Subscribe to HTTP requests, but opt into bypass
+channel('http.client.request.start').subscribe((message) => {
+  console.log('HTTP request:', message.url);
+}, { bypassId: kMyTracer });
+
+// When exporting traces internally, use bypass() so the
+// above subscriber is NOT triggered for this internal request
+function exportTraces(data) {
+  bypass(kMyTracer, () => {
+    // This HTTP request will NOT trigger the subscriber above
+    const req = request('https://my-apm-backend.example.com/traces', {
+      method: 'POST',
+    });
+    req.end();
+  });
+}
+```
+
+```cjs
+const diagnostics_channel = require('node:diagnostics_channel');
+const { request } = require('node:http');
+
+const { channel, bypass } = diagnostics_channel;
+
+// A unique token identifying this APM tool
+const kMyTracer = Symbol('my-tracer');
+
+// Subscribe to HTTP requests, but opt into bypass
+channel('http.client.request.start').subscribe((message) => {
+  console.log('HTTP request:', message.url);
+}, { bypassId: kMyTracer });
+
+// When exporting traces internally, use bypass() so the
+// above subscriber is NOT triggered for this internal request
+function exportTraces(data) {
+  bypass(kMyTracer, () => {
+    // This HTTP request will NOT trigger the subscriber above
+    const req = request('https://my-apm-backend.example.com/traces', {
+      method: 'POST',
+    });
+    req.end();
+  });
+}
+```
+
+Without `bypass()`, the internal `exportTraces()` HTTP request
+would trigger the subscriber, which would try to export a trace
+of the export, causing infinite recursion.
+
+The bypass context propagates across async boundaries:
+
+```mjs
+// bypass() works across Promise boundaries
+await bypass(kMyTracer, async () => {
+  await someAsyncOperation(); // still bypassed
+  channel('http.client.request.start').publish({}); // subscriber skipped
+});
+
+// And across timers
+bypass(kMyTracer, () => {
+  setImmediate(() => {
+    // Still bypassed here
+    channel('http.client.request.start').publish({});
+  });
+});
+```
+
+```cjs
+(async () => {
+  await bypass(kMyTracer, async () => {
+    await someAsyncOperation();
+    channel('http.client.request.start').publish({});
+  });
+  bypass(kMyTracer, () => {
+    setImmediate(() => {
+      channel('http.client.request.start').publish({});
+    });
+  });
+})();
+```
+
+Multiple tools can each use their own `bypassId` without
+interfering with each other:
+
+```mjs
+const kToolA = Symbol('tool-a');
+const kToolB = Symbol('tool-b');
+
+channel('http.client.request.start').subscribe(handlerA, { bypassId: kToolA });
+channel('http.client.request.start').subscribe(handlerB, { bypassId: kToolB });
+
+// Only handlerA is skipped, handlerB still fires
+bypass(kToolA, () => {
+  channel('http.client.request.start').publish({});
+});
+```
+
+```cjs
+const diagnostics_channel = require('node:diagnostics_channel');
+
+const { channel, bypass } = diagnostics_channel;
+
+const kToolA = Symbol('tool-a');
+const kToolB = Symbol('tool-b');
+
+channel('http.client.request.start').subscribe(handlerA, { bypassId: kToolA });
+channel('http.client.request.start').subscribe(handlerB, { bypassId: kToolB });
+
+// Only handlerA is skipped, handlerB still fires
+bypass(kToolA, () => {
+  channel('http.client.request.start').publish({});
+});
+```
+
 #### `diagnostics_channel.tracingChannel(nameOrChannels)`
 
 <!-- YAML
@@ -414,13 +558,16 @@ channel.publish({
 });
 ```
 
-#### `channel.subscribe(onMessage)`
+#### `channel.subscribe(onMessage[, options])`
 
 <!-- YAML
 added:
  - v15.1.0
  - v14.17.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/63651
+    description: Added `options.bypassId` parameter.
   - version:
     - v24.8.0
     - v22.20.0
@@ -436,6 +583,10 @@ changes:
 * `onMessage` {Function} The handler to receive channel messages
   * `message` {any} The message data
   * `name` {string|symbol} The name of the channel
+* `options` {Object}
+  * `bypassId` {symbol|Object} An optional identity token. When
+    provided, this subscriber will be skipped while
+    [`diagnostics_channel.bypass()`][] is active with the same key.
 
 Register a message handler to subscribe to this channel. This message handler
 will be run synchronously whenever a message is published to the channel. Any
@@ -461,6 +612,8 @@ channel.subscribe((message, name) => {
 });
 ```
 
+See [`diagnostics_channel.bypass()`][] for usage with `bypassId`.
+
 #### `channel.unsubscribe(onMessage)`
 
 <!-- YAML
@@ -520,18 +673,26 @@ channel.subscribe(onMessage);
 channel.unsubscribe(onMessage);
 ```
 
-#### `channel.bindStore(store[, transform])`
+#### `channel.bindStore(store[, transform[, options]])`
 
 <!-- YAML
 added:
  - v19.9.0
  - v18.19.0
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/63651
+    description: Added `options.bypassId` parameter.
 -->
 
 > Stability: 1 - Experimental
 
 * `store` {AsyncLocalStorage} The store to which to bind the context data
 * `transform` {Function} Transform context data before setting the store context
+* `options` {Object}
+  * `bypassId` {symbol|Object} An optional identity token. When
+    provided, this bound store will be skipped while
+    [`diagnostics_channel.bypass()`][] is active with the same key.
 
 When [`channel.runStores(context, ...)`][] is called, the given context data
 will be applied to any store bound to the channel. If the store has already been
@@ -565,6 +726,8 @@ channel.bindStore(store, (data) => {
 });
 ```
 
+See [`diagnostics_channel.bypass()`][] for usage with `bypassId`.
+
 #### `channel.unbindStore(store)`
 
 <!-- YAML
@@ -756,7 +919,7 @@ simplify the process of producing events for tracing application flow.
 single `TracingChannel` at the top-level of the file rather than creating them
 dynamically.
 
-#### `tracingChannel.subscribe(subscribers)`
+#### `tracingChannel.subscribe(subscribers[, options])`
 
 <!-- YAML
 added:
@@ -770,6 +933,11 @@ added:
   * `asyncStart` {Function} The [`asyncStart` event][] subscriber
   * `asyncEnd` {Function} The [`asyncEnd` event][] subscriber
   * `error` {Function} The [`error` event][] subscriber
+* `options` {Object}
+  * `bypassId` {symbol|Object} An optional identity token. When
+    provided, ALL handlers (start, end, asyncStart, asyncEnd, error)
+    will be skipped while [`diagnostics_channel.bypass()`][] is
+    active with the same key.
 
 Helper to subscribe a collection of functions to the corresponding channels.
 This is the same as calling [`channel.subscribe(onMessage)`][] on each channel
@@ -823,6 +991,52 @@ channels.subscribe({
 });
 ```
 
+To opt all TracingChannel handlers into bypass behavior:
+
+```mjs
+import diagnostics_channel from 'node:diagnostics_channel';
+
+const { tracingChannel, bypass } = diagnostics_channel;
+const kMyTool = Symbol('my-tool');
+const tc = tracingChannel('my-operation');
+
+// All TracingChannel events skipped when bypass(kMyTool) is active
+tc.subscribe({
+  start(message) { /* ... */ },
+  end(message) { /* ... */ },
+  asyncStart(message) { /* ... */ },
+  asyncEnd(message) { /* ... */ },
+}, { bypassId: kMyTool });
+
+bypass(kMyTool, () => {
+  tc.traceSync(() => {
+    // Start and end handlers are NOT called
+  });
+});
+```
+
+```cjs
+const diagnostics_channel = require('node:diagnostics_channel');
+
+const { tracingChannel, bypass } = diagnostics_channel;
+const kMyTool = Symbol('my-tool');
+const tc = tracingChannel('my-operation');
+
+// All TracingChannel events skipped when bypass(kMyTool) is active
+tc.subscribe({
+  start(message) { /* ... */ },
+  end(message) { /* ... */ },
+  asyncStart(message) { /* ... */ },
+  asyncEnd(message) { /* ... */ },
+}, { bypassId: kMyTool });
+
+bypass(kMyTool, () => {
+  tc.traceSync(() => {
+    // Start and end handlers are NOT called
+  });
+});
+```
+
 #### `tracingChannel.unsubscribe(subscribers)`
 
 <!-- YAML
@@ -1930,6 +2144,7 @@ Emitted when a new thread is created.
 [`channel.unsubscribe(onMessage)`]: #channelunsubscribeonmessage
 [`channel.withStoreScope(data)`]: #channelwithstorescopedata
 [`child_process.spawn()`]: child_process.md#child_processspawncommand-args-options
+[`diagnostics_channel.bypass()`]: #diagnostics_channelbypasskey-fn-thisarg-args
 [`diagnostics_channel.channel(name)`]: #diagnostics_channelchannelname
 [`diagnostics_channel.subscribe(name, onMessage)`]: #diagnostics_channelsubscribename-onmessage
 [`diagnostics_channel.tracingChannel()`]: #diagnostics_channeltracingchannelnameorchannels
diff --git a/lib/diagnostics_channel.js b/lib/diagnostics_channel.js
index 7b78851208df66..49d0dbfb69c674 100644
--- a/lib/diagnostics_channel.js
+++ b/lib/diagnostics_channel.js
@@ -15,6 +15,7 @@ const {
   ReflectApply,
   SafeFinalizationRegistry,
   SafeMap,
+  SafeSet,
   SymbolDispose,
   SymbolHasInstance,
 } = primordials;
@@ -36,6 +37,33 @@ const { subscribers: subscriberCounts } = dc_binding;
 const { WeakReference, kEmptyObject } = require('internal/util');
 const { isPromise } = require('internal/util/types');
 
+let bypassStorage;
+
+function getBypassStorage() {
+  if (bypassStorage === undefined) {
+    const { AsyncLocalStorage } = require('async_hooks');
+    bypassStorage = new AsyncLocalStorage();
+  }
+  return bypassStorage;
+}
+
+function withBypassContext(set, fn, thisArg, args) {
+  return getBypassStorage().run(
+    set,
+    () => ReflectApply(fn, thisArg, args),
+  );
+}
+
+function validateBypassKey(value, name) {
+  if (value == null) {
+    throw new ERR_INVALID_ARG_TYPE(name, ['object', 'symbol'], value);
+  }
+  const type = typeof value;
+  if (type !== 'object' && type !== 'symbol') {
+    throw new ERR_INVALID_ARG_TYPE(name, ['object', 'symbol'], value);
+  }
+}
+
 // Can't delete when weakref count reaches 0 as it could increment again.
 // Only GC can be used as a valid time to clean up the channels map.
 class WeakRefMap extends SafeMap {
@@ -71,16 +99,36 @@ function markActive(channel) {
   // eslint-disable-next-line no-use-before-define
   ObjectSetPrototypeOf(channel, ActiveChannel.prototype);
   channel._subscribers = [];
+  channel._bypassSubscribers = null;
   channel._stores = new SafeMap();
+  channel._bypassStores = null;
+}
+
+function incRefIfNew(channel, isNew) {
+  if (isNew) {
+    channels.incRef(channel.name);
+    subscriberCounts[channel._index]++;
+  }
+}
+
+function decRefAndMaybeInactive(channel) {
+  channels.decRef(channel.name);
+  subscriberCounts[channel._index]--;
+  maybeMarkInactive(channel);
 }
 
 function maybeMarkInactive(channel) {
   // When there are no more active subscribers or bound, restore to fast prototype.
-  if (!channel._subscribers.length && !channel._stores.size) {
+  if (!channel._subscribers.length &&
+      !channel._stores.size &&
+      !channel._bypassSubscribers?.length &&
+      !channel._bypassStores?.size) {
     // eslint-disable-next-line no-use-before-define
     ObjectSetPrototypeOf(channel, Channel.prototype);
     channel._subscribers = undefined;
     channel._stores = undefined;
+    channel._bypassSubscribers = undefined;
+    channel._bypassStores = undefined;
   }
 }
 
@@ -91,12 +139,11 @@ class RunStoresScope {
     // eslint-disable-next-line no-restricted-globals
     using stack = new DisposableStack();
 
-    // Enter stores using withScope
+    // Normal stores, unchanged from before.
     if (activeChannel._stores) {
       for (const entry of activeChannel._stores.entries()) {
         const store = entry[0];
         const transform = entry[1];
-
         let newContext = data;
         if (transform) {
           try {
@@ -108,7 +155,28 @@ class RunStoresScope {
             continue;
           }
         }
+        stack.use(store.withScope(newContext));
+      }
+    }
 
+    // Bypass stores, only checked when bypass stores exist.
+    if (activeChannel._bypassStores) {
+      const activeKeys = getBypassStorage().getStore();
+      for (const entry of activeChannel._bypassStores.entries()) {
+        const store = entry[0];
+        const { transform, bypassId } = entry[1];
+        if (activeKeys?.has(bypassId)) continue;
+        let newContext = data;
+        if (transform) {
+          try {
+            newContext = transform(data);
+          } catch (err) {
+            process.nextTick(() => {
+              triggerUncaughtException(err, false);
+            });
+            continue;
+          }
+        }
         stack.use(store.withScope(newContext));
       }
     }
@@ -127,51 +195,101 @@ class RunStoresScope {
 
 // TODO(qard): should there be a C++ channel interface?
 class ActiveChannel {
-  subscribe(subscription) {
+  subscribe(subscription, options = kEmptyObject) {
     validateFunction(subscription, 'subscription');
-    this._subscribers = ArrayPrototypeSlice(this._subscribers);
-    ArrayPrototypePush(this._subscribers, subscription);
-    channels.incRef(this.name);
-    if (this._index !== undefined) subscriberCounts[this._index]++;
+    const bypassId = options?.bypassId;
+
+    if (bypassId !== undefined) {
+      validateBypassKey(bypassId, 'bypassId');
+      // Bypass path, lazy separate array only allocated when needed.
+      if (this._bypassSubscribers === null) {
+        this._bypassSubscribers = [];
+      }
+      this._bypassSubscribers = ArrayPrototypeSlice(this._bypassSubscribers);
+      ArrayPrototypePush(this._bypassSubscribers, { handler: subscription, bypassId });
+    } else {
+      // Normal path, plain function call with no extra overhead.
+      this._subscribers = ArrayPrototypeSlice(this._subscribers);
+      ArrayPrototypePush(this._subscribers, subscription);
+    }
+
+    incRefIfNew(this, true);
   }
 
   unsubscribe(subscription) {
     const index = ArrayPrototypeIndexOf(this._subscribers, subscription);
-    if (index === -1) return false;
-
-    const before = ArrayPrototypeSlice(this._subscribers, 0, index);
-    const after = ArrayPrototypeSlice(this._subscribers, index + 1);
-    this._subscribers = before;
-    ArrayPrototypePushApply(this._subscribers, after);
+    if (index !== -1) {
+      const before = ArrayPrototypeSlice(this._subscribers, 0, index);
+      const after = ArrayPrototypeSlice(this._subscribers, index + 1);
+      this._subscribers = before;
+      ArrayPrototypePushApply(this._subscribers, after);
+      decRefAndMaybeInactive(this);
+      return true;
+    }
 
-    channels.decRef(this.name);
-    if (this._index !== undefined) subscriberCounts[this._index]--;
-    maybeMarkInactive(this);
+    // Check bypass subscribers
+    if (this._bypassSubscribers !== null) {
+      let bypassIndex = -1;
+      for (let i = 0; i < this._bypassSubscribers.length; i++) {
+        if (this._bypassSubscribers[i].handler === subscription) {
+          bypassIndex = i;
+          break;
+        }
+      }
+      if (bypassIndex !== -1) {
+        const before = ArrayPrototypeSlice(this._bypassSubscribers, 0, bypassIndex);
+        const after = ArrayPrototypeSlice(this._bypassSubscribers, bypassIndex + 1);
+        this._bypassSubscribers = before;
+        ArrayPrototypePushApply(this._bypassSubscribers, after);
+        if (this._bypassSubscribers.length === 0) {
+          this._bypassSubscribers = null;
+        }
+        decRefAndMaybeInactive(this);
+        return true;
+      }
+    }
 
-    return true;
+    return false;
   }
 
-  bindStore(store, transform) {
-    const replacing = this._stores.has(store);
-    if (!replacing) {
-      channels.incRef(this.name);
-      if (this._index !== undefined) subscriberCounts[this._index]++;
+  bindStore(store, transform, options = kEmptyObject) {
+    const bypassId = options?.bypassId;
+
+    if (bypassId !== undefined) {
+      validateBypassKey(bypassId, 'bypassId');
+      // Bypass path, lazy separate SafeMap only allocated when needed.
+      if (this._bypassStores === null) {
+        this._bypassStores = new SafeMap();
+      }
+      const replacing = this._bypassStores.has(store);
+      incRefIfNew(this, !replacing);
+      this._bypassStores.set(store, { transform, bypassId });
+    } else {
+      // No bypassId provided: store as a plain transform function,
+      // matching the pre-bypass-feature behavior exactly.
+      const replacing = this._stores.has(store);
+      incRefIfNew(this, !replacing);
+      this._stores.set(store, transform);
     }
-    this._stores.set(store, transform);
   }
 
   unbindStore(store) {
-    if (!this._stores.has(store)) {
-      return false;
+    if (this._stores.has(store)) {
+      this._stores.delete(store);
+      decRefAndMaybeInactive(this);
+      return true;
     }
 
-    this._stores.delete(store);
-
-    channels.decRef(this.name);
-    if (this._index !== undefined) subscriberCounts[this._index]--;
-    maybeMarkInactive(this);
+    if (this._bypassStores?.has(store)) {
+      this._bypassStores.delete(store);
+      if (this._bypassStores.size === 0) {
+        this._bypassStores = null;
+      }
+      decRefAndMaybeInactive(this);
+      return true;
+    }
 
-    return true;
+    return false;
   }
 
   get hasSubscribers() {
@@ -179,17 +297,34 @@ class ActiveChannel {
   }
 
   publish(data) {
+    // Normal path, no ALS lookup, plain function call, zero overhead.
     const subscribers = this._subscribers;
-    for (let i = 0; i < (subscribers?.length || 0); i++) {
+    for (let i = 0; i < subscribers.length; i++) {
       try {
-        const onMessage = subscribers[i];
-        onMessage(data, this.name);
+        subscribers[i](data, this.name);
       } catch (err) {
         process.nextTick(() => {
           triggerUncaughtException(err, false);
         });
       }
     }
+
+    // Bypass path, only entered if bypass subscribers exist.
+    if (this._bypassSubscribers !== null) {
+      const activeKeys = getBypassStorage().getStore();
+      const bypassSubscribers = this._bypassSubscribers;
+      for (let i = 0; i < bypassSubscribers.length; i++) {
+        try {
+          const { handler, bypassId } = bypassSubscribers[i];
+          if (activeKeys?.has(bypassId)) continue;
+          handler(data, this.name);
+        } catch (err) {
+          process.nextTick(() => {
+            triggerUncaughtException(err, false);
+          });
+        }
+      }
+    }
   }
 
   withStoreScope(data) {
@@ -221,18 +356,18 @@ class Channel {
            prototype === ActiveChannel.prototype;
   }
 
-  subscribe(subscription) {
+  subscribe(subscription, options) {
     markActive(this);
-    this.subscribe(subscription);
+    this.subscribe(subscription, options);
   }
 
   unsubscribe() {
     return false;
   }
 
-  bindStore(store, transform) {
+  bindStore(store, transform, options) {
     markActive(this);
-    this.bindStore(store, transform);
+    this.bindStore(store, transform, options);
   }
 
   unbindStore() {
@@ -366,12 +501,12 @@ class BoundedChannel {
       this.end?.hasSubscribers;
   }
 
-  subscribe(handlers) {
+  subscribe(handlers, options) {
     for (let i = 0; i < boundedEvents.length; ++i) {
       const name = boundedEvents[i];
       if (!handlers[name]) continue;
 
-      this[name]?.subscribe(handlers[name]);
+      this[name]?.subscribe(handlers[name], options);
     }
   }
 
@@ -458,13 +593,13 @@ class TracingChannel {
       this.error?.hasSubscribers;
   }
 
-  subscribe(handlers) {
+  subscribe(handlers, options) {
     // Subscribe to call window (start/end)
     if (handlers.start || handlers.end) {
       this.#callWindow.subscribe({
         start: handlers.start,
         end: handlers.end,
-      });
+      }, options);
     }
 
     // Subscribe to continuation window (asyncStart/asyncEnd)
@@ -472,12 +607,12 @@ class TracingChannel {
       this.#continuationWindow.subscribe({
         start: handlers.asyncStart,
         end: handlers.asyncEnd,
-      });
+      }, options);
     }
 
     // Subscribe to error channel
     if (handlers.error) {
-      this.error.subscribe(handlers.error);
+      this.error.subscribe(handlers.error, options);
     }
   }
 
@@ -642,10 +777,22 @@ function tracingChannel(nameOrChannels) {
 
 dc_binding.linkNativeChannel((name) => channel(name));
 
+function bypass(key, fn, thisArg, ...args) {
+  validateFunction(fn, 'fn');
+
+  validateBypassKey(key, 'key');
+
+  const currentSet = getBypassStorage().getStore();
+  const next = currentSet ? new SafeSet(currentSet) : new SafeSet();
+  next.add(key);
+  return withBypassContext(next, fn, thisArg, args);
+}
+
 module.exports = {
   channel,
   hasSubscribers,
   subscribe,
+  bypass,
   tracingChannel,
   unsubscribe,
   boundedChannel,
diff --git a/test/parallel/test-diagnostics-channel-bypass.js b/test/parallel/test-diagnostics-channel-bypass.js
new file mode 100644
index 00000000000000..d3ddd3d4def2bf
--- /dev/null
+++ b/test/parallel/test-diagnostics-channel-bypass.js
@@ -0,0 +1,307 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { channel, bypass } = require('node:diagnostics_channel');
+const { AsyncLocalStorage } = require('async_hooks');
+
+// Test 1: Basic bypass - subscriber with bypassId is skipped inside bypass()
+{
+  const key = Symbol('tracer');
+  const ch = channel('test-bypass-basic');
+  const handler = common.mustNotCall();
+  ch.subscribe(handler, { bypassId: key });
+
+  bypass(key, common.mustCall(() => {
+    ch.publish({});
+  }));
+
+  ch.unsubscribe(handler);
+}
+
+// Test 2: Non-opted subscriber fires even inside bypass() scope
+{
+  const key = Symbol('tracer2');
+  const ch = channel('test-bypass-nonopted');
+  const optedHandler = common.mustNotCall();
+  const regularHandler = common.mustCall();
+  ch.subscribe(optedHandler, { bypassId: key });
+  ch.subscribe(regularHandler); // no bypass
+
+  bypass(key, common.mustCall(() => {
+    ch.publish({});
+  }));
+
+  ch.unsubscribe(optedHandler);
+  ch.unsubscribe(regularHandler);
+}
+
+// Test 3: Two APMs with different keys don't bypass each other
+{
+  const k1 = Symbol('k1');
+  const k2 = Symbol('k2');
+  const ch = channel('test-bypass-two-keys');
+  let h1Calls = 0;
+  let h2Calls = 0;
+  const h1 = common.mustCall(() => { h1Calls++; }, 1);
+  const h2 = common.mustCall(() => { h2Calls++; }, 1);
+  ch.subscribe(h1, { bypassId: k1 });
+  ch.subscribe(h2, { bypassId: k2 });
+
+  bypass(k1, common.mustCall(() => {
+    ch.publish({});
+  }));
+
+  assert.strictEqual(h1Calls, 0);
+  assert.strictEqual(h2Calls, 1);
+
+  bypass(k2, common.mustCall(() => {
+    ch.publish({});
+  }));
+
+  assert.strictEqual(h1Calls, 1);
+  assert.strictEqual(h2Calls, 1);
+
+  ch.unsubscribe(h1);
+  ch.unsubscribe(h2);
+}
+
+// Test 4: Nested bypass() calls (same key, different keys)
+{
+  const k1 = Symbol('nested1');
+  const k2 = Symbol('nested2');
+  const ch = channel('test-bypass-nested');
+  const h1 = common.mustNotCall();
+  let h2Calls = 0;
+  const h2 = common.mustCall(() => { h2Calls++; }, 2);
+  ch.subscribe(h1, { bypassId: k1 });
+  ch.subscribe(h2, { bypassId: k2 });
+
+  bypass(k1, common.mustCall(() => {
+    // Inside k1, h1 skipped, h2 runs
+    ch.publish({});
+    assert.strictEqual(h2Calls, 1);
+
+    bypass(k2, common.mustCall(() => {
+      // Inside both, both skipped
+      ch.publish({});
+      assert.strictEqual(h2Calls, 1);
+    }));
+
+    // Back to only k1
+    ch.publish({});
+    assert.strictEqual(h2Calls, 2);
+  }));
+
+  ch.unsubscribe(h1);
+  ch.unsubscribe(h2);
+}
+
+// Test 5: bypass() across a Promise boundary
+{
+  const key = Symbol('promise');
+  const ch = channel('test-bypass-promise');
+  const handler = common.mustNotCall();
+  ch.subscribe(handler, { bypassId: key });
+  const done = common.mustCall();
+
+  bypass(key, common.mustCall(async () => {
+    await Promise.resolve();
+    ch.publish({});
+  })).then(common.mustCall(() => {
+    ch.unsubscribe(handler);
+    done();
+  }));
+}
+
+// Test 6: bypass() across setImmediate and queueMicrotask
+{
+  const key = Symbol('timers');
+  const ch = channel('test-bypass-timers');
+  const handler = common.mustNotCall();
+  ch.subscribe(handler, { bypassId: key });
+  const done = common.mustCall();
+
+  bypass(key, common.mustCall(async () => {
+    await new Promise((resolve) => {
+      setImmediate(common.mustCall(() => {
+        ch.publish({});
+
+        queueMicrotask(common.mustCall(() => {
+          ch.publish({});
+          resolve();
+        }));
+      }));
+    });
+  })).then(common.mustCall(() => {
+    ch.unsubscribe(handler);
+    done();
+  }));
+}
+
+// Test 7: unsubscribe() works correctly after using bypassId
+{
+  const key = Symbol('unsub');
+  const ch = channel('test-bypass-unsubscribe');
+  const handler = common.mustNotCall();
+  ch.subscribe(handler, { bypassId: key });
+  ch.unsubscribe(handler);
+
+  // Should not throw and should not be called
+  bypass(key, common.mustCall(() => {
+    ch.publish({});
+  }));
+}
+
+// Test 8: bindStore with bypassId is skipped inside bypass()
+{
+  const key = Symbol('store');
+  const ch = channel('test-bypass-store');
+  const als = new AsyncLocalStorage();
+  const normalAls = new AsyncLocalStorage();
+
+  // Normal store, no bypassId, must always be entered.
+  ch.bindStore(normalAls, common.mustCall((data) => ({ value: data.value })));
+
+  // Bypass store, must NOT be entered inside bypass().
+  ch.bindStore(als, common.mustNotCall(), { bypassId: key });
+
+  // Handler verifies:
+  // - normal store WAS entered (normalAls has value)
+  // - bypass store was NOT entered (als is undefined)
+  const handler = common.mustCall(() => {
+    assert.strictEqual(normalAls.getStore()?.value, 42);
+    assert.strictEqual(als.getStore(), undefined);
+  });
+  ch.subscribe(handler);
+
+  bypass(key, common.mustCall(() => {
+    ch.runStores({ value: 42 }, common.mustCall());
+  }));
+
+  ch.unsubscribe(handler);
+  ch.unbindStore(als);
+  ch.unbindStore(normalAls);
+}
+
+// Test 9: Wrong type for bypassId throws ERR_INVALID_ARG_TYPE
+{
+  const ch = channel('test-bypass-wrong-type');
+  const bad = 'not-allowed';
+  assert.throws(() => ch.subscribe(() => {}, { bypassId: bad }), {
+    name: 'TypeError'
+  });
+  const als = new AsyncLocalStorage();
+  assert.throws(() => ch.bindStore(als, (d) => d, { bypassId: bad }), {
+    name: 'TypeError'
+  });
+}
+
+// Test 10: bypass() return value passes through fn's return value
+{
+  const key = Symbol('return');
+  const receiver = { value: 41 };
+  const result = bypass(key, common.mustCall(function(a, b) {
+    assert.strictEqual(this, receiver);
+    assert.strictEqual(a, 'a');
+    assert.strictEqual(b, 'b');
+    return this.value + 1;
+  }), receiver, 'a', 'b');
+  assert.strictEqual(result, 42);
+}
+
+// Test 11: TracingChannel traceSync respects bypass
+{
+  const { tracingChannel } = require('node:diagnostics_channel');
+  const key = Symbol('tracing-sync');
+  const tc = tracingChannel('test-bypass-tracing-sync');
+  const startHandler = common.mustNotCall();
+  const endHandler = common.mustNotCall();
+  const errorHandler = common.mustNotCall();
+
+  tc.subscribe({
+    start: startHandler,
+    end: endHandler,
+    error: errorHandler,
+  }, { bypassId: key });
+
+  bypass(key, common.mustCall(() => {
+    tc.traceSync(common.mustCall(), {});
+  }));
+
+  tc.unsubscribe({
+    start: startHandler,
+    end: endHandler,
+    error: errorHandler,
+  });
+}
+
+// Test 12: TracingChannel tracePromise respects bypass
+{
+  const { tracingChannel } = require('node:diagnostics_channel');
+  const key = Symbol('tracing-promise');
+  const tc = tracingChannel('test-bypass-tracing-promise');
+  const startHandler = common.mustNotCall();
+  const endHandler = common.mustNotCall();
+  const asyncStartHandler = common.mustNotCall();
+  const asyncEndHandler = common.mustNotCall();
+  const done = common.mustCall();
+
+  tc.subscribe({
+    start: startHandler,
+    end: endHandler,
+    asyncStart: asyncStartHandler,
+    asyncEnd: asyncEndHandler,
+  }, { bypassId: key });
+
+  bypass(key, common.mustCall(() => {
+    return tc.tracePromise(common.mustCall(() => Promise.resolve(42)), {});
+  })).then(common.mustCall(() => {
+    tc.unsubscribe({
+      start: startHandler,
+      end: endHandler,
+      asyncStart: asyncStartHandler,
+      asyncEnd: asyncEndHandler,
+    });
+    done();
+  }));
+}
+
+// Test 13: TracingChannel traceCallback respects bypass
+{
+  const { tracingChannel } = require('node:diagnostics_channel');
+  const key = Symbol('tracing-callback');
+  const tc = tracingChannel('test-bypass-tracing-callback');
+  const startHandler = common.mustNotCall();
+  const endHandler = common.mustNotCall();
+  const asyncStartHandler = common.mustNotCall();
+  const asyncEndHandler = common.mustNotCall();
+  const done = common.mustCall();
+
+  tc.subscribe({
+    start: startHandler,
+    end: endHandler,
+    asyncStart: asyncStartHandler,
+    asyncEnd: asyncEndHandler,
+  }, { bypassId: key });
+
+  bypass(key, common.mustCall(() => {
+    tc.traceCallback(
+      common.mustCall((cb) => setImmediate(cb, null, 'result')),
+      -1,
+      {},
+      null,
+      common.mustCall((err, res) => {
+        assert.strictEqual(err, null);
+        assert.strictEqual(res, 'result');
+        tc.unsubscribe({
+          start: startHandler,
+          end: endHandler,
+          asyncStart: asyncStartHandler,
+          asyncEnd: asyncEndHandler,
+        });
+        done();
+      })
+    );
+  }));
+}