From 4ee467f91254fdd5d9a1c328edd2e3fc5b541943 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 19 Mar 2026 12:06:03 +0100
Subject: [PATCH 1/4] tools: do not swallow error in `lint-nix` workflow
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/62292
Reviewed-By: René <contact.9a5d6388@renegade334.me.uk>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Tierney Cyren <hello@bnb.im>
---
 .github/workflows/linters.yml | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/linters.yml b/.github/workflows/linters.yml
index 3cb2689061d67b..4ac3f26dc66800 100644
--- a/.github/workflows/linters.yml
+++ b/.github/workflows/linters.yml
@@ -154,7 +154,12 @@ jobs:
         run: |
           nix-shell -I nixpkgs=./tools/nix/pkgs.nix -p 'nixfmt-tree' --run '
             treefmt --quiet --ci
-          ' || git --no-pager diff --exit-code
+          ' && EXIT_CODE="$?" || EXIT_CODE="$?"
+          if [ "$EXIT_CODE" != "0" ]
+          then
+            git --no-pager diff || true
+            exit "$EXIT_CODE"
+          fi
 
   lint-py:
     if: github.event.pull_request.draft == false

From b328bf74bd4fba4dc13b948505a4b309c87d2258 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 2/4] lib,src: implement QuotaExceededError as
 DOMException-derived interface
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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
PR-URL: https://github.com/nodejs/node/pull/62293

Reviewed-By: Mattias Buelens <mattias@buelens.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 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      |  91 ++++++++
 lib/internal/worker/clone_dom_exception.js    |   6 +-
 src/node_messaging.cc                         |  15 ++
 src/node_webstorage.cc                        |  18 +-
 test/common/globals.js                        |   1 +
 test/parallel/test-quotaexceedederror.js      | 199 ++++++++++++++++++
 test/parallel/test-webcrypto-random.js        |  10 +-
 test/parallel/test-webstorage.js              |  53 +++--
 test/wpt/status/WebCryptoAPI.cjs              |  16 --
 test/wpt/status/webstorage.json               |  16 --
 15 files changed, 376 insertions(+), 75 deletions(-)
 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 fb6f9623587583..86cbf2b56dd668 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -130,6 +130,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..c00a9afb105b52 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/worker/clone_dom_exception', [
+  '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..05a2002a399043 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,91 @@ for (const { 0: name, 1: codeName, 2: value } of [
 }
 
 exports.DOMException = DOMException;
+
+// 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;
+
+    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');
+    }
+
+    this.#quota = quota;
+    this.#requested = requested;
+  }
+
+  [messaging_clone_symbol]() {
+    const domExceptionClone = DOMExceptionPrototype[messaging_clone_symbol].call(this);
+    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);
+    this.#quota = data.quota;
+    this.#requested = data.requested;
+  }
+
+  get quota() {
+    if (!(#quota in this)) {
+      throwInvalidThisError(TypeError, 'QuotaExceededError');
+    }
+    return this.#quota;
+  }
+
+  get requested() {
+    if (!(#requested in this)) {
+      throwInvalidThisError(TypeError, 'QuotaExceededError');
+    }
+    return this.#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/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/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',
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/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 () => {
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 0998c37eb64cc9e147d90f3aa031a0d128b6282a Mon Sep 17 00:00:00 2001
From: Richard Lau <richard.lau@ibm.com>
Date: Thu, 19 Mar 2026 14:17:22 +0000
Subject: [PATCH 3/4] build: target Power 9 for AIX/IBM i
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Minimum supported Power architecture for AIX and IBM i is now Power 9.

PR-URL: https://github.com/nodejs/node/pull/62296
Refs: https://github.com/nodejs/node/pull/61005
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 node.gypi                        | 3 +++
 tools/v8_gypfiles/toolchain.gypi | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/node.gypi b/node.gypi
index 559330fba8b1ca..64250ed19837e4 100644
--- a/node.gypi
+++ b/node.gypi
@@ -84,6 +84,9 @@
     }, { # POSIX
       'defines': [ '__POSIX__' ],
     }],
+    [ 'OS=="aix" or OS=="os400"', {
+      'cflags': [ '-mcpu=power9' ],
+    }],
     [ 'node_enable_d8=="true"', {
       'dependencies': [ 'tools/v8_gypfiles/d8.gyp:d8' ],
     }],
diff --git a/tools/v8_gypfiles/toolchain.gypi b/tools/v8_gypfiles/toolchain.gypi
index e614c39a6b53b9..b11be560e966e6 100644
--- a/tools/v8_gypfiles/toolchain.gypi
+++ b/tools/v8_gypfiles/toolchain.gypi
@@ -330,7 +330,7 @@
         'conditions': [
           ['OS=="aix" or OS=="os400"', {
             # Work around AIX ceil, trunc and round oddities.
-            'cflags': [ '-mcpu=power5+ -mfprnd' ],
+            'cflags': [ '-mcpu=power9 -mfprnd' ],
           }],
           ['OS=="aix" or OS=="os400"', {
             # Work around AIX assembler popcntb bug.

From f84366d33943fee94756655df17f4d38dc8519da Mon Sep 17 00:00:00 2001
From: Mowafak Almahaini <97206982+SuperMo0@users.noreply.github.com>
Date: Fri, 20 Mar 2026 01:33:44 +0200
Subject: [PATCH 4/4] doc: enhance clarification about the main field

removed "this" to enhance sentence flow.

PR-URL: https://github.com/nodejs/node/pull/62302
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Jacob Smith <jacob@frende.me>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/packages.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/packages.md b/doc/api/packages.md
index d98fe357538a9a..d00eaeaf9df675 100644
--- a/doc/api/packages.md
+++ b/doc/api/packages.md
@@ -1012,7 +1012,7 @@ added: v0.4.0
 The `"main"` field defines the entry point of a package when imported by name
 via a `node_modules` lookup.  Its value is a path.
 
-When a package has an [`"exports"`][] field, this will take precedence over the
+The [`"exports"`][] field, if it exists, takes precedence over the
 `"main"` field when importing the package by name.
 
 It also defines the script that is used when the [package directory is loaded