diff --git a/doc/api/util.md b/doc/api/util.md
index 52e2c06b09ff..a667f3c259dc 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -387,6 +387,86 @@ The `--throw-deprecation` command-line flag and `process.throwDeprecation`
 property take precedence over `--trace-deprecation` and
 `process.traceDeprecation`.
 
+## `util.debounce(fn, wait[, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `fn` {Function} The function to debounce.
+* `wait` {integer} The number of milliseconds to delay `fn`.
+* `options` {Object}
+  * `rejectOnCancel` {boolean} When `true`, a call superseded by a later call
+    rejects with an `AbortError`. **Default:** `false`.
+  * `signal` {AbortSignal} An `AbortSignal` that cancels a pending call when
+    aborted.
+* Returns: {Function} The debounced function.
+
+Creates a function that delays calling `fn` until `wait` milliseconds have
+elapsed since the most recent invocation. The debounced function returns a
+{Promise} for the value returned by `fn`. If `fn` throws or returns a rejected
+promise, the returned promise is rejected with the same reason.
+
+When the debounced function is called more than once before the delay expires,
+`fn` receives the arguments from the most recent call. By default, the promises
+from all calls resolve or reject with the result of that invocation. If
+`options.rejectOnCancel` is `true`, the promises from superseded calls reject
+with an `AbortError` instead.
+
+The returned function has the following properties:
+
+* `cancel([reason])` cancels the pending invocation. Its pending promises reject
+  with an `AbortError`. If provided, `reason` is set as the error's `cause`.
+* `flush()` cancels the delay and invokes `fn` immediately. It has no effect if
+  no invocation is pending.
+* `pending` {Promise|null} is the promise returned by the most recent call in
+  the current debounce window, or `null` if no invocation is pending.
+* `pendingCount` {integer} is the number of calls awaiting the invocation in
+  the current debounce window.
+* `ref()` makes the pending and future timeout keep the Node.js event loop
+  active. Returns the debounced function.
+* `unref()` allows the event loop to exit while a timeout is pending. This also
+  applies to future timeouts. Returns the debounced function.
+
+When invoked, `fn` has the debounced function as its `this` value. Once `fn` is
+invoked, a new debounce window can begin even if a promise returned by `fn` is
+still pending. The debounced function preserves the `name` and `length` of `fn`.
+
+```mjs
+import { setTimeout as wait } from 'node:timers/promises';
+import { debounce } from 'node:util';
+
+const fn = debounce(async (value) => {
+  await wait(100);
+  return value;
+}, 50);
+
+const first = fn(1);
+const second = fn(2);
+
+console.log(await first);  // 2
+console.log(await second); // 2
+```
+
+A debounced function can be used to trigger an action after a period of
+inactivity. Each call resets the timeout:
+
+```cjs
+const { debounce } = require('node:util');
+
+const onInactivity = debounce(() => {
+  console.log('No activity for 5 seconds');
+}, 5_000).unref();
+
+process.stdin.on('data', (data) => {
+  console.log(`Received ${data.length} bytes`);
+  onInactivity();
+});
+
+// Start the initial inactivity timeout.
+onInactivity();
+```
+
 ## `util.diff(actual, expected)`
 
 <!-- YAML
diff --git a/lib/internal/util/debounce.js b/lib/internal/util/debounce.js
new file mode 100644
index 000000000000..6c966a4181be
--- /dev/null
+++ b/lib/internal/util/debounce.js
@@ -0,0 +1,185 @@
+'use strict';
+
+const {
+  ArrayPrototypePush,
+  ObjectDefineProperties,
+  PromiseWithResolvers,
+  ReflectApply,
+} = primordials;
+
+const {
+  AbortError,
+} = require('internal/errors');
+const {
+  validateAbortSignal,
+  validateBoolean,
+  validateFunction,
+  validateInteger,
+  validateObject,
+} = require('internal/validators');
+const { addAbortListener } = require('internal/events/abort_listener');
+const { kEmptyObject } = require('internal/util');
+const { TIMEOUT_MAX } = require('internal/timers');
+const { clearTimeout, setTimeout } = require('timers');
+const { markPromiseAsHandled } = internalBinding('util');
+
+/**
+ * @typedef {object} DebounceOptions
+ * @property {AbortSignal} [signal] An AbortSignal that cancels a pending call.
+ * @property {boolean} [rejectOnCancel] Whether to reject superseded calls.
+ */
+
+/**
+ * Creates a function that delays calling `fn` until `wait` milliseconds have
+ * elapsed since its most recent invocation.
+ * @param {Function} fn
+ * @param {number} wait
+ * @param {DebounceOptions} [options]
+ * @returns {Function}
+ */
+function debounce(fn, wait, options = kEmptyObject) {
+  validateFunction(fn, 'fn');
+  validateInteger(wait, 'wait', 0, TIMEOUT_MAX);
+  validateObject(options, 'options');
+
+  const {
+    rejectOnCancel = false,
+    signal,
+  } = options;
+
+  validateBoolean(rejectOnCancel, 'options.rejectOnCancel');
+  validateAbortSignal(signal, 'options.signal');
+
+  if (signal?.aborted) {
+    throw new AbortError(undefined, { __proto__: null, cause: signal.reason });
+  }
+
+  let args;
+  let pendingCalls = [];
+  let refed = true;
+  let timeout;
+
+  function rejectPending(error) {
+    const calls = pendingCalls;
+    pendingCalls = [];
+    for (let i = 0; i < calls.length; i++) {
+      calls[i].reject(error);
+    }
+  }
+
+  function cancel(reason) {
+    if (timeout === undefined) return;
+    clearTimeout(timeout);
+    timeout = undefined;
+    args = undefined;
+    const error = reason === undefined ?
+      new AbortError() :
+      new AbortError(undefined, { __proto__: null, cause: reason });
+    rejectPending(error);
+  }
+
+  function ref() {
+    refed = true;
+    timeout?.ref();
+    return debounced;
+  }
+
+  function unref() {
+    refed = false;
+    timeout?.unref();
+    return debounced;
+  }
+
+  function flush() {
+    if (timeout === undefined) return;
+
+    clearTimeout(timeout);
+    timeout = undefined;
+    const callArgs = args;
+    args = undefined;
+    const calls = pendingCalls;
+    pendingCalls = [];
+
+    let result;
+    try {
+      result = ReflectApply(fn, debounced, callArgs);
+    } catch (error) {
+      for (let i = 0; i < calls.length; i++) {
+        calls[i].reject(error);
+      }
+      return;
+    }
+
+    for (let i = 0; i < calls.length; i++) {
+      calls[i].resolve(result);
+    }
+  }
+
+  function debounced(...callArgs) {
+    if (timeout !== undefined) {
+      markPromiseAsHandled(pendingCalls[pendingCalls.length - 1].promise);
+      if (rejectOnCancel) {
+        rejectPending(new AbortError('The debounced call was superseded'));
+      }
+      timeout.refresh();
+    } else {
+      timeout = setTimeout(flush, wait);
+      if (!refed) timeout.unref();
+    }
+
+    const call = PromiseWithResolvers();
+    ArrayPrototypePush(pendingCalls, call);
+    args = callArgs;
+    return call.promise;
+  }
+
+  function createFn(value) {
+    return {
+      __proto__: null,
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value,
+    };
+  }
+
+  ObjectDefineProperties(debounced, {
+    __proto__: null,
+    cancel: createFn(cancel),
+    flush: createFn(flush),
+    ref: createFn(ref),
+    unref: createFn(unref),
+    pending: {
+      __proto__: null,
+      enumerable: false,
+      get() {
+        return timeout === undefined ? null : pendingCalls[pendingCalls.length - 1].promise;
+      },
+    },
+    pendingCount: {
+      __proto__: null,
+      enumerable: false,
+      get() { return pendingCalls.length; },
+    },
+    length: {
+      __proto__: null,
+      configurable: true,
+      value: fn.length,
+    },
+    name: {
+      __proto__: null,
+      configurable: true,
+      value: fn.name,
+    },
+  });
+
+  if (signal !== undefined) {
+    addAbortListener(signal, () => {
+      cancel(signal.reason);
+    });
+  }
+
+  return debounced;
+}
+
+module.exports = debounce;
diff --git a/lib/util.js b/lib/util.js
index d238a620e59a..14af08a0fe42 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -668,6 +668,15 @@ defineLazyProperties(
   ['diff'],
 );
 
+ObjectDefineProperties(module.exports, {
+  debounce: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() { return require('internal/util/debounce'); },
+  },
+});
+
 defineLazyProperties(
   module.exports,
   'internal/util/trace_sigint',
diff --git a/test/parallel/test-util-debounce.js b/test/parallel/test-util-debounce.js
new file mode 100644
index 000000000000..5064ffbfcf8c
--- /dev/null
+++ b/test/parallel/test-util-debounce.js
@@ -0,0 +1,221 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+const { createHook } = require('node:async_hooks');
+const { setTimeout } = require('node:timers/promises');
+const { debounce } = require('node:util');
+const { TIMEOUT_MAX } = require('internal/timers');
+
+for (const value of [undefined, null, true, 0, 'fn', {}, [], Symbol()]) {
+  assert.throws(() => debounce(value, 1), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+}
+
+for (const value of [undefined, null, true, '1', {}, [], Symbol()]) {
+  assert.throws(() => debounce(() => {}, value), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+}
+
+for (const value of [-1, 0.5, NaN, Infinity, TIMEOUT_MAX + 1]) {
+  assert.throws(() => debounce(() => {}, value), {
+    code: 'ERR_OUT_OF_RANGE',
+  });
+}
+
+for (const value of [null, true, 1, 'options', []]) {
+  assert.throws(() => debounce(() => {}, 1, value), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+}
+
+assert.throws(() => debounce(() => {}, 1, { rejectOnCancel: 1 }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+});
+assert.throws(() => debounce(() => {}, 1, { signal: {} }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+});
+
+{
+  const reason = new Error('already aborted');
+  assert.throws(
+    () => debounce(() => {}, 1, { signal: AbortSignal.abort(reason) }),
+    (error) => error.code === 'ABORT_ERR' && error.cause === reason,
+  );
+}
+
+(async () => {
+  {
+    const debounced = debounce(common.mustCall(function(...args) {
+      assert.strictEqual(this, debounced);
+      assert.strictEqual(debounced.pending, null);
+      assert.deepStrictEqual(args, ['last', 2]);
+      return args[1];
+    }), 100);
+
+    assert.strictEqual(typeof debounced.cancel, 'function');
+    assert.strictEqual(typeof debounced.flush, 'function');
+    assert.strictEqual(typeof debounced.ref, 'function');
+    assert.strictEqual(typeof debounced.unref, 'function');
+    assert.strictEqual(debounced.unref(), debounced);
+    assert.strictEqual(debounced.ref(), debounced);
+    assert.strictEqual(debounced.pending, null);
+    assert.strictEqual(debounced.pendingCount, 0);
+
+    const first = debounced('first', 1);
+    const second = debounced('last', 2);
+    assert(first instanceof Promise);
+    assert(second instanceof Promise);
+    assert.notStrictEqual(first, second);
+    assert.strictEqual(debounced.pending, second);
+    assert.strictEqual(debounced.pendingCount, 2);
+    assert.strictEqual(debounced.unref(), debounced);
+    assert.strictEqual(debounced.ref(), debounced);
+
+    debounced.flush();
+    assert.strictEqual(debounced.pending, null);
+    assert.strictEqual(debounced.pendingCount, 0);
+    debounced.flush();
+    assert.deepStrictEqual(await Promise.all([first, second]), [2, 2]);
+  }
+
+  {
+    const debounced = debounce(common.mustCall(async (value) => {
+      await Promise.resolve();
+      return value;
+    }), 100);
+    const result = debounced(42);
+    debounced.flush();
+    assert.strictEqual(await result, 42);
+  }
+
+  {
+    const expected = new Error('failure');
+    const debounced = debounce(common.mustCall(() => { throw expected; }), 100);
+    const result = debounced();
+    debounced.flush();
+    await assert.rejects(result, (error) => error === expected);
+  }
+
+  {
+    const debounced = debounce(common.mustNotCall(), 100);
+    const first = debounced();
+    const second = debounced();
+    const reason = new Error('cancelled');
+    debounced.cancel(reason);
+    assert.strictEqual(debounced.pending, null);
+    debounced.cancel();
+    await assert.rejects(
+      first,
+      (error) => error.code === 'ABORT_ERR' && error.cause === reason,
+    );
+    await assert.rejects(
+      second,
+      (error) => error.code === 'ABORT_ERR' && error.cause === reason,
+    );
+  }
+
+  {
+    const debounced = debounce(common.mustCall((value) => value), 100, {
+      rejectOnCancel: true,
+    });
+    const first = debounced(1);
+    const firstRejection = assert.rejects(first, {
+      code: 'ABORT_ERR',
+      name: 'AbortError',
+    });
+    const second = debounced(2);
+    assert.strictEqual(debounced.pendingCount, 1);
+    await firstRejection;
+    debounced.flush();
+    assert.strictEqual(await second, 2);
+  }
+
+  {
+    const reason = new Error('stop');
+    const controller = new AbortController();
+    const debounced = debounce(common.mustNotCall(), 100, {
+      signal: controller.signal,
+    });
+    const result = debounced();
+    controller.abort(reason);
+    await assert.rejects(
+      result,
+      (error) => error.code === 'ABORT_ERR' && error.cause === reason,
+    );
+    assert.strictEqual(debounced.pending, null);
+  }
+
+  {
+    const controller = new AbortController();
+    const debounced = debounce(common.mustCall(() => 1), 100, {
+      signal: controller.signal,
+    });
+    const result = debounced();
+    debounced.flush();
+    controller.abort();
+    assert.strictEqual(await result, 1);
+  }
+
+  {
+    const debounced = debounce(common.mustCall((value) => value), 1);
+    assert.strictEqual(await debounced(42), 42);
+  }
+
+  {
+    const debounced = debounce(common.mustCall((value) => value, 2), 100);
+    const first = debounced(1);
+    debounced.flush();
+    assert.strictEqual(await first, 1);
+    const second = debounced(2);
+    debounced.flush();
+    assert.strictEqual(await second, 2);
+  }
+
+  {
+    function original(first, second) {
+      return first + second;
+    }
+    const debounced = debounce(original, 100);
+    assert.strictEqual(debounced.name, original.name);
+    assert.strictEqual(debounced.length, original.length);
+  }
+
+  {
+    let timeoutCount = 0;
+    const hook = createHook({
+      init(_asyncId, type) {
+        if (type === 'Timeout') timeoutCount++;
+      },
+    });
+    const debounced = debounce(common.mustCall((value) => value), 100);
+    hook.enable();
+    const first = debounced(1);
+    const second = debounced(2);
+    const third = debounced(3);
+    hook.disable();
+    assert.strictEqual(timeoutCount, 1);
+    debounced.flush();
+    assert.deepStrictEqual(await Promise.all([first, second, third]), [3, 3, 3]);
+  }
+
+  {
+    const debounced = debounce(common.mustNotCall(), 100);
+    debounced();
+    const pending = debounced();
+    const { promise, resolve } = Promise.withResolvers();
+    process.once('unhandledRejection', common.mustCall((error, unhandled) => {
+      assert.strictEqual(error.code, 'ABORT_ERR');
+      assert.strictEqual(unhandled, pending);
+      resolve();
+    }));
+    debounced.cancel();
+    await promise;
+  }
+
+  // Give canceled timers time to expose any accidental extra invocation.
+  await setTimeout(110);
+})().then(common.mustCall());