From f056a792bc8fa8f0300985895f7e84ef3772bdb3 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Tue, 17 Mar 2026 13:48:16 +0100
Subject: [PATCH 1/5] lib,src: implement QuotaExceededError as
 DOMException-derived interface

Implement QuotaExceededError as a DOMException-derived interface per the
WebIDL specification update.

QuotaExceededError is now a proper constructor exposed as a global
[Exposed=*] interface that extends DOMException with optional `quota`
and `requested` attributes (both nullable doubles, defaulting to null).

The constructor validates that quota and requested are finite,
non-negative, and that requested is not less than quota when both are
provided.

QuotaExceededError is [Serializable] and supports structuredClone,
preserving the quota and requested values across the serialization
boundary.

Callers updated:
- crypto.getRandomValues() now throws a QuotaExceededError instance
- WebStorage (C++) now constructs QuotaExceededError directly

Refs: https://redirect.github.com/whatwg/webidl/pull/1465
Fixes: https://github.com/nodejs/node/issues/58987
---
 doc/api/globals.md                            |   8 +
 eslint.config.mjs                             |   1 +
 lib/eslint.config_partial.mjs                 |   6 +-
 .../bootstrap/web/exposed-wildcard.js         |   5 +
 lib/internal/crypto/random.js                 |   6 +-
 lib/internal/per_context/domexception.js      |  94 +++++++++
 lib/internal/quota_exceeded_error.js          |   5 +
 lib/internal/worker/clone_dom_exception.js    |   6 +-
 src/node_messaging.cc                         |  15 ++
 src/node_webstorage.cc                        |  18 +-
 test/parallel/test-quotaexceedederror.js      | 199 ++++++++++++++++++
 test/parallel/test-webcrypto-random.js        |  10 +-
 test/wpt/status/WebCryptoAPI.cjs              |  16 --
 test/wpt/status/webstorage.json               |  16 --
 14 files changed, 357 insertions(+), 48 deletions(-)
 create mode 100644 lib/internal/quota_exceeded_error.js
 create mode 100644 test/parallel/test-quotaexceedederror.js

diff --git a/doc/api/globals.md b/doc/api/globals.md
index 47340c897b4a36..6c0caca06d3dbb 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -976,6 +976,14 @@ DataHandler.prototype.load = async function load(key) {
 };
 ```
 
+## Class: `QuotaExceededError`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+The WHATWG {QuotaExceededError} class. Extends {DOMException}.
+
 ## Class: `ReadableByteStreamController`
 
 <!-- YAML
diff --git a/eslint.config.mjs b/eslint.config.mjs
index cd66c1392b68c7..1e20010a6c21f1 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -128,6 +128,7 @@ export default [
         Float16Array: 'readonly',
         FormData: 'readonly',
         navigator: 'readonly',
+        QuotaExceededError: 'readonly',
         ReadableStream: 'readonly',
         ReadableStreamDefaultReader: 'readonly',
         ReadableStreamBYOBReader: 'readonly',
diff --git a/lib/eslint.config_partial.mjs b/lib/eslint.config_partial.mjs
index bb5b4d8cc7c980..48328ed678a0a8 100644
--- a/lib/eslint.config_partial.mjs
+++ b/lib/eslint.config_partial.mjs
@@ -23,7 +23,7 @@ const noRestrictedSyntax = [
     message: "`btoa` supports only latin-1 charset, use Buffer.from(str).toString('base64') instead",
   },
   {
-    selector: 'NewExpression[callee.name=/Error$/]:not([callee.name=/^(AssertionError|NghttpError|AbortError|NodeAggregateError)$/])',
+    selector: 'NewExpression[callee.name=/Error$/]:not([callee.name=/^(AssertionError|NghttpError|AbortError|NodeAggregateError|QuotaExceededError)$/])',
     message: "Use an error exported by 'internal/errors' instead.",
   },
   {
@@ -122,6 +122,10 @@ export default [
           name: 'DOMException',
           message: "Use lazy function `const { lazyDOMExceptionClass } = require('internal/util');` instead of the global.",
         },
+        {
+          name: 'QuotaExceededError',
+          message: "Use `internalBinding('messaging').QuotaExceededError` instead of the global.",
+        },
         {
           name: 'ErrorEvent',
           message: "Use `const { ErrorEvent } = require('internal/deps/undici/undici');` instead of the global.",
diff --git a/lib/internal/bootstrap/web/exposed-wildcard.js b/lib/internal/bootstrap/web/exposed-wildcard.js
index 4b3d6be0701ec4..9d418153705f5c 100644
--- a/lib/internal/bootstrap/web/exposed-wildcard.js
+++ b/lib/internal/bootstrap/web/exposed-wildcard.js
@@ -29,6 +29,11 @@ exposeInterface(globalThis, 'URL', URL);
 exposeInterface(globalThis, 'URLSearchParams', URLSearchParams);
 exposeLazyDOMExceptionProperty(globalThis);
 
+// https://webidl.spec.whatwg.org/#quotaexceedederror
+exposeLazyInterfaces(globalThis, 'internal/quota_exceeded_error', [
+  'QuotaExceededError',
+]);
+
 // https://dom.spec.whatwg.org/#interface-abortcontroller
 // Lazy ones.
 exposeLazyInterfaces(globalThis, 'internal/abort_controller', [
diff --git a/lib/internal/crypto/random.js b/lib/internal/crypto/random.js
index c9030124e7f71f..72ac4b72ac0825 100644
--- a/lib/internal/crypto/random.js
+++ b/lib/internal/crypto/random.js
@@ -328,9 +328,9 @@ function getRandomValues(data) {
       'TypeMismatchError');
   }
   if (data.byteLength > 65536) {
-    throw lazyDOMException(
-      'The requested length exceeds 65,536 bytes',
-      'QuotaExceededError');
+    const { QuotaExceededError } = internalBinding('messaging');
+    throw new QuotaExceededError(
+      'The requested length exceeds 65,536 bytes');
   }
   randomFillSync(data, 0);
   return data;
diff --git a/lib/internal/per_context/domexception.js b/lib/internal/per_context/domexception.js
index d8a2e7df88a697..846e0547e51758 100644
--- a/lib/internal/per_context/domexception.js
+++ b/lib/internal/per_context/domexception.js
@@ -3,9 +3,12 @@
 const {
   Error,
   ErrorPrototype,
+  NumberIsFinite,
+  NumberIsNaN,
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
+  RangeError,
   SafeMap,
   SafeSet,
   SafeWeakMap,
@@ -203,3 +206,94 @@ for (const { 0: name, 1: codeName, 2: value } of [
 }
 
 exports.DOMException = DOMException;
+
+const quotaExceededInternalsMap = new SafeWeakMap();
+
+// https://webidl.spec.whatwg.org/#quotaexceedederror
+class QuotaExceededError extends DOMException {
+  constructor(message = '', options = { __proto__: null }) {
+    super(message, 'QuotaExceededError');
+    this[transfer_mode_private_symbol] = kCloneable;
+
+    let quota = null;
+    let requested = null;
+
+    if (options !== null && options !== undefined) {
+      if ('quota' in options) {
+        quota = +options.quota;
+        if (!NumberIsFinite(quota)) {
+          // eslint-disable-next-line no-restricted-syntax
+          throw new TypeError(
+            `Cannot convert options.quota to a double: the value is ${NumberIsNaN(quota) ? 'NaN' : 'Infinity'}`,
+          );
+        }
+        if (quota < 0) {
+          // eslint-disable-next-line no-restricted-syntax
+          throw new RangeError('options.quota must not be negative');
+        }
+      }
+
+      if ('requested' in options) {
+        requested = +options.requested;
+        if (!NumberIsFinite(requested)) {
+          // eslint-disable-next-line no-restricted-syntax
+          throw new TypeError(
+            `Cannot convert options.requested to a double: the value is ${NumberIsNaN(requested) ? 'NaN' : 'Infinity'}`,
+          );
+        }
+        if (requested < 0) {
+          // eslint-disable-next-line no-restricted-syntax
+          throw new RangeError('options.requested must not be negative');
+        }
+      }
+    }
+
+    if (quota !== null && requested !== null && requested < quota) {
+      // eslint-disable-next-line no-restricted-syntax
+      throw new RangeError('options.requested must not be less than options.quota');
+    }
+
+    quotaExceededInternalsMap.set(this, { quota, requested });
+  }
+
+  [messaging_clone_symbol]() {
+    const domExceptionClone = DOMExceptionPrototype[messaging_clone_symbol].call(this);
+    const { quota, requested } = quotaExceededInternalsMap.get(this);
+    domExceptionClone.data.quota = quota;
+    domExceptionClone.data.requested = requested;
+    domExceptionClone.deserializeInfo = 'internal/worker/clone_dom_exception:QuotaExceededError';
+    return domExceptionClone;
+  }
+
+  [messaging_deserialize_symbol](data) {
+    DOMExceptionPrototype[messaging_deserialize_symbol].call(this, data);
+    quotaExceededInternalsMap.set(this, {
+      quota: data.quota,
+      requested: data.requested,
+    });
+  }
+
+  get quota() {
+    const internals = quotaExceededInternalsMap.get(this);
+    if (internals === undefined) {
+      throwInvalidThisError(TypeError, 'QuotaExceededError');
+    }
+    return internals.quota;
+  }
+
+  get requested() {
+    const internals = quotaExceededInternalsMap.get(this);
+    if (internals === undefined) {
+      throwInvalidThisError(TypeError, 'QuotaExceededError');
+    }
+    return internals.requested;
+  }
+}
+
+ObjectDefineProperties(QuotaExceededError.prototype, {
+  [SymbolToStringTag]: { __proto__: null, configurable: true, value: 'QuotaExceededError' },
+  quota: { __proto__: null, enumerable: true, configurable: true },
+  requested: { __proto__: null, enumerable: true, configurable: true },
+});
+
+exports.QuotaExceededError = QuotaExceededError;
diff --git a/lib/internal/quota_exceeded_error.js b/lib/internal/quota_exceeded_error.js
new file mode 100644
index 00000000000000..e7c928868842fd
--- /dev/null
+++ b/lib/internal/quota_exceeded_error.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  QuotaExceededError: internalBinding('messaging').QuotaExceededError,
+};
diff --git a/lib/internal/worker/clone_dom_exception.js b/lib/internal/worker/clone_dom_exception.js
index e1e47a3b988e71..85cc7e9f0ce5d0 100644
--- a/lib/internal/worker/clone_dom_exception.js
+++ b/lib/internal/worker/clone_dom_exception.js
@@ -1,6 +1,8 @@
 'use strict';
 
-// Delegate to the actual DOMException implementation.
+// Delegate to the actual DOMException/QuotaExceededError implementation.
+const messaging = internalBinding('messaging');
 module.exports = {
-  DOMException: internalBinding('messaging').DOMException,
+  DOMException: messaging.DOMException,
+  QuotaExceededError: messaging.QuotaExceededError,
 };
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index 76c934ccbc9873..72e807a1c04de5 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -1762,6 +1762,21 @@ static void CreatePerContextProperties(Local<Object> target,
               domexception)
         .Check();
   }
+  {
+    Local<Object> per_context_bindings;
+    Local<Value> quota_exceeded_error_val;
+    if (GetPerContextExports(context).ToLocal(&per_context_bindings) &&
+        per_context_bindings
+            ->Get(context,
+                  FIXED_ONE_BYTE_STRING(env->isolate(), "QuotaExceededError"))
+            .ToLocal(&quota_exceeded_error_val)) {
+      target
+          ->Set(context,
+                FIXED_ONE_BYTE_STRING(env->isolate(), "QuotaExceededError"),
+                quota_exceeded_error_val)
+          .Check();
+    }
+  }
 }
 
 static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
diff --git a/src/node_webstorage.cc b/src/node_webstorage.cc
index 224f49e8596cf1..1ec2b02318da37 100644
--- a/src/node_webstorage.cc
+++ b/src/node_webstorage.cc
@@ -57,23 +57,23 @@ using v8::Value;
 
 static void ThrowQuotaExceededException(Local<Context> context) {
   Isolate* isolate = Isolate::GetCurrent();
-  auto dom_exception_str = FIXED_ONE_BYTE_STRING(isolate, "DOMException");
-  auto err_name = FIXED_ONE_BYTE_STRING(isolate, "QuotaExceededError");
+  auto quota_exceeded_str =
+      FIXED_ONE_BYTE_STRING(isolate, "QuotaExceededError");
   auto err_message =
       FIXED_ONE_BYTE_STRING(isolate, "Setting the value exceeded the quota");
   Local<Object> per_context_bindings;
-  Local<Value> domexception_ctor_val;
+  Local<Value> quota_exceeded_ctor_val;
   if (!GetPerContextExports(context).ToLocal(&per_context_bindings) ||
-      !per_context_bindings->Get(context, dom_exception_str)
-           .ToLocal(&domexception_ctor_val)) {
+      !per_context_bindings->Get(context, quota_exceeded_str)
+           .ToLocal(&quota_exceeded_ctor_val)) {
     return;
   }
-  CHECK(domexception_ctor_val->IsFunction());
-  Local<Function> domexception_ctor = domexception_ctor_val.As<Function>();
-  Local<Value> argv[] = {err_message, err_name};
+  CHECK(quota_exceeded_ctor_val->IsFunction());
+  Local<Function> quota_exceeded_ctor = quota_exceeded_ctor_val.As<Function>();
+  Local<Value> argv[] = {err_message};
   Local<Value> exception;
 
-  if (!domexception_ctor->NewInstance(context, arraysize(argv), argv)
+  if (!quota_exceeded_ctor->NewInstance(context, arraysize(argv), argv)
            .ToLocal(&exception)) {
     return;
   }
diff --git a/test/parallel/test-quotaexceedederror.js b/test/parallel/test-quotaexceedederror.js
new file mode 100644
index 00000000000000..fa7a2053be3277
--- /dev/null
+++ b/test/parallel/test-quotaexceedederror.js
@@ -0,0 +1,199 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+// Verify QuotaExceededError is a global.
+assert.strictEqual(typeof QuotaExceededError, 'function');
+
+// Prototype chain.
+{
+  const err = new QuotaExceededError('test');
+  assert(err instanceof QuotaExceededError);
+  assert(err instanceof DOMException);
+  assert(err instanceof Error);
+  assert(Error.isError(err));
+}
+
+// Default properties.
+{
+  const err = new QuotaExceededError();
+  assert.strictEqual(err.name, 'QuotaExceededError');
+  assert.strictEqual(err.message, '');
+  assert.strictEqual(err.code, 22);
+  assert.strictEqual(err.quota, null);
+  assert.strictEqual(err.requested, null);
+  assert.strictEqual(typeof err.stack, 'string');
+}
+
+// Custom message.
+{
+  const err = new QuotaExceededError('out of space');
+  assert.strictEqual(err.message, 'out of space');
+  assert.strictEqual(err.name, 'QuotaExceededError');
+  assert.strictEqual(err.code, 22);
+}
+
+// Options with quota and requested.
+{
+  const err = new QuotaExceededError('full', { quota: 100, requested: 200 });
+  assert.strictEqual(err.quota, 100);
+  assert.strictEqual(err.requested, 200);
+}
+
+// Options with only quota.
+{
+  const err = new QuotaExceededError('full', { quota: 50 });
+  assert.strictEqual(err.quota, 50);
+  assert.strictEqual(err.requested, null);
+}
+
+// Options with only requested.
+{
+  const err = new QuotaExceededError('full', { requested: 75 });
+  assert.strictEqual(err.quota, null);
+  assert.strictEqual(err.requested, 75);
+}
+
+// Options with zero values.
+{
+  const err = new QuotaExceededError('full', { quota: 0, requested: 0 });
+  assert.strictEqual(err.quota, 0);
+  assert.strictEqual(err.requested, 0);
+}
+
+// Equal quota and requested is valid.
+{
+  const err = new QuotaExceededError('full', { quota: 100, requested: 100 });
+  assert.strictEqual(err.quota, 100);
+  assert.strictEqual(err.requested, 100);
+}
+
+// Numeric string coercion.
+{
+  const err = new QuotaExceededError('full', { quota: '10', requested: '20' });
+  assert.strictEqual(err.quota, 10);
+  assert.strictEqual(err.requested, 20);
+}
+
+// Validation: negative quota.
+assert.throws(
+  () => new QuotaExceededError('test', { quota: -1 }),
+  { name: 'RangeError' },
+);
+
+// Validation: negative requested.
+assert.throws(
+  () => new QuotaExceededError('test', { requested: -1 }),
+  { name: 'RangeError' },
+);
+
+// Validation: requested < quota.
+assert.throws(
+  () => new QuotaExceededError('test', { quota: 100, requested: 50 }),
+  { name: 'RangeError' },
+);
+
+// Validation: NaN quota.
+assert.throws(
+  () => new QuotaExceededError('test', { quota: NaN }),
+  { name: 'TypeError' },
+);
+
+// Validation: Infinity quota.
+assert.throws(
+  () => new QuotaExceededError('test', { quota: Infinity }),
+  { name: 'TypeError' },
+);
+
+// Validation: NaN requested.
+assert.throws(
+  () => new QuotaExceededError('test', { requested: NaN }),
+  { name: 'TypeError' },
+);
+
+// Validation: Infinity requested.
+assert.throws(
+  () => new QuotaExceededError('test', { requested: Infinity }),
+  { name: 'TypeError' },
+);
+
+// Validation: -Infinity quota.
+assert.throws(
+  () => new QuotaExceededError('test', { quota: -Infinity }),
+  { name: 'TypeError' },
+);
+
+// Null/undefined options are allowed.
+{
+  const e1 = new QuotaExceededError('test', null);
+  assert.strictEqual(e1.quota, null);
+  assert.strictEqual(e1.requested, null);
+
+  const e2 = new QuotaExceededError('test', undefined);
+  assert.strictEqual(e2.quota, null);
+  assert.strictEqual(e2.requested, null);
+}
+
+// DOMException backwards compat: new DOMException('msg', 'QuotaExceededError')
+// still works and returns code 22, but is not instanceof QuotaExceededError.
+{
+  const err = new DOMException('msg', 'QuotaExceededError');
+  assert.strictEqual(err.code, 22);
+  assert.strictEqual(err.name, 'QuotaExceededError');
+  assert(!(err instanceof QuotaExceededError));
+}
+
+// SymbolToStringTag.
+{
+  const err = new QuotaExceededError('test');
+  assert.strictEqual(Object.prototype.toString.call(err), '[object QuotaExceededError]');
+}
+
+// Property descriptors for quota/requested are enumerable and configurable.
+{
+  const proto = QuotaExceededError.prototype;
+  for (const prop of ['quota', 'requested']) {
+    const desc = Object.getOwnPropertyDescriptor(proto, prop);
+    assert.strictEqual(desc.enumerable, true);
+    assert.strictEqual(desc.configurable, true);
+    assert.strictEqual(typeof desc.get, 'function');
+  }
+}
+
+// Getter throws on invalid this.
+{
+  const proto = QuotaExceededError.prototype;
+  assert.throws(
+    () => Object.getOwnPropertyDescriptor(proto, 'quota').get.call({}),
+    { code: 'ERR_INVALID_THIS' },
+  );
+  assert.throws(
+    () => Object.getOwnPropertyDescriptor(proto, 'requested').get.call({}),
+    { code: 'ERR_INVALID_THIS' },
+  );
+}
+
+// structuredClone preserves properties.
+{
+  const original = new QuotaExceededError('cloned', { quota: 42, requested: 50 });
+  const cloned = structuredClone(original);
+  assert(cloned instanceof QuotaExceededError);
+  assert(cloned instanceof DOMException);
+  assert(cloned instanceof Error);
+  assert.strictEqual(cloned.name, 'QuotaExceededError');
+  assert.strictEqual(cloned.message, 'cloned');
+  assert.strictEqual(cloned.code, 22);
+  assert.strictEqual(cloned.quota, 42);
+  assert.strictEqual(cloned.requested, 50);
+  assert.strictEqual(cloned.stack, original.stack);
+}
+
+// structuredClone with null quota/requested.
+{
+  const original = new QuotaExceededError('defaults');
+  const cloned = structuredClone(original);
+  assert(cloned instanceof QuotaExceededError);
+  assert.strictEqual(cloned.quota, null);
+  assert.strictEqual(cloned.requested, null);
+}
diff --git a/test/parallel/test-webcrypto-random.js b/test/parallel/test-webcrypto-random.js
index c83a0964bc5805..20639d2b8e1d49 100644
--- a/test/parallel/test-webcrypto-random.js
+++ b/test/parallel/test-webcrypto-random.js
@@ -65,7 +65,15 @@ for (const ctor of intTypedConstructors) {
   if (kData !== undefined) {
     assert.throws(
       () => crypto.getRandomValues(kData),
-      { name: 'QuotaExceededError', code: 22 },
+      (err) => {
+        assert.strictEqual(err.name, 'QuotaExceededError');
+        assert.strictEqual(err.code, 22);
+        assert(err instanceof DOMException);
+        assert(err instanceof QuotaExceededError);
+        assert.strictEqual(err.quota, null);
+        assert.strictEqual(err.requested, null);
+        return true;
+      },
     );
   }
 }
diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs
index d23fb1d40453fe..722a0b38398e1d 100644
--- a/test/wpt/status/WebCryptoAPI.cjs
+++ b/test/wpt/status/WebCryptoAPI.cjs
@@ -70,20 +70,4 @@ module.exports = {
       ],
     },
   },
-  'getRandomValues.any.js': {
-    'fail': {
-      'note': 'https://github.com/nodejs/node/issues/58987',
-      'expected': [
-        'Large length: Int8Array',
-        'Large length: Int16Array',
-        'Large length: Int32Array',
-        'Large length: BigInt64Array',
-        'Large length: Uint8Array',
-        'Large length: Uint8ClampedArray',
-        'Large length: Uint16Array',
-        'Large length: Uint32Array',
-        'Large length: BigUint64Array',
-      ],
-    },
-  },
 };
diff --git a/test/wpt/status/webstorage.json b/test/wpt/status/webstorage.json
index 1dad4e2dd48403..e492fb355ce2b4 100644
--- a/test/wpt/status/webstorage.json
+++ b/test/wpt/status/webstorage.json
@@ -23,22 +23,6 @@
   "storage_session_window_reopen.window.js": {
     "skip": "window.open() is not supported in Node.js."
   },
-  "storage_session_setitem_quotaexceedederr.window.js": {
-    "fail": {
-      "note": "https://github.com/nodejs/node/issues/58987",
-      "expected": [
-        "Throws QuotaExceededError when the quota has been exceeded"
-      ]
-    }
-  },
-  "storage_local_setitem_quotaexceedederr.window.js": {
-    "fail": {
-      "note": "https://github.com/nodejs/node/issues/58987",
-      "expected": [
-        "Throws QuotaExceededError when the quota has been exceeded"
-      ]
-    }
-  },
   "symbol-props.window.js": {
     "fail": {
       "note": "https://github.com/nodejs/node/issues/59310",

From 6ac0aa3038151a1c2031c5953c90f4dfdf5488d1 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Tue, 17 Mar 2026 14:29:40 +0100
Subject: [PATCH 2/5] fixup! lib,src: implement QuotaExceededError as
 DOMException-derived interface

---
 lib/internal/per_context/domexception.js | 29 +++++++++++-------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/lib/internal/per_context/domexception.js b/lib/internal/per_context/domexception.js
index 846e0547e51758..05a2002a399043 100644
--- a/lib/internal/per_context/domexception.js
+++ b/lib/internal/per_context/domexception.js
@@ -207,10 +207,11 @@ for (const { 0: name, 1: codeName, 2: value } of [
 
 exports.DOMException = DOMException;
 
-const quotaExceededInternalsMap = new SafeWeakMap();
-
 // https://webidl.spec.whatwg.org/#quotaexceedederror
 class QuotaExceededError extends DOMException {
+  #quota;
+  #requested;
+
   constructor(message = '', options = { __proto__: null }) {
     super(message, 'QuotaExceededError');
     this[transfer_mode_private_symbol] = kCloneable;
@@ -253,40 +254,36 @@ class QuotaExceededError extends DOMException {
       throw new RangeError('options.requested must not be less than options.quota');
     }
 
-    quotaExceededInternalsMap.set(this, { quota, requested });
+    this.#quota = quota;
+    this.#requested = requested;
   }
 
   [messaging_clone_symbol]() {
     const domExceptionClone = DOMExceptionPrototype[messaging_clone_symbol].call(this);
-    const { quota, requested } = quotaExceededInternalsMap.get(this);
-    domExceptionClone.data.quota = quota;
-    domExceptionClone.data.requested = requested;
+    domExceptionClone.data.quota = this.#quota;
+    domExceptionClone.data.requested = this.#requested;
     domExceptionClone.deserializeInfo = 'internal/worker/clone_dom_exception:QuotaExceededError';
     return domExceptionClone;
   }
 
   [messaging_deserialize_symbol](data) {
     DOMExceptionPrototype[messaging_deserialize_symbol].call(this, data);
-    quotaExceededInternalsMap.set(this, {
-      quota: data.quota,
-      requested: data.requested,
-    });
+    this.#quota = data.quota;
+    this.#requested = data.requested;
   }
 
   get quota() {
-    const internals = quotaExceededInternalsMap.get(this);
-    if (internals === undefined) {
+    if (!(#quota in this)) {
       throwInvalidThisError(TypeError, 'QuotaExceededError');
     }
-    return internals.quota;
+    return this.#quota;
   }
 
   get requested() {
-    const internals = quotaExceededInternalsMap.get(this);
-    if (internals === undefined) {
+    if (!(#requested in this)) {
       throwInvalidThisError(TypeError, 'QuotaExceededError');
     }
-    return internals.requested;
+    return this.#requested;
   }
 }
 

From af481d12b41268e1a51c93b2f005648c0afcc05f Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Tue, 17 Mar 2026 14:41:05 +0100
Subject: [PATCH 3/5] fixup! lib,src: implement QuotaExceededError as
 DOMException-derived interface

---
 test/parallel/test-webstorage.js | 53 ++++++++++++++++----------------
 1 file changed, 26 insertions(+), 27 deletions(-)

diff --git a/test/parallel/test-webstorage.js b/test/parallel/test-webstorage.js
index 139c5f1d6c0102..71e0a095163ced 100644
--- a/test/parallel/test-webstorage.js
+++ b/test/parallel/test-webstorage.js
@@ -93,34 +93,33 @@ test('localStorage is persisted if it is used', async () => {
 describe('webstorage quota for localStorage and sessionStorage', () => {
   const MAX_STORAGE_SIZE = 10 * 1024 * 1024;
 
-  test('localStorage can store and retrieve a max of 10 MB quota', async () => {
-    const localStorageFile = nextLocalStorage();
-    const cp = await spawnPromisified(process.execPath, [
-      '--localstorage-file', localStorageFile,
+  for (const storage of ['localStorage', 'sessionStorage']) {
+    test(`${storage} can store a max of 10 MB quota`, async () => {
+      const args = [];
+      if (storage === 'localStorage') {
+        args.push('--localstorage-file', nextLocalStorage());
+      }
       // Each character is 2 bytes
-      '-pe', `
-      localStorage['a'.repeat(${MAX_STORAGE_SIZE} / 2)] = '';
-      console.error('filled');
-      localStorage.anything = 'should fail';
-      `,
-    ]);
-
-    assert.match(cp.stderr, /filled/);
-    assert.match(cp.stderr, /QuotaExceededError: Setting the value exceeded the quota/);
-  });
-
-  test('sessionStorage can store a max of 10 MB quota', async () => {
-    const cp = await spawnPromisified(process.execPath, [
-      // Each character is 2 bytes
-      '-pe', `sessionStorage['a'.repeat(${MAX_STORAGE_SIZE} / 2)] = '';
-      console.error('filled');
-      sessionStorage.anything = 'should fail';
-      `,
-    ]);
-
-    assert.match(cp.stderr, /filled/);
-    assert.match(cp.stderr, /QuotaExceededError/);
-  });
+      args.push('-e', `
+      const assert = require('assert');
+      ${storage}['a'.repeat(${MAX_STORAGE_SIZE} / 2)] = '';
+      assert.throws(
+        () => { ${storage}.anything = 'should fail'; },
+        (err) => {
+          assert.strictEqual(err.name, 'QuotaExceededError');
+          assert.strictEqual(err.code, 22);
+          assert(err instanceof DOMException);
+          assert(err instanceof QuotaExceededError);
+          assert.strictEqual(err.quota, null);
+          assert.strictEqual(err.requested, null);
+          return true;
+        },
+      );
+      `);
+      const cp = await spawnPromisified(process.execPath, args);
+      assert.strictEqual(cp.code, 0);
+    });
+  }
 });
 
 test('disabled with --no-webstorage', async () => {

From 953b12297f38dbaf171c09a88c05ce1f6399db21 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Tue, 17 Mar 2026 15:11:20 +0100
Subject: [PATCH 4/5] fixup! lib,src: implement QuotaExceededError as
 DOMException-derived interface

---
 test/common/globals.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/common/globals.js b/test/common/globals.js
index 0f637ad53f70c9..d5c32828bcf514 100644
--- a/test/common/globals.js
+++ b/test/common/globals.js
@@ -79,6 +79,7 @@ intrinsics.add('console');
 
 const webIdlExposedWildcard = new Set([
   'DOMException',
+  'QuotaExceededError',
   'TextEncoder',
   'TextDecoder',
   'AbortController',

From 5a8ef66a61b68704e6ea6a4b3cbb7589cd03ee48 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Tue, 17 Mar 2026 20:47:27 +0100
Subject: [PATCH 5/5] fixup! lib,src: implement QuotaExceededError as
 DOMException-derived interface

---
 lib/internal/bootstrap/web/exposed-wildcard.js | 2 +-
 lib/internal/quota_exceeded_error.js           | 5 -----
 2 files changed, 1 insertion(+), 6 deletions(-)
 delete mode 100644 lib/internal/quota_exceeded_error.js

diff --git a/lib/internal/bootstrap/web/exposed-wildcard.js b/lib/internal/bootstrap/web/exposed-wildcard.js
index 9d418153705f5c..c00a9afb105b52 100644
--- a/lib/internal/bootstrap/web/exposed-wildcard.js
+++ b/lib/internal/bootstrap/web/exposed-wildcard.js
@@ -30,7 +30,7 @@ exposeInterface(globalThis, 'URLSearchParams', URLSearchParams);
 exposeLazyDOMExceptionProperty(globalThis);
 
 // https://webidl.spec.whatwg.org/#quotaexceedederror
-exposeLazyInterfaces(globalThis, 'internal/quota_exceeded_error', [
+exposeLazyInterfaces(globalThis, 'internal/worker/clone_dom_exception', [
   'QuotaExceededError',
 ]);
 
diff --git a/lib/internal/quota_exceeded_error.js b/lib/internal/quota_exceeded_error.js
deleted file mode 100644
index e7c928868842fd..00000000000000
--- a/lib/internal/quota_exceeded_error.js
+++ /dev/null
@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = {
-  QuotaExceededError: internalBinding('messaging').QuotaExceededError,
-};