Subclass built inside a per-evaluation class's own static method fails '#x in' and instanceof against that class (redis RedisClient.factory shape) #11142

Summary

A per-evaluation class (declared inside a function, or top-level inside a CommonJS wrapper) builds a subclass inside one of its own static methods, as in class extends RC {}. Instances of that subclass then fail #field in instance and instance instanceof RC, and both return false. Reading this.#field through an inherited method still works.

The same subclass built outside the class body passes both checks.

This is @redis/client 6.1.0's own shape. RedisClient.factory calls attachConfig({ BaseClass: RedisClient, ... }) from inside the static method, and RedisClient.create does new (RedisClient.factory(options))(options). So a redis client has client instanceof RedisClient === false under Perry.

Repro (no packages)

function body(tag: string) {
  function attachConfig(BaseClass: any) { return class extends BaseClass {}; }
  class RC {
    #s = tag;
    static make() { const C = attachConfig(RC); return new C(); }
    static has(o: any) { return #s in o; }
    read() { return this.#s; }
  }
  const viaStatic: any = RC.make();
  const C2 = attachConfig(RC);
  const viaOuter: any = new C2();
  console.log("static-made", viaStatic.read(), RC.has(viaStatic), viaStatic instanceof RC);
  console.log("outer-made", viaOuter.read(), RC.has(viaOuter), viaOuter instanceof RC);
}
body("t");

• Node 26.5.1: static-made t true true / outer-made t true true
• Perry origin/main 36892b7 plus PR fix(runtime): resolve an ancestor's #private brand through the instance's evaluation heritage chain #11141 (perry-dev build, PERRY_NO_AUTO_OPTIMIZE=1): static-made t false false / outer-made t true true
• Perry origin/main 36892b7 alone: static-made t false false, then the outer-made line throws Cannot access private member… (that part is Private field holding new EventEmitter() from require("events") is unreadable when its class is constructed as a parent (next redis createClient blocker) #11131/Base-class method can't read its #private field on a subclass instance when both classes are function-local #11127, fixed by fix(runtime): resolve an ancestor's #private brand through the instance's evaluation heritage chain #11141).

Likely cause (not confirmed with instrumentation)

Inside the class body, RC in static make() resolves to the class's template ClassRef rather than to the current evaluation's class object. So the subclass evaluation pins a ClassRef as its parent. Both of the following follow the per-evaluation pinned parent chain, which stops at that ClassRef without reaching the RC evaluation the caller holds:

• fix(runtime): resolve an ancestor's #private brand through the instance's evaluation heritage chain #11141's instance private-brand walk (pinned_class_object_for_ancestor)
• instanceof's per-evaluation heritage walk (instanceof against a ClassExprFresh parent resolves by shared class id, so an earlier evaluation's class can fail instanceof after a later evaluation #10624)

Per spec, the class's inner binding is the class object of that evaluation. The fix probably belongs where a fresh class's self-reference inside its own body is lowered. The #9052/#9089 static-private self-reference work is nearby.

Found while re-checking redis attachConfig for #11131 / PR #11141.