A class has `static #count = 0` and `static bump() { this.#count++; }`. Calling `Base.bump()` works, but `Sub.bump()` on `class Sub extends Base {}` throws a TypeError. Why, and how do you fix it?

## Private names are slots, not properties The `#name` syntax does not create a property with an odd character in it. It creates a private name bound lexically to the class body, and the engine installs a matching *slot* on specific objects. For a private instance member, the slot is added to each instance as it is constructed. For a private **static** member, the slot is added to exactly one object: the constructor of the class that declared it. That one sentence explains the whole failure. ```js class Base { static #count = 0; static bump() { this.#count++; return this.#count; } } class Sub extends Base {} Base.bump(); // 1 Sub.bump(); // TypeError ``` ## Walking the failure `Sub.bump` resolves fine: `extends` makes `Base` the prototype of the `Sub` constructor object, so the method is found by ordinary prototype lookup. The call then runs `Base`'s method body with `this === Sub`, because `this` in a static is the receiver. Now the body evaluates `this.#count`. Private access performs a **brand check**: does this object actually carry the `#count` slot? `Sub` does not — the slot was installed on `Base` only, and slots are not inherited through the prototype chain the way properties are. A failed brand check is specified to throw a `TypeError`; it never falls back to the prototype chain and never yields `undefined`. (The exact message varies by engine, so do not memorise wording — memorise that it is a `TypeError`.) Contrast the public version, which quietly does something different but also surprising: ```js class PubBase { static count = 0; static bump() { this.count++; } } class PubSub extends PubBase {} PubSub.bump(); PubBase.count; // 0 — the read went through the chain, the write made an own property on PubSub PubSub.count; // 1 ``` So the public field silently splits into two counters, while the private field throws. Both are the same underlying issue — `this` is the subclass — with different failure modes, and the loud one is arguably kinder. ## Fixing it Decide what you actually want. **One counter for the whole hierarchy.** Stop using the receiver; name the declaring class: ```js class Base { static #count = 0; static bump() { return ++Base.#count; } } class Sub extends Base {} Sub.bump(); // 1 — the access targets Base regardless of the receiver ``` This works because the private name is lexically scoped to the class body, and `Base` inside it refers to the class binding — the object that owns the slot. **One counter per subclass.** Private statics cannot express that at all, since only the declaring class has the slot. Use something keyed by the receiver instead: ```js const counts = new WeakMap(); class Base { static bump() { const n = (counts.get(this) ?? 0) + 1; counts.set(this, n); return n; } } class Sub extends Base {} Sub.bump(); Sub.bump(); Base.bump(); // Sub: 2, Base: 1, kept separate ``` A `WeakMap` keyed by the constructor gives per-class state without the slot problem, and keeps the storage out of the public surface. A public static that each subclass redeclares (`static count = 0` in both) also works and is simpler to read, at the cost of being writable from outside. ## Detecting the slot Because the failure is a `TypeError` rather than a value, you cannot probe it with `in` the way you would a property — you use the ergonomic brand check, which is exactly what that syntax is for: ```js class Base { static #count = 0; static hasSlot(o) { return #count in o; } } Base.hasSlot(Base); // true Base.hasSlot(class Sub extends Base {}); // false — proves the slot is not inherited ``` ## The general rule to carry away Any static method that touches a private static **and** can be reached from a subclass is a latent `TypeError` waiting for the first person who writes `Sub.method()`. It is invisible in tests that only ever exercise the base class, and subclassing is exactly the kind of change a different team makes later. Treat `this.#x` inside a static as a smell: either pin the access to the declaring class by name, or move the state somewhere the receiver can legitimately vary.