The cached default stylesheet retains the first style-computation window

Author: domenicCreated Sep 17, 2026Updated Sep 17, 2026

Labelsmemory

Posted by GPT-6 Astra Extra High

Calling window.getComputedStyle() in a jsdom window causes the process-global parsed default stylesheet to retain the first window used for style computation, even after window.close() and after the caller drops every strong reference.

A ten-window reproduction retains index 0; an otherwise identical control that omits style computation collects all ten. This retains one window per loaded module instance, rather than one per call, but arbitrary application state reachable from that window can remain alive for the module's lifetime.

Reproduction and controls

Verified on Node.js v26.8.2, Linux x64, with a clean checkout of jsdom commit 3ab614e5 on 17 September 2026. Its package version is 30.1.0; the commit identifies the tested source more precisely than that version string. No older Node versions were tested.

To reproduce independently, prepare a checkout:

bash

git clone https://github.com/jsdom/jsdom.git jsdom-memory-repro
cd jsdom-memory-repro
git checkout 3ab614e52bc41973937993746bccd203ea874e0e
npm ci
npm run prepare

Save the script below under the indicated filename. Run the commands with the checkout root as the working directory; the scripts deliberately load that checkout's implementation and dependencies. Each command starts a fresh Node process. --expose-gc is required. The event-loop turns before GC matter: neither construction nor WeakRef observations should be assessed only within the job that created the objects.

Save as default-stylesheet.mjs:

javascript

import { createRequire } from "node:module";
import { resolve } from "node:path";
import { setImmediate } from "node:timers/promises";

const require = createRequire(resolve("package.json"));
const { JSDOM } = require("./lib/api.js");
const windows = [];

function createAndClose() {
  const { window } = new JSDOM("<body>test</body>");
  if (process.argv[2] !== "no-style") {
    window.getComputedStyle(window.document.body);
  }
  windows.push(new WeakRef(window));
  window.close();
}

for (let i = 0; i < 10; ++i) {
  createAndClose();
}
for (let i = 0; i < 8; ++i) {
  await setImmediate();
  global.gc();
}
console.log({
  aliveIndices: windows.flatMap((ref, i) => ref.deref() === undefined ? [] : [i])
});

bash

node --expose-gc default-stylesheet.mjs
node --expose-gc default-stylesheet.mjs no-style

Actual output is { aliveIndices: [ 0 ] } in the first process and { aliveIndices: [] } in the control. Expected behavior is that all ten windows can collect after the caller releases them. There is no application script, network load, jQuery, explicit stylesheet, or retained computed-style return value.

The earlier audit at jsdom 87979578c786ad4a37dd279a2e4e2fb00a46e926 obtained the same survivor with V8's compilation cache disabled. Historical jQuery reproductions exposed this problem, but the script above needs no jQuery. This is a precise bounded-retention report, not evidence that it caused all historical reports of unbounded memory growth. GC timing is nondeterministic in general; the repeated-turn control and source/heap path below are the basis for attributing this result.

Retaining path, likely fix directions, and regression guidance

The audit's heap snapshot identified this ordinary strong-reference path:

Node's module cache
  → computed-style.js module/function context
  → parsedDefaultStyleSheet
  → CSSOM implementation's _globalObject
  → first style-computation Window

computed-style.js declares parsedDefaultStyleSheet at module scope. applyStyleSheetRules() initializes it with parseStyleSheet(defaultStyleSheet, elementImpl._globalObject) once. The adjacent comment explicitly acknowledges that the CSSOM objects come from the first global, but overlooks their effect on its lifetime.

A fix must prevent process-global cached CSSOM objects from strongly owning an application window. Possible approaches include caching only realm-independent parsed data globally, or associating the CSSOM cache with a global via weak keys. Those are investigation directions, not tested fixes: account for the cost of parsing/instantiating the default stylesheet for many windows, and ensure cache values do not escape into another strong global root. Merely closing the retained window again cannot break the module's reference.

Use a fresh child process for the regression so an earlier style computation cannot initialize the cache on an unrelated window and hide the bug. Keep the no-style control and measure window reachability after event-loop turns; an RSS assertion would be too indirect. A Node-specific from-outside GC test is appropriate. Run relevant computed-style WPTs for the implementation change and benchmark repeated style queries as well as creation of many style-using windows.

This is independent of the CSS parser callback retaining the last stylesheet-parsing window. The default-stylesheet reproduction does not install that application-stylesheet error callback, and the two roots need separate fixes.

Source: jsdom/jsdom

View original on GitHub View discussion on GitHub