From cd7b50a441fafb4a9e5210b60fc123c782e4d046 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ralph=20K=C3=BCpper?= <ralph3@skelpo.com>
Date: Wed, 23 Sep 2026 22:08:57 +0000
Subject: [PATCH 1/4] fix(hir): a per-evaluation class declaration's members
 see its evaluation, not the template (#11157)

---
 crates/perry-hir/src/analysis.rs              |  9 +++
 crates/perry-hir/src/lower/context_new.rs     |  2 +
 .../perry-hir/src/lower/lowering_context.rs   | 13 ++++
 crates/perry-hir/src/lower_decl/body_stmt.rs  | 20 +++++-
 .../body_stmt/class_self_binding.rs           | 61 ++++++++++++++++
 crates/perry-hir/src/lower_decl/class_decl.rs | 24 ++++++-
 .../class_decl/decl_self_binding.rs           | 71 +++++++++++++++++++
 7 files changed, 196 insertions(+), 4 deletions(-)
 create mode 100644 crates/perry-hir/src/lower_decl/body_stmt/class_self_binding.rs
 create mode 100644 crates/perry-hir/src/lower_decl/class_decl/decl_self_binding.rs

diff --git a/crates/perry-hir/src/analysis.rs b/crates/perry-hir/src/analysis.rs
index 0b62440897..8c0eb1420d 100644
--- a/crates/perry-hir/src/analysis.rs
+++ b/crates/perry-hir/src/analysis.rs
@@ -493,6 +493,7 @@ pub fn substitute_lexical_this_in_expr(expr: &mut Expr, replacement: &Expr) {
         Expr::Closure {
             body,
             captures_this,
+            captures,
             params,
             ..
         } => {
@@ -507,6 +508,14 @@ pub fn substitute_lexical_this_in_expr(expr: &mut Expr, replacement: &Expr) {
                 // slot so the closure-cache key doesn't include a stale
                 // implicit-this snapshot.
                 *captures_this = false;
+                // #11157: a local replacement (a per-evaluation class's
+                // self-binding) is read from the closure body now, so the
+                // closure must capture it like any other outer local.
+                if let Expr::LocalGet(id) = replacement {
+                    if !captures.contains(id) {
+                        captures.push(*id);
+                    }
+                }
             }
         }
         _ => crate::walker::walk_expr_children_mut(expr, &mut |child| {
diff --git a/crates/perry-hir/src/lower/context_new.rs b/crates/perry-hir/src/lower/context_new.rs
index 7bf9399924..bc92f20bc6 100644
--- a/crates/perry-hir/src/lower/context_new.rs
+++ b/crates/perry-hir/src/lower/context_new.rs
@@ -91,6 +91,8 @@ impl LoweringContext {
             current_class_inner_name: None,
             pending_class_inner_name: None,
             class_expr_self_bindings: Vec::new(),
+            class_decl_self_binding_wanted: false,
+            class_decl_self_binding: None,
             current_class_member_is_static: false,
             private_scopes: Vec::new(),
             object_super_home_stack: Vec::new(),
diff --git a/crates/perry-hir/src/lower/lowering_context.rs b/crates/perry-hir/src/lower/lowering_context.rs
index 3c44999141..8b3f5d1bad 100644
--- a/crates/perry-hir/src/lower/lowering_context.rs
+++ b/crates/perry-hir/src/lower/lowering_context.rs
@@ -386,6 +386,19 @@ pub struct LoweringContext {
     /// while lowering that ClassBody, while nested classes can still capture
     /// an outer class expression's evaluated value.
     pub(crate) class_expr_self_bindings: Vec<(String, usize, LocalId)>,
+    /// #11157: set by the function-body class-DECLARATION arm right before it
+    /// calls `lower_class_decl`, and consumed there. When the declaration is
+    /// already known to take the per-evaluation `ClassExprFresh` path (dynamic
+    /// heritage or private elements), `lower_class_decl` then registers a
+    /// `class_expr_self_bindings` entry for the class name — exactly what a
+    /// named class expression gets — so the members' own references to the
+    /// class resolve to this evaluation instead of the shared template.
+    pub(crate) class_decl_self_binding_wanted: bool,
+    /// #11157: the compiler-private self-binding local `lower_class_decl`
+    /// registered for the declaration it just lowered (see above), handed
+    /// back to the declaration arm so it can become the `ClassExprFresh`
+    /// evaluation owner.
+    pub(crate) class_decl_self_binding: Option<LocalId>,
     /// True while lowering a static class member body.
     pub(crate) current_class_member_is_static: bool,
     /// Lexical stack of private-name scopes — one entry per enclosing class
diff --git a/crates/perry-hir/src/lower_decl/body_stmt.rs b/crates/perry-hir/src/lower_decl/body_stmt.rs
index 60c448d03a..49170705a1 100644
--- a/crates/perry-hir/src/lower_decl/body_stmt.rs
+++ b/crates/perry-hir/src/lower_decl/body_stmt.rs
@@ -17,11 +17,14 @@ use super::class_computed::push_deduped_class_computed_keys;
 use super::helpers::{async_iterator_method_call, is_filehandle_readlines_for_await_target};
 use super::*;
 
+mod class_self_binding;
 mod detect;
 mod for_await;
 pub(crate) mod gen_capture_scan;
 mod nested_fn_decl;
 
+use class_self_binding::{decl_self_binding_owner, lower_body_class_decl};
+
 use gen_capture_scan::nested_generator_references_outer_locals;
 
 use detect::{
@@ -338,7 +341,7 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
             let already_exists = ctx.pending_classes.iter().any(|c| c.name == class_name)
                 || ctx.classes_index.contains_key(&class_name);
             if !already_exists {
-                let class = lower_class_decl(ctx, class_decl, false)?;
+                let (class, decl_self_binding) = lower_body_class_decl(ctx, class_decl)?;
                 if let Some(extends_expr) = &class.extends_expr {
                     result.push(Stmt::Expr(Expr::RegisterClassParentDynamic {
                         class_name: class.name.clone(),
@@ -388,7 +391,9 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                 let fresh_binding = has_private_elements
                     || class.extends_expr.is_some()
                     || !computed_keys.is_empty()
-                    || (!captured_exprs.is_empty() && !has_static_state);
+                    || (!captured_exprs.is_empty() && !has_static_state)
+                    // #11157: members that captured the self-binding need it.
+                    || decl_self_binding.is_some();
                 let named_statics: Vec<(String, Expr)> = if fresh_binding {
                     class
                         .static_fields
@@ -447,6 +452,15 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                         ),
                     );
                 }
+                let evaluation_owner = decl_self_binding_owner(
+                    ctx,
+                    decl_self_binding,
+                    &class.name,
+                    &captured_exprs,
+                    &named_statics,
+                    &computed_keys,
+                    &computed_statics,
+                );
                 let template_name = class.name.clone();
                 ctx.pending_classes.push(class);
                 // #6465/#5893/#9502 (see `fresh_binding` above): bind the
@@ -471,7 +485,7 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                         ty: Type::Any,
                         init: Some(Expr::ClassExprFresh {
                             template: template_name,
-                            evaluation_owner: None,
+                            evaluation_owner,
                             named_statics,
                             computed_keys,
                             computed_statics,
diff --git a/crates/perry-hir/src/lower_decl/body_stmt/class_self_binding.rs b/crates/perry-hir/src/lower_decl/body_stmt/class_self_binding.rs
new file mode 100644
index 0000000000..ed5620aca5
--- /dev/null
+++ b/crates/perry-hir/src/lower_decl/body_stmt/class_self_binding.rs
@@ -0,0 +1,61 @@
+//! #11157: the class-declaration arm's half of the per-evaluation self-binding
+//! (see `lower_decl/class_decl/decl_self_binding.rs` for the lowering half).
+
+use anyhow::Result;
+use swc_ecma_ast as ast;
+
+use crate::ir::{Class, Expr};
+use crate::lower::LoweringContext;
+use crate::types::LocalId;
+
+/// Lower a function-body class declaration, asking `lower_class_decl` for a
+/// self-binding. Returns the class and the self-binding local, if one was
+/// registered. The binding stack is restored even when lowering fails.
+pub(super) fn lower_body_class_decl(
+    ctx: &mut LoweringContext,
+    class_decl: &ast::ClassDecl,
+) -> Result<(Class, Option<LocalId>)> {
+    let mark = ctx.class_expr_self_bindings.len();
+    ctx.class_decl_self_binding_wanted = true;
+    let class = super::lower_class_decl(ctx, class_decl, false);
+    ctx.class_decl_self_binding_wanted = false;
+    ctx.class_expr_self_bindings.truncate(mark);
+    let self_binding = ctx.class_decl_self_binding.take();
+    Ok((class?, self_binding))
+}
+
+/// The `ClassExprFresh` evaluation owner for a declaration: its self-binding,
+/// when anything the evaluation runs reads it. The owner local is registered
+/// with the enclosing body so it is declared (and shadow-rooted) at body
+/// entry, before codegen stores the evaluated class object in it — the same
+/// contract a named class expression's self-binding has (`arm_class.rs`).
+pub(super) fn decl_self_binding_owner(
+    ctx: &mut LoweringContext,
+    self_binding: Option<LocalId>,
+    class_name: &str,
+    captured_exprs: &[Expr],
+    named_statics: &[(String, Expr)],
+    computed_keys: &[(String, Expr)],
+    computed_statics: &[(String, Expr)],
+) -> Option<LocalId> {
+    let self_id = self_binding?;
+    let uses_self = |expr: &Expr| {
+        let mut refs = Vec::new();
+        let mut visited = std::collections::HashSet::new();
+        crate::analysis::collect_local_refs_expr(expr, &mut refs, &mut visited);
+        refs.contains(&self_id)
+    };
+    let used = captured_exprs.iter().any(&uses_self)
+        || named_statics.iter().any(|(_, value)| uses_self(value))
+        || computed_keys.iter().any(|(_, key)| uses_self(key))
+        || computed_statics.iter().any(|(_, value)| uses_self(value));
+    if !used {
+        return None;
+    }
+    let ids = ctx
+        .lookup_class_captures(class_name)
+        .map(<[_]>::to_vec)
+        .unwrap_or_default();
+    ctx.body_class_expr_captures.push((self_id, ids));
+    Some(self_id)
+}
diff --git a/crates/perry-hir/src/lower_decl/class_decl.rs b/crates/perry-hir/src/lower_decl/class_decl.rs
index 05de5e433c..c107f718fb 100644
--- a/crates/perry-hir/src/lower_decl/class_decl.rs
+++ b/crates/perry-hir/src/lower_decl/class_decl.rs
@@ -48,6 +48,7 @@ fn is_genuine_node_stream_parent(ctx: &LoweringContext, name: &str) -> bool {
 }
 
 mod class_heritage;
+mod decl_self_binding;
 mod from_ast;
 mod member_helpers;
 mod member_registration;
@@ -70,6 +71,10 @@ pub fn lower_class_decl(
     // Resolve through any active scope-local rename so a disambiguated
     // duplicate class registers (and self-references) under its unique name.
     let name = ctx.resolve_class_name(class_decl.ident.sym.as_str());
+    // #11157: consume the declaration arm's request before anything below can
+    // lower a nested class declaration.
+    let self_binding_wanted = std::mem::take(&mut ctx.class_decl_self_binding_wanted);
+    ctx.class_decl_self_binding = None;
     validate_legacy_decorator_surface(&class_decl.class, &name)?;
     validate_class_element_early_errors(&class_decl.class, &name)?;
     let class_id = match ctx.lookup_class(&name) {
@@ -443,6 +448,14 @@ pub fn lower_class_decl(
         (None, None, None, None)
     };
 
+    // #11157: a function-body declaration with a runtime heritage value or
+    // private elements is evaluated per evaluation (`ClassExprFresh`). Give
+    // its members the evaluated class, not the template, for its own name.
+    let class_self_binding = (self_binding_wanted
+        && (extends_expr.is_some()
+            || decl_self_binding::class_body_has_private_names(&class_decl.class)))
+    .then(|| decl_self_binding::push_decl_self_binding(ctx, class_decl.ident.sym.as_ref(), &name));
+
     // Issue #10486: the branches above deliberately leave `extends_name`
     // None when the heritage identifier resolves to a lexically-scoped
     // local (`locally_shadowed`) or a fully dynamic expression, to avoid
@@ -1193,9 +1206,18 @@ pub fn lower_class_decl(
     // unpatched capture slot (test262 static-field-init-this-inside-arrow).
     for sf in &mut static_fields {
         if let Some(init) = &mut sf.init {
-            crate::analysis::substitute_lexical_this_in_expr(init, &Expr::ClassRef(name.clone()));
+            match class_self_binding {
+                Some(self_id) => decl_self_binding::substitute_static_this_with_self(init, self_id),
+                None => crate::analysis::substitute_lexical_this_in_expr(
+                    init,
+                    &Expr::ClassRef(name.clone()),
+                ),
+            }
         }
     }
+    if let Some(self_id) = class_self_binding {
+        decl_self_binding::pop_decl_self_binding(ctx, self_id);
+    }
 
     // Exit type parameter scope
     ctx.exit_type_param_scope();
diff --git a/crates/perry-hir/src/lower_decl/class_decl/decl_self_binding.rs b/crates/perry-hir/src/lower_decl/class_decl/decl_self_binding.rs
new file mode 100644
index 0000000000..afc190881d
--- /dev/null
+++ b/crates/perry-hir/src/lower_decl/class_decl/decl_self_binding.rs
@@ -0,0 +1,71 @@
+//! #11157: the lexical self-binding of a per-evaluation class DECLARATION.
+//!
+//! A class declared in a function body (including the body of a CommonJS
+//! module wrapper) whose heritage is a runtime value or that has private
+//! elements lowers to a `ClassExprFresh` object per evaluation. Its static
+//! fields live on that object. Before this module, the class's own members
+//! resolved its name to `ClassRef(<template>)`, so `C.count = C.count + 1` in
+//! a static method read and wrote the shared template, never the object
+//! whose statics were initialized, and a static-field arrow's `this` was
+//! the template too. bson's `ObjectId.getInc()` (`class ObjectId extends
+//! BSONValue` inside `bson.cjs`) returned 1 on every call as a result.
+//!
+//! Named class EXPRESSIONS already get a compiler-private self-binding local
+//! (`class_expr_self_bindings`, see `arm_class.rs`) that codegen fills with
+//! the evaluated class object before any static initializer runs. These
+//! helpers give a class declaration the same binding when it is known up
+//! front to take the fresh path.
+
+use swc_ecma_ast as ast;
+
+use crate::ir::Expr;
+use crate::lower::LoweringContext;
+use crate::types::LocalId;
+
+/// Syntactic private-element check: the class will report
+/// `has_private_elements()` once lowered.
+pub(super) fn class_body_has_private_names(class: &ast::Class) -> bool {
+    class.body.iter().any(|member| match member {
+        ast::ClassMember::PrivateMethod(_) | ast::ClassMember::PrivateProp(_) => true,
+        ast::ClassMember::AutoAccessor(accessor) => {
+            matches!(accessor.key, ast::Key::Private(_))
+        }
+        _ => false,
+    })
+}
+
+/// Register the self-binding for `source_name` in the current scope. It stays
+/// active while the class body lowers and is removed by
+/// [`pop_decl_self_binding`].
+pub(super) fn push_decl_self_binding(
+    ctx: &mut LoweringContext,
+    source_name: &str,
+    template_name: &str,
+) -> LocalId {
+    let id = ctx.define_local(
+        format!("__perry_class_decl_self_{template_name}"),
+        crate::types::Type::Any,
+    );
+    ctx.class_expr_self_bindings
+        .push((source_name.to_string(), ctx.scope_depth, id));
+    id
+}
+
+pub(super) fn pop_decl_self_binding(ctx: &mut LoweringContext, id: LocalId) {
+    if let Some(pos) = ctx
+        .class_expr_self_bindings
+        .iter()
+        .rposition(|(_, _, binding)| *binding == id)
+    {
+        ctx.class_expr_self_bindings.truncate(pos);
+    }
+    ctx.class_decl_self_binding = Some(id);
+}
+
+/// `this` in a static field initializer is the class being defined. For a
+/// per-evaluation class that is the self-binding local, not the template.
+/// `substitute_lexical_this_in_expr` adds the local to the capture list of
+/// every `this`-capturing arrow it rewrites.
+pub(super) fn substitute_static_this_with_self(expr: &mut Expr, self_id: LocalId) {
+    crate::analysis::substitute_lexical_this_in_expr(expr, &Expr::LocalGet(self_id));
+}

From 4b1b899d1fc75ac58378fca55846c88a6d08f4bd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ralph=20K=C3=BCpper?= <ralph3@skelpo.com>
Date: Thu, 24 Sep 2026 00:53:08 +0000
Subject: [PATCH 2/4] fix(hir): route a per-evaluation class's own static
 reads/writes/calls through its evaluation; gap test (#11157)

---
 crates/perry-hir/src/lower/context.rs         |  29 +++++
 crates/perry-hir/src/lower/context_new.rs     |   1 +
 crates/perry-hir/src/lower/expr_assign.rs     |   4 +-
 .../lower/expr_call/static_and_instance.rs    |   6 +-
 crates/perry-hir/src/lower/expr_member.rs     |   2 +-
 .../src/lower/lower_expr/arm_ident.rs         |  14 +--
 .../src/lower/lower_expr/assignment.rs        |   4 +-
 .../perry-hir/src/lower/lowering_context.rs   |   4 +
 crates/perry-hir/src/lower_decl/body_stmt.rs  |   3 +
 crates/perry-hir/src/lower_patterns.rs        |   4 +-
 .../test_gap_11157_class_decl_self_statics.ts | 116 ++++++++++++++++++
 11 files changed, 170 insertions(+), 17 deletions(-)
 create mode 100644 test-files/test_gap_11157_class_decl_self_statics.ts

diff --git a/crates/perry-hir/src/lower/context.rs b/crates/perry-hir/src/lower/context.rs
index f1869429f7..2eae5bb63b 100644
--- a/crates/perry-hir/src/lower/context.rs
+++ b/crates/perry-hir/src/lower/context.rs
@@ -545,6 +545,35 @@ impl LoweringContext {
             .unwrap_or(false)
     }
 
+    /// The compiler-private self-binding local `name` resolves to while a
+    /// per-evaluation class body is lowered (innermost first), unless a nearer
+    /// local shadows it.
+    pub(crate) fn resolve_class_self_binding(&self, name: &str) -> Option<LocalId> {
+        let (_, binding_depth, binding_id) = self
+            .class_expr_self_bindings
+            .iter()
+            .rev()
+            .find(|(binding_name, _, _)| binding_name == name)?;
+        let shadowed_by_nearer_local = self
+            .local_decl_scope_depth(name)
+            .is_some_and(|local_depth| local_depth > *binding_depth);
+        (!shadowed_by_nearer_local).then_some(*binding_id)
+    }
+
+    /// #11157: may `<ident>.<static>` be lowered to a template-keyed
+    /// `StaticFieldSet` / `StaticFieldGet`? Not when `ident` is a per-evaluation class's
+    /// self-binding, and not for a class declaration lowered per evaluation at
+    /// all: that class's statics are own properties of each evaluated class
+    /// object, which is what every read of the binding sees.
+    pub(crate) fn static_field_access_targets_template(
+        &self,
+        ident: &str,
+        resolved_class: &str,
+    ) -> bool {
+        self.resolve_class_self_binding(ident).is_none()
+            && !self.per_evaluation_class_decls.contains(resolved_class)
+    }
+
     pub(crate) fn has_static_method(&self, class_name: &str, method_name: &str) -> bool {
         self.class_statics_index
             .get(class_name)
diff --git a/crates/perry-hir/src/lower/context_new.rs b/crates/perry-hir/src/lower/context_new.rs
index bc92f20bc6..ff676532c1 100644
--- a/crates/perry-hir/src/lower/context_new.rs
+++ b/crates/perry-hir/src/lower/context_new.rs
@@ -93,6 +93,7 @@ impl LoweringContext {
             class_expr_self_bindings: Vec::new(),
             class_decl_self_binding_wanted: false,
             class_decl_self_binding: None,
+            per_evaluation_class_decls: HashSet::new(),
             current_class_member_is_static: false,
             private_scopes: Vec::new(),
             object_super_home_stack: Vec::new(),
diff --git a/crates/perry-hir/src/lower/expr_assign.rs b/crates/perry-hir/src/lower/expr_assign.rs
index 1b08d31c8e..e3d817d028 100644
--- a/crates/perry-hir/src/lower/expr_assign.rs
+++ b/crates/perry-hir/src/lower/expr_assign.rs
@@ -693,7 +693,9 @@ fn lower_assignment_target(
                 // colliding body-local `class X`'s static write targets the
                 // renamed registrant, not the first same-named one.
                 let resolved_class = ctx.resolve_class_name(&obj_name);
-                if ctx.lookup_class(&resolved_class).is_some() {
+                if ctx.lookup_class(&resolved_class).is_some()
+                    && ctx.static_field_access_targets_template(&obj_name, &resolved_class)
+                {
                     if let ast::MemberProp::Ident(prop_ident) = &member.prop {
                         let field_name = prop_ident.sym.to_string();
                         if ctx.has_static_field(&resolved_class, &field_name) {
diff --git a/crates/perry-hir/src/lower/expr_call/static_and_instance.rs b/crates/perry-hir/src/lower/expr_call/static_and_instance.rs
index f9dfc6036f..b5eb22c13e 100644
--- a/crates/perry-hir/src/lower/expr_call/static_and_instance.rs
+++ b/crates/perry-hir/src/lower/expr_call/static_and_instance.rs
@@ -115,7 +115,11 @@ pub(super) fn try_static_method_and_instance(
             // itself keyed on a local/param binding via `lookup_native_instance`
             // (e.g. an upgrade handler's `wsId.send(...)` parameter) and must
             // still dispatch.
-            let local_shadows_class = ctx.lookup_local(&obj_name).is_some();
+            // #11157: a per-evaluation class's self-binding is a value too —
+            // `C.m()` inside C's own body must call THIS evaluation's `m`
+            // with `this` = the evaluated class object.
+            let local_shadows_class = ctx.lookup_local(&obj_name).is_some()
+                || ctx.resolve_class_self_binding(&obj_name).is_some();
             if local_shadows_class {
                 // fall through past the static arms to native-instance / generic
                 // dispatch below.
diff --git a/crates/perry-hir/src/lower/expr_member.rs b/crates/perry-hir/src/lower/expr_member.rs
index 2dbe55abeb..6e280c3a2a 100644
--- a/crates/perry-hir/src/lower/expr_member.rs
+++ b/crates/perry-hir/src/lower/expr_member.rs
@@ -1066,7 +1066,7 @@ fn lower_member_inner(ctx: &mut LoweringContext, member: &ast::MemberExpr) -> Re
             ctx.inferred_class_bindings
                 .class_key_for(local, source_name)
                 != Some(source_name)
-        });
+        }) || ctx.resolve_class_self_binding(source_name).is_some();
         let obj_name = ctx.resolve_class_name(source_name);
         if !local_shadows_class && ctx.lookup_class(&obj_name).is_some() {
             if let ast::MemberProp::Ident(prop_ident) = &member.prop {
diff --git a/crates/perry-hir/src/lower/lower_expr/arm_ident.rs b/crates/perry-hir/src/lower/lower_expr/arm_ident.rs
index 3485153715..77231f6227 100644
--- a/crates/perry-hir/src/lower/lower_expr/arm_ident.rs
+++ b/crates/perry-hir/src/lower/lower_expr/arm_ident.rs
@@ -71,18 +71,8 @@ pub(crate) fn lower_ident_expr(ctx: &mut LoweringContext, ident: &ast::Ident) ->
     // compiler-private local so its own members use this evaluation and a
     // nested class can capture an outer class expression's binding. Search
     // innermost-first to preserve ordinary lexical shadowing.
-    if let Some((_, binding_depth, binding_id)) = ctx
-        .class_expr_self_bindings
-        .iter()
-        .rev()
-        .find(|(binding_name, _, _)| binding_name == &name)
-    {
-        let shadowed_by_nearer_local = ctx
-            .local_decl_scope_depth(&name)
-            .is_some_and(|local_depth| local_depth > *binding_depth);
-        if !shadowed_by_nearer_local {
-            return Ok(Expr::LocalGet(*binding_id));
-        }
+    if let Some(binding_id) = ctx.resolve_class_self_binding(&name) {
+        return Ok(Expr::LocalGet(binding_id));
     }
     if ctx.current_class_inner_name.as_deref() == Some(name.as_str()) && !nearer_local {
         if let Some(current) = ctx.current_class.clone() {
diff --git a/crates/perry-hir/src/lower/lower_expr/assignment.rs b/crates/perry-hir/src/lower/lower_expr/assignment.rs
index be59969e7d..7102796b78 100644
--- a/crates/perry-hir/src/lower/lower_expr/assignment.rs
+++ b/crates/perry-hir/src/lower/lower_expr/assignment.rs
@@ -24,7 +24,9 @@ pub(crate) fn lower_expr_assignment(
                 // colliding body-local `class X`'s static write targets the
                 // renamed registrant, not the first same-named one.
                 let obj_name = ctx.resolve_class_name(obj_ident.sym.as_ref());
-                if ctx.lookup_class(&obj_name).is_some() {
+                if ctx.lookup_class(&obj_name).is_some()
+                    && ctx.static_field_access_targets_template(obj_ident.sym.as_ref(), &obj_name)
+                {
                     if let ast::MemberProp::Ident(prop_ident) = &member.prop {
                         let field_name = prop_ident.sym.to_string();
                         if ctx.has_static_field(&obj_name, &field_name) {
diff --git a/crates/perry-hir/src/lower/lowering_context.rs b/crates/perry-hir/src/lower/lowering_context.rs
index 8b3f5d1bad..4b34a4526f 100644
--- a/crates/perry-hir/src/lower/lowering_context.rs
+++ b/crates/perry-hir/src/lower/lowering_context.rs
@@ -399,6 +399,10 @@ pub struct LoweringContext {
     /// back to the declaration arm so it can become the `ClassExprFresh`
     /// evaluation owner.
     pub(crate) class_decl_self_binding: Option<LocalId>,
+    /// #11157: template names of class DECLARATIONS that lowered to a
+    /// per-evaluation `ClassExprFresh` binding. A static write through such a
+    /// class's name must reach the evaluated object, not the template.
+    pub(crate) per_evaluation_class_decls: HashSet<String>,
     /// True while lowering a static class member body.
     pub(crate) current_class_member_is_static: bool,
     /// Lexical stack of private-name scopes — one entry per enclosing class
diff --git a/crates/perry-hir/src/lower_decl/body_stmt.rs b/crates/perry-hir/src/lower_decl/body_stmt.rs
index 49170705a1..b06a72a10f 100644
--- a/crates/perry-hir/src/lower_decl/body_stmt.rs
+++ b/crates/perry-hir/src/lower_decl/body_stmt.rs
@@ -462,6 +462,9 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                     &computed_statics,
                 );
                 let template_name = class.name.clone();
+                if fresh_binding {
+                    ctx.per_evaluation_class_decls.insert(template_name.clone());
+                }
                 ctx.pending_classes.push(class);
                 // #6465/#5893/#9502 (see `fresh_binding` above): bind the
                 // declared name to a per-evaluation heap class object carrying
diff --git a/crates/perry-hir/src/lower_patterns.rs b/crates/perry-hir/src/lower_patterns.rs
index 9260d33b80..e0b4bac627 100644
--- a/crates/perry-hir/src/lower_patterns.rs
+++ b/crates/perry-hir/src/lower_patterns.rs
@@ -218,7 +218,9 @@ pub(crate) fn lower_assign_target_to_expr(
             // Check if this is a static field access
             if let ast::Expr::Ident(obj_ident) = member.obj.as_ref() {
                 let obj_name = obj_ident.sym.to_string();
-                if ctx.lookup_class(&obj_name).is_some() {
+                if ctx.lookup_class(&obj_name).is_some()
+                    && ctx.static_field_access_targets_template(&obj_name, &obj_name)
+                {
                     if let ast::MemberProp::Ident(prop_ident) = &member.prop {
                         let field_name = prop_ident.sym.to_string();
                         if ctx.has_static_field(&obj_name, &field_name) {
diff --git a/test-files/test_gap_11157_class_decl_self_statics.ts b/test-files/test_gap_11157_class_decl_self_statics.ts
new file mode 100644
index 0000000000..12882eb48b
--- /dev/null
+++ b/test-files/test_gap_11157_class_decl_self_statics.ts
@@ -0,0 +1,116 @@
+// #11157: a class DECLARATION in a function body (a CommonJS module body is
+// one) that is evaluated per evaluation — its heritage is a runtime value, or
+// it has private elements — must see THIS evaluation's class object when its
+// members name the class. bson's ObjectId is the real shape: its base class
+// reads a module-level const, so `class ObjectId extends BSONValue` inside
+// bson.cjs is per-evaluation, and `ObjectId.index = (ObjectId.index + 1)` in a
+// static method read and wrote the shared template, so every id was the same.
+
+function bsonShape(): any {
+  const MAJOR = 7;
+  class Base {
+    get version() {
+      return MAJOR;
+    }
+  }
+  class Oid extends Base {
+    static index = 0;
+    static PROCESS_UNIQUE: number[] | null = null;
+    static resetState = () => {
+      this.index = 100;
+      this.PROCESS_UNIQUE = null;
+    };
+    static {
+      this.resetState();
+      console.log("static block: this === Oid", this === Oid, "index", Oid.index);
+    }
+    static cacheHexString: boolean | undefined;
+    inc: number;
+    pu: number[];
+    constructor() {
+      super();
+      this.inc = Oid.getInc();
+      this.pu = (Oid.PROCESS_UNIQUE ??= [1, 2, 3, 4, 5]);
+    }
+    static getInc() {
+      return (Oid.index = (Oid.index + 1) % 0x1000000);
+    }
+    static createPk() {
+      return new Oid();
+    }
+    static bumpTwice() {
+      Oid.index += 2;
+      Oid.index++;
+      return Oid.index;
+    }
+    sameClass() {
+      return this.constructor === Oid;
+    }
+  }
+  return Oid;
+}
+
+const factories: any[] = [bsonShape];
+const Oid = factories[0]();
+const a = new Oid();
+const b = new Oid();
+const c = Oid.createPk();
+console.log("counters", a.inc, b.inc, c.inc);
+console.log("distinct", new Set([a.inc, b.inc, c.inc]).size);
+console.log("PROCESS_UNIQUE shared", a.pu === b.pu && b.pu === c.pu, "length", a.pu.length);
+console.log("static index", Oid.index, "cacheHexString", Oid.cacheHexString);
+console.log("constructor === Oid", a.sameClass(), "version", a.version);
+console.log("compound", Oid.bumpTwice(), Oid.index);
+Oid.index = 500;
+Oid.index += 1;
+console.log("outside write", Oid.index, new Oid().inc);
+Oid.resetState();
+console.log("after resetState", Oid.index, Oid.PROCESS_UNIQUE);
+
+// Two evaluations keep their own statics.
+const Oid2 = factories[0]();
+const d = new Oid2();
+console.log("second evaluation", Oid2 !== Oid, d.inc, Oid.index, Oid2.index);
+
+// A nested arrow in a static initializer still sees the evaluation.
+function nestedArrow(): any {
+  const tag = "t";
+  class Base {
+    t() {
+      return tag;
+    }
+  }
+  class N extends Base {
+    static label = "n";
+    static self = () => () => this;
+    static read() {
+      return N.label;
+    }
+  }
+  return N;
+}
+const N = [nestedArrow][0]();
+console.log("nested arrow this", N.self()() === N, N.read());
+
+// Private elements make a function-body class per-evaluation too.
+function privateShape(): any {
+  class P {
+    #x = 1;
+    static n = 0;
+    inc: number;
+    constructor() {
+      this.inc = P.bump();
+    }
+    static bump() {
+      return (P.n = P.n + 1);
+    }
+    get x() {
+      return this.#x;
+    }
+  }
+  return P;
+}
+const P = [privateShape][0]();
+const p1 = new P();
+const p2 = new P();
+console.log("private", p1.inc, p2.inc, P.n, p1.x);

From c87904bf6aa3e2fa253e2e7eeeb07919c9c49379 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ralph=20K=C3=BCpper?= <ralph3@skelpo.com>
Date: Thu, 24 Sep 2026 02:08:01 +0000
Subject: [PATCH 3/4] test(hir): per-evaluation class declaration statics route
 through the evaluation (#11157)

---
 crates/perry-hir/src/lower/tests.rs           |  2 +
 .../issue_11157_class_decl_self_statics.rs    | 74 +++++++++++++++++++
 2 files changed, 76 insertions(+)
 create mode 100644 crates/perry-hir/src/lower/tests/issue_11157_class_decl_self_statics.rs

diff --git a/crates/perry-hir/src/lower/tests.rs b/crates/perry-hir/src/lower/tests.rs
index 75adeb6b7b..45a39ed5bc 100644
--- a/crates/perry-hir/src/lower/tests.rs
+++ b/crates/perry-hir/src/lower/tests.rs
@@ -1989,3 +1989,5 @@ mod issue_10623_require_destructured_native_super;
 mod issue_10745_passthrough_heritage;
 
 mod hoisted_sibling_in_later_closure;
+
+mod issue_11157_class_decl_self_statics;
diff --git a/crates/perry-hir/src/lower/tests/issue_11157_class_decl_self_statics.rs b/crates/perry-hir/src/lower/tests/issue_11157_class_decl_self_statics.rs
new file mode 100644
index 0000000000..96674f9799
--- /dev/null
+++ b/crates/perry-hir/src/lower/tests/issue_11157_class_decl_self_statics.rs
@@ -0,0 +1,74 @@
+//! #11157: a function-body class DECLARATION lowered per evaluation
+//! (`ClassExprFresh`) keeps its statics on each evaluated class object. Its
+//! own members must reach them through that evaluation, never through the
+//! template-keyed `StaticFieldGet`/`StaticFieldSet` or `ClassRef`.
+
+fn lower(source: &str) -> crate::ir::Module {
+    let module = perry_parser::parse_typescript(source, "t.ts").expect("source parses");
+    super::lower_module(&module, "t", "t.ts").expect("source lowers")
+}
+
+fn static_method_debug(hir: &crate::ir::Module, class: &str, method: &str) -> String {
+    let class = hir
+        .classes
+        .iter()
+        .find(|c| c.name == class)
+        .unwrap_or_else(|| panic!("{class} is lowered"));
+    let method = class
+        .static_methods
+        .iter()
+        .find(|m| m.name == method)
+        .unwrap_or_else(|| panic!("{method} is lowered"));
+    format!("{:?}", method.body)
+}
+
+#[test]
+fn per_evaluation_class_decl_members_use_the_evaluation() {
+    let hir = lower(
+        r#"
+        function mk() {
+            const V = 7;
+            class Base { get v() { return V; } }
+            class C extends Base {
+                static n = 0;
+                static reset = () => { this.n = 40; };
+                static bump() { return (C.n = (C.n + 1) % 0x1000000); }
+            }
+            return C;
+        }
+        "#,
+    );
+    let bump = static_method_debug(&hir, "C", "bump");
+    assert!(!bump.contains("StaticFieldSet"), "template write: {bump}");
+    assert!(!bump.contains("StaticFieldGet"), "template read: {bump}");
+    let class = hir.classes.iter().find(|c| c.name == "C").unwrap();
+    let reset = class
+        .static_fields
+        .iter()
+        .find(|f| f.name == "reset")
+        .and_then(|f| f.init.as_ref())
+        .expect("reset has an initializer");
+    let reset = format!("{reset:?}");
+    assert!(
+        !reset.contains("ClassRef(\"C\")"),
+        "arrow this is the template: {reset}"
+    );
+}
+
+#[test]
+fn module_top_class_keeps_the_template_static_path() {
+    let hir = lower(
+        r#"
+        class Base {}
+        class C extends Base {
+            static n = 0;
+            static bump() { return (C.n = C.n + 1); }
+        }
+        "#,
+    );
+    let bump = static_method_debug(&hir, "C", "bump");
+    assert!(
+        bump.contains("StaticFieldSet"),
+        "control lost its fast path: {bump}"
+    );
+}

From 1ed53c32a758884ad0872ee27f69a25a7f6ace21 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ralph=20K=C3=BCpper?= <ralph3@skelpo.com>
Date: Thu, 24 Sep 2026 02:58:23 +0000
Subject: [PATCH 4/4] changelog: #11188 per-evaluation class declaration
 statics (#11157)

---
 changelog.d/11188-class-decl-self-statics.md | 22 ++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 changelog.d/11188-class-decl-self-statics.md

diff --git a/changelog.d/11188-class-decl-self-statics.md b/changelog.d/11188-class-decl-self-statics.md
new file mode 100644
index 0000000000..9a0ab8a9d5
--- /dev/null
+++ b/changelog.d/11188-class-decl-self-statics.md
@@ -0,0 +1,22 @@
+fix(hir): a per-evaluation class declaration's own members see its evaluation, not the shared template (#11157)
+
+bson's `ObjectId` (mongodb 7.5.0 installs bson 7.3.3) gave the same id on every `new ObjectId()` when compiled through `perry.compilePackages`: the counter was always 1 and the 5 `PROCESS_UNIQUE` bytes were all 0. mongodb's `insertMany` then failed with `E11000 duplicate key`.
+
+Root cause: `class ObjectId extends BSONValue` sits inside `bson.cjs`, and a CommonJS module body is a function body. Its base `BSONValue` reads module-level consts, so `BSONValue` is a capturing class value and `ObjectId`'s heritage is a runtime value (`extends_expr`). That sends the declaration down the per-evaluation `ClassExprFresh` path, and its statics (`index`, `PROCESS_UNIQUE`) become own properties of the evaluated class object. The class's own members still resolved the name `ObjectId`, and `this` in a static-field arrow, to the shared template:
+
+- `ObjectId.index = (ObjectId.index + 1) % 0x1000000` in `static getInc()` lowered to a template-keyed `StaticFieldSet`, with `StaticFieldGet` for the read. It read and wrote the template global, never the object whose `index` the static block had set.
+- `static resetState = () => { this.index = …; this.PROCESS_UNIQUE = null }` had `this` replaced by `ClassRef(template)`. `this === ObjectId` was false in the static block, and the reset wrote to the template.
+- `ObjectId.PROCESS_UNIQUE ??= ByteUtils.randomBytes(5)` in the constructor stored the random bytes where the next read never looked, so the packed id read `undefined` bytes, which came out as 0.
+
+Named class *expressions* already had a compiler-private self-binding local (`class_expr_self_bindings`) that codegen fills with the evaluated class object before any static initializer runs. Class *declarations* did not. The fix:
+
+- `lower_class_decl` registers the same self-binding for a function-body declaration that takes the fresh path because of runtime heritage or private elements. The declaration arm asks for it through `class_decl_self_binding_wanted`. Members then resolve the class name to this evaluation, and `this` in static-field initializers becomes the self-binding. `substitute_lexical_this_in_expr` now adds a local replacement to each rewritten arrow's capture list.
+- The `ClassExprFresh` for the declaration carries the binding as its `evaluation_owner` when a static initializer or capture uses it. The owner is registered with the enclosing body's class-expression owners, so it is declared and rooted at body entry.
+- The template-keyed `StaticFieldGet`/`StaticFieldSet`/`StaticMethodCall` fast paths no longer fire for a self-binding or for a declaration recorded as per-evaluation (`per_evaluation_class_decls`). Those accesses go through the class value.
+
+Module-top classes and function-body classes that stay on the shared-template path are unchanged. A unit test asserts that the control keeps its `StaticFieldSet`.
+
+Validation (Linux x64, perry-dev, Node 26.5.1):
+- `test-files/test_gap_11157_class_decl_self_statics.ts` fails on main at 93a86ffb, passes with the fix, and its output is byte-identical to Node.
+- bson 7.3.3 repro from the issue: main gives `distinct 1 rand-zero true counter-step 0`. With the fix it gives `distinct 3 rand-zero false counter-step 1` both with `PERRY_NO_AUTO_OPTIMIZE=1` and with auto-optimize on, which matches Node.
+- `lower::tests::issue_11157_class_decl_self_statics` has 2 tests. The per-evaluation test fails with the source change reverted and passes with it.