diff --git a/changelog.d/11840-class-fresh-evaluations.md b/changelog.d/11840-class-fresh-evaluations.md
new file mode 100644
index 0000000000..7dbf35e9a2
--- /dev/null
+++ b/changelog.d/11840-class-fresh-evaluations.md
@@ -0,0 +1,39 @@
+**A class declaration evaluated more than once now creates a fresh class on every evaluation after the first, as Node does** (#11759).
+
+`function f() { class K {} return K }` returned the same class on every call, so `f() === f()` was `true`, a property written to one evaluation's `prototype` showed up on the other's instances, `instanceof` answered `true` across evaluations, and every evaluation shared the same static fields. The same happened for a class declared in a module-level loop body. Classes that capture variables, have private elements, or have a computed key or a runtime `extends` value were already fresh per evaluation.
+
+The fix follows owner decision 64, option (c′). The first evaluation of a declaration is still the shared class, so code that runs once keeps the static class and its fast paths: bundle wrappers (esbuild `__esm`/`__commonJS` bodies, which only the runtime can see running once), functions called once, and module top level. The second and later evaluations each create a fresh class object, built from #11780's template shapes.
+
+- **The evaluation check.** Whether the first evaluation has happened is a fact of the class template: a module-private word per template (`@perry_class_first_eval.<template>`) that holds the shared class once the first evaluation has handed it out. An evaluation does one load, one compare and one branch. No word and no check is emitted where `lower::run_once` proves the declaration runs once: module top level outside loops, IIFE bodies, and functions called once from such a position.
+- **The class's own name inside a repeatable declaration.** It resolves to that evaluation. The members read it from a guarded class environment, the scheme fresh class expressions use, so first-evaluation instances carry no capture fields.
+- **Static forms where the binding holds the first evaluation.** `new C(...)`, `C.<static field>` and `C.<static method>(...)` through the binding are guarded on the first evaluation and take the static form there: a static `new`, a direct static-field load and a static call. The exact-receiver inliner treats the guarded `new` as constructing `C`; every evaluation runs C's constructor and carries C's declaration-time method table.
+- **Loops test once.** A `for`, `while` or `do` loop holding such guards on a binding it cannot rebind (not boxed, not a module global, never reassigned in the body, not rebound by the loop) tests the binding once before the loop and is lowered twice: the first-evaluation copy holds only the static forms, so `const c = new C()` in it is scalar-replaced as a single evaluation's would be, and the later-evaluation copy holds only the by-value forms. A loop that defines a closure or a class keeps its per-use tests. Escape analysis now walks a class evaluation and the first-evaluation test by their operands instead of escaping every candidate in the body.
+- **Field proofs come from the template.** A local bound to the guarded `new` (`const c = new C()`) gets the `Ptr<Shape>` proof of every rule except the exact class object, recorded as a template-lineage fact: every evaluation of one template runs the same constructor chain, field initializers and methods on the same arguments, so which fields hold a Number is a fact of the template. It feeds the Number-by-construction proof and the canonical-number test for reads of those fields in both copies of a versioned loop, so `t += c.x` keeps `t` a Number. It never licenses a bare field load or a direct method call by itself.
+- **The rest of a body tests once.** The statements after `const c = new C()` in a function body test the first evaluation once and are lowered twice when the binding cannot be rebound, they define no closure or class, hold at most 400 HIR nodes, and either use `c` or test the binding outside a loop. In the first-evaluation copy (and in a versioned loop's) `c` is an instance of the shared class, which is the lineage fact's missing exactness: its field reads and method calls take the `Ptr<Shape>` forms.
+- **Subclasses in the same body.** `class D extends L`, where `L` is such a declaration in the same body, is one too. D's template extends L's template, and D shares its first evaluation only while L's binding holds L's first evaluation. Every other evaluation of D pins the evaluated `L` it extends.
+- **Captured values.** The template-keyed capture snapshot (`RegisterClassCaptures`, read when the shared class is constructed by value) and its body-end refreshes belong to the first evaluation only. A later evaluation carries its own capture array.
+- **Runtime.** A class function object has a second INT32 capture slot that records whether it is its declaration's first evaluation. Generated code sets it when the first evaluation hands the shared class out; the slot index and value are in `perry-abi`. From then on the shared class is a class of its own:
+  - a later evaluation's static writes are no longer mirrored into it (#6530);
+  - it no longer stands in for the template in `CLASS_OBJECT_VALUES`;
+  - its static parent is no longer replaced by a later evaluation's parent;
+  - `instanceof` against either evaluation, and `instance.constructor` of a later evaluation's instance, follow the instance's actual prototype chain.
+- **Fixed on the way.** `monomorph`'s default-argument padding now reaches a `new` inside `ClassEnvStamp`. It also missed fresh class expressions' guarded `new K()`, which left captured values in omitted constructor parameters.
+
+**Validation**
+
+- **New gap tests.** `test_gap_11759_class_decl_fresh_per_evaluation`, `test_gap_11759_class_decl_loop_extends_wrapper` and `test_gap_11759_class_decl_evaluations_gc` cover identity, prototype isolation, statics, `delete`, captures, self-reference, instance fields, a module-top loop, `extends` of an evaluated class, a module-level parent, an esbuild `__esm` wrapper, a CommonJS factory a three-level chain with `super` calls and inherited statics over three evaluations, a subclass declared in a nested function, and 400 evaluations under GC pressure.
+  - All three match Node 26.5.1. The GC test also matches under `PERRY_GC_MOVING_LOOP_POLLS`, `PERRY_GC_FORCE_EVACUATE`, `PERRY_GC_POISON_FROMSPACE` and a 64 KB allocation schedule.
+  - All three fail on main and on a sabotaged build whose every evaluation is the shared class.
+  - `test_gap_11759_class_decl_first_evaluation_versions` runs the versioned loops and body tails through a first and two later evaluations: numeric and string fields, captured values, methods, `instanceof`, statics, and a binding the tail rebinds. It matches Node on main and on this change, and under the same five GC settings on this change.
+- **IR test.** `crates/perry/tests/issue_11759_class_first_evaluation.rs` checks that a repeatable declaration emits the check and fresh later evaluations, that a module-top loop body is repeatable, that a loop over the class is versioned once and a loop rebinding it is not, that an accumulator over its field adds as a Number in both copies, that the rest of a body after `const c = new C()` is versioned and a rest that defines a closure is not, that an IIFE, a module-top block and a function called once emit neither, and that the esbuild wrapper keeps its one class.
+- **Suites.** The full gap suite against main 2026ecfe6: no test goes from PASS to anything else, and the only real differences are the three new tests passing (rows that failed to build under load on one arm were rerun; the 16 HTTP/2 and WebSocket tests fail on both). Runtime: 4850/0 (`RUST_TEST_THREADS=1`, release). `perry-hir` 880/0, `perry-transform` 198/0, `perry-codegen` 2473/0, the IR test 9/9, `cargo fmt --check` clean. `gc_call_effects --check` (linux-x86_64) shows no drift from this change, and `--check-wasm-abi` is current.
+- **Cost.** Instruction counts against main 2026ecfe6.
+  - tsc and Zod (n=5): Zod +0.02% instructions, 0/0 full collections, RSS 55.5/55.3 MB; tsc +0.04%, 82/82 full collections, RSS 296.3/296.7 MB. `.text` is tsc −37.7 KB and Zod +3.7 KB. Neither program has a versioned loop or body tail (tsc has 4 repeatable declarations, Zod none), so the versioning adds no code to either.
+  - A body that runs once but cannot be proven to, with a hot loop over its class (`new` + method + static field + static call): 215 → 216 instructions per iteration.
+    - `new C()` + field read into an accumulator: 35 → 35;
+    - method call on an instance built before the loop: 7 → 7;
+    - static field read: 30 → 31; static call: 82 → 84. The loop's IR is the same as main's; the function holds both copies of the loop, and the register allocator rematerializes two constants in the hot one.
+  - A later evaluation pays #11780's fresh-class path, which this change does not touch: evaluation + `new` + call is 30.8k instructions against 3.8k for the shared class (node: 13.5k); `new` + call on an existing later evaluation is 9.0k against 4.2k; a static method adds ~650 per evaluation. Most of an evaluation is its prototype, built at the first `new` (about 30%: the object, one function object per method, and two template-cell lookups through the class registry lock), linking the instance to it (about 24%: interning the per-evaluation instance shape and marking the prototype), the class object (10%) and the minor collections all of that allocation causes (11%).
+  - Of the repo files that evaluate such a declaration more than once:
+    - `test_gap_10490_implicit_this_scope_rooting` (500 evaluations): +0.8%;
+    - `test_gap_9466_shadowed_class_identity` (3 evaluations): +10.7% of a 6.3M-instruction run.
diff --git a/crates/perry-abi/src/lib.rs b/crates/perry-abi/src/lib.rs
index 06c7300a4c..71b2dc8f65 100644
--- a/crates/perry-abi/src/lib.rs
+++ b/crates/perry-abi/src/lib.rs
@@ -61,6 +61,13 @@ pub const STATIC_CALL_MEMO_C_OFFSET: usize = 8;
 pub const STATIC_CALL_MEMO_OWNER_OFFSET: usize = 16;
 pub const STATIC_CALL_MEMO_VALUE_OFFSET: usize = 24;
 
+/// #11759 (c′): the capture slot of a class function object (an INT32) that
+/// says whether the object is its declaration's first evaluation, and the
+/// value generated code stores there when the first evaluation hands the
+/// shared class out (`INT32_TAG | 1`; the slot is born `INT32_TAG | 0`).
+pub const CLASS_EVALUATION_STATE_CAPTURE: usize = 1;
+pub const CLASS_FIRST_EVALUATION_STATE: u64 = 0x7FFE_0000_0000_0001;
+
 /// `gc::GC_TYPE_CLOSURE`: the GcHeader type byte (at payload - 8) that makes a
 /// cell a function object. The kind is this byte, never a payload magic.
 pub const GC_TYPE_CLOSURE: u8 = 4;
diff --git a/crates/perry-codegen/src/codegen/artifacts.rs b/crates/perry-codegen/src/codegen/artifacts.rs
index f3ab2087b0..0f957490e2 100644
--- a/crates/perry-codegen/src/codegen/artifacts.rs
+++ b/crates/perry-codegen/src/codegen/artifacts.rs
@@ -1043,6 +1043,11 @@ pub(super) fn emit_module_artifacts(
     );
     progress.checkpoint("string pool and registration initializer");
 
+    crate::expr::class_first_evaluation::emit_flag_globals(
+        llmod,
+        &super::fresh_class_templates::shared_first_templates(hir),
+    );
+
     super::namespace_value_getters::emit(llmod, module_prefix, cross_module);
 
     Ok(())
diff --git a/crates/perry-codegen/src/codegen/fresh_class_templates.rs b/crates/perry-codegen/src/codegen/fresh_class_templates.rs
index a818c726a9..9533ab39da 100644
--- a/crates/perry-codegen/src/codegen/fresh_class_templates.rs
+++ b/crates/perry-codegen/src/codegen/fresh_class_templates.rs
@@ -29,31 +29,76 @@ pub(crate) fn template_cell_words(class: Option<&perry_hir::Class>) -> usize {
 /// Every `ClassExprFresh` template named anywhere in `hir`: module init,
 /// function bodies, class members and nested closures.
 pub(crate) fn fresh_class_templates(hir: &perry_hir::Module) -> HashSet<String> {
-    fn visit_expr(e: &Expr, out: &mut HashSet<String>) {
-        if let Expr::ClassExprFresh { template, .. } = e {
+    templates_where(hir, |_| true)
+}
+
+/// The templates whose first evaluation is the shared class (#11759 (c′),
+/// `ClassExprFresh { shared_first_evaluation: Some(_) }`) or that a
+/// `ClassIsFirstEvaluation` names, in a stable order.
+pub(crate) fn shared_first_templates(hir: &perry_hir::Module) -> Vec<String> {
+    let mut out: Vec<String> = collect(hir, &mut |e, out| match e {
+        Expr::ClassExprFresh {
+            template,
+            shared_first_evaluation: Some(_),
+            ..
+        }
+        | Expr::ClassIsFirstEvaluation { template, .. } => {
             out.insert(template.clone());
         }
+        _ => {}
+    })
+    .into_iter()
+    .collect();
+    out.sort();
+    out
+}
+
+fn templates_where(hir: &perry_hir::Module, wanted: fn(&Expr) -> bool) -> HashSet<String> {
+    let visit_expr = &mut |e: &Expr, out: &mut HashSet<String>| {
+        if let Expr::ClassExprFresh { template, .. } = e {
+            if wanted(e) {
+                out.insert(template.clone());
+            }
+        }
+    };
+    collect(hir, visit_expr)
+}
+
+fn collect(
+    hir: &perry_hir::Module,
+    on_expr: &mut dyn FnMut(&Expr, &mut HashSet<String>),
+) -> HashSet<String> {
+    fn visit_expr(
+        e: &Expr,
+        out: &mut HashSet<String>,
+        on_expr: &mut dyn FnMut(&Expr, &mut HashSet<String>),
+    ) {
+        on_expr(e, out);
         if let Expr::Closure { body, .. } = e {
-            visit_body(body, out);
+            visit_body(body, out, on_expr);
         }
-        perry_hir::walker::walk_expr_children(e, &mut |c| visit_expr(c, out));
+        perry_hir::walker::walk_expr_children(e, &mut |c| visit_expr(c, out, on_expr));
     }
-    fn visit_body(body: &[Stmt], out: &mut HashSet<String>) {
+    fn visit_body(
+        body: &[Stmt],
+        out: &mut HashSet<String>,
+        on_expr: &mut dyn FnMut(&Expr, &mut HashSet<String>),
+    ) {
         for s in body {
             perry_hir::walker::stmt_any_expr(s, &mut |e| {
-                visit_expr(e, out);
+                visit_expr(e, out, on_expr);
                 false
             });
         }
     }
     let mut out = HashSet::new();
-    visit_body(&hir.init, &mut out);
+    visit_body(&hir.init, &mut out, on_expr);
     for f in &hir.functions {
-        visit_body(&f.body, &mut out);
+        visit_body(&f.body, &mut out, on_expr);
     }
     for class in &hir.classes {
         if let Some(ctor) = &class.constructor {
-            visit_body(&ctor.body, &mut out);
+            visit_body(&ctor.body, &mut out, on_expr);
         }
         for f in class
             .methods
@@ -62,11 +107,11 @@ pub(crate) fn fresh_class_templates(hir: &perry_hir::Module) -> HashSet<String>
             .chain(class.getters.iter().map(|(_, f)| f))
             .chain(class.setters.iter().map(|(_, f)| f))
         {
-            visit_body(&f.body, &mut out);
+            visit_body(&f.body, &mut out, on_expr);
         }
         for field in class.fields.iter().chain(class.static_fields.iter()) {
             if let Some(init) = &field.init {
-                visit_expr(init, &mut out);
+                visit_expr(init, &mut out, on_expr);
             }
         }
     }
diff --git a/crates/perry-codegen/src/collectors/escape_check.rs b/crates/perry-codegen/src/collectors/escape_check.rs
index 9d96ef1960..ac19afcce5 100644
--- a/crates/perry-codegen/src/collectors/escape_check.rs
+++ b/crates/perry-codegen/src/collectors/escape_check.rs
@@ -27,6 +27,28 @@ pub fn find_new_candidates(
             } if !boxed_vars.contains(id) && !module_globals.contains_key(id) => {
                 candidates.insert(*id, class_name.clone());
             }
+            // #11759 (c′): `new C()` guarded on a class declaration's first
+            // evaluation. Its first-evaluation branch is the static `new`; a
+            // loop versioned on the guard (`stmt/class_first_loop.rs`) lowers
+            // that branch alone, which scalar replacement then sees. Where the
+            // guard stays, the init is not a `New` and is never replaced.
+            Stmt::Let {
+                id,
+                init:
+                    Some(Expr::Conditional {
+                        condition,
+                        then_expr,
+                        ..
+                    }),
+                ..
+            } if matches!(condition.as_ref(), Expr::ClassIsFirstEvaluation { .. })
+                && !boxed_vars.contains(id)
+                && !module_globals.contains_key(id) =>
+            {
+                if let Expr::New { class_name, .. } = then_expr.as_ref() {
+                    candidates.insert(*id, class_name.clone());
+                }
+            }
             Stmt::If {
                 then_branch,
                 else_branch,
@@ -1159,6 +1181,14 @@ pub fn check_escapes_in_expr(
         // arm (around line 4949). The `ErrorNew(None)` here was dead —
         // removed.
         | Expr::BigInt(_) => {}
+        // #11759 (c′): a class declaration's evaluation and its
+        // first-evaluation test hold candidates only in their operand
+        // expressions (captured values, static initializers, the binding).
+        Expr::ClassExprFresh { .. } | Expr::ClassIsFirstEvaluation { .. } => {
+            perry_hir::walker::walk_expr_children(e, &mut |child| {
+                check_escapes_in_expr(child, candidates, classes, escaped)
+            });
+        }
         // Catch-all: conservatively mark any candidate referenced in an
         // unrecognized expression as escaped. This is safe — just misses
         // the optimization for patterns we haven't enumerated.
diff --git a/crates/perry-codegen/src/collectors/hir_facts.rs b/crates/perry-codegen/src/collectors/hir_facts.rs
index b6a498911f..7a569c3ea2 100644
--- a/crates/perry-codegen/src/collectors/hir_facts.rs
+++ b/crates/perry-codegen/src/collectors/hir_facts.rs
@@ -211,6 +211,11 @@ pub(crate) struct ShapeStabilityFacts {
     /// and unguarded direct method dispatch
     /// (`lower_call/property_get/dynamic_dispatch.rs`).
     pub shape_proven_ptr_locals: HashMap<u32, super::PtrShapeLocal>,
+    /// #11759 (c′): locals bound to a repeatable class declaration's guarded
+    /// `new`, proven up to the class TEMPLATE (`ShapeProof::lineage`). Only
+    /// their `numeric_fields` are consumed, as a fact about the VALUES read
+    /// from those fields; never a layout or dispatch license.
+    pub shape_lineage_locals: HashMap<u32, super::PtrShapeLocal>,
     /// Fresh-object containment facts consumed exclusively by guarded
     /// argument-shape clone routes. This map remains available in modules
     /// with shape barriers, so it must never license guard-free field access:
@@ -457,6 +462,12 @@ impl TypeFacts {
         self.shape_stability.shape_proven_ptr_locals.get(&local_id)
     }
 
+    /// #11759 (c′): the template-lineage fact for a local bound to a
+    /// repeatable class declaration's guarded `new` (`ShapeProof::lineage`).
+    pub(crate) fn shape_lineage_local(&self, local_id: u32) -> Option<&super::PtrShapeLocal> {
+        self.shape_stability.shape_lineage_locals.get(&local_id)
+    }
+
     pub(crate) fn guarded_argument_route_local(
         &self,
         local_id: u32,
@@ -717,17 +728,20 @@ pub(crate) fn collect_type_facts(
     // Representation-selection Phase 3b: shape-proven pointer locals. Gated
     // on `PERRY_PTR_SHAPE_LOCALS` and the module-wide §5.2 barrier scan
     // inside the collector.
-    let (shape_proven_ptr_locals, exact_numeric_element_fields) =
-        super::ptr_shape::collect_shape_proven_ptr_locals_and_element_fields(
-            stmts,
-            boxed_vars,
-            module_globals,
-            classes,
-            module_dispatch,
-            &not_bigint_locals,
-            &element_shape_facts,
-            spec_numeric_params,
-        );
+    let super::ptr_shape::ShapeProof {
+        exact: shape_proven_ptr_locals,
+        element_fields: exact_numeric_element_fields,
+        lineage: shape_lineage_locals,
+    } = super::ptr_shape::collect_shape_proven_ptr_locals_and_element_fields(
+        stmts,
+        boxed_vars,
+        module_globals,
+        classes,
+        module_dispatch,
+        &not_bigint_locals,
+        &element_shape_facts,
+        spec_numeric_params,
+    );
     array_facts.exact_numeric_element_fields = exact_numeric_element_fields;
 
     // #8105 / #10777: locals that hold a JS Number by construction.
@@ -746,8 +760,20 @@ pub(crate) fn collect_type_facts(
     // `PERRY_PTR_SHAPE_LOCALS=0`; that still holds, because an empty
     // `shape_proven_ptr_locals` yields empty inputs below and the fixpoint then
     // computes exactly what it computed before.
-    let (nbc_shape_members, nbc_shape_numeric_fields) =
-        super::number_by_construction::shape_numeric_inputs(&shape_proven_ptr_locals);
+    //
+    // #11759 (c′): a repeatable class declaration's guarded `new` is proven
+    // only up to its template (`ShapeProof::lineage`); which of its fields
+    // hold a Number is a template fact, so it feeds this proof and nothing
+    // that relies on one class object's layout.
+    let (nbc_shape_members, nbc_shape_numeric_fields) = {
+        let mut numeric_inputs = shape_proven_ptr_locals.clone();
+        numeric_inputs.extend(
+            shape_lineage_locals
+                .iter()
+                .map(|(id, fact)| (*id, fact.clone())),
+        );
+        super::number_by_construction::shape_numeric_inputs(&numeric_inputs)
+    };
     let number_by_construction_locals = super::collect_number_by_construction_locals(
         stmts,
         params,
@@ -865,6 +891,7 @@ pub(crate) fn collect_type_facts(
         shape_stability: ShapeStabilityFacts {
             scalar_replaceable_object_locals,
             shape_proven_ptr_locals,
+            shape_lineage_locals,
             guarded_argument_route_locals,
             num_array_locals,
         },
diff --git a/crates/perry-codegen/src/collectors/ptr_shape.rs b/crates/perry-codegen/src/collectors/ptr_shape.rs
index be9256f82b..2d0449acbf 100644
--- a/crates/perry-codegen/src/collectors/ptr_shape.rs
+++ b/crates/perry-codegen/src/collectors/ptr_shape.rs
@@ -235,6 +235,30 @@ pub(crate) use entry::{
     collect_shape_proven_ptr_locals_and_element_fields, expr_is_shape_barrier,
 };
 
+/// What one region's `Ptr<Shape>` proof established.
+#[derive(Default)]
+pub(crate) struct ShapeProof {
+    /// Locals holding exactly one object of a known class object, with a
+    /// statically immutable shape: field accesses lower to bare fixed-offset
+    /// loads and method calls to direct calls.
+    pub exact: HashMap<u32, PtrShapeLocal>,
+    /// Group-wide numeric layouts of proven element arrays.
+    pub element_fields: HashMap<u32, HashSet<String>>,
+    /// #11759 (c′): locals bound to the guarded `new` of a repeatable class
+    /// declaration, proven by every rule above except that the class OBJECT
+    /// is not fixed: the instance belongs to whichever evaluation the binding
+    /// holds. Every evaluation of one template runs the same constructor
+    /// chain, field initializers and methods on the same arguments, and a
+    /// later evaluation's captures are values of the same locals the first
+    /// evaluation's are, so which fields hold a Number on every reachable
+    /// store is a fact of the template (`numeric_fields`). The slot layout
+    /// and the method table are not proven for a later evaluation's
+    /// instance, so these locals never take the bare-load or direct-call
+    /// forms: the facts feed only the Number-by-construction proof of values
+    /// read from them.
+    pub lineage: HashMap<u32, PtrShapeLocal>,
+}
+
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum CollectionPurpose {
     UnguardedRepresentation,
@@ -252,7 +276,7 @@ fn collect_shape_proven_ptr_locals_impl(
     element_facts: &ElementShapeFacts,
     numeric_param_seeds: &HashSet<u32>,
     purpose: CollectionPurpose,
-) -> (HashMap<u32, PtrShapeLocal>, HashMap<u32, HashSet<String>>) {
+) -> ShapeProof {
     // #7152: Perry's own `cjs_wrap` preamble, recognised once for this region.
     // One scan of the top-level statement list on anything else, then a
     // `Default` that suppresses nothing. See `cjs_scaffolding.rs`.
@@ -268,7 +292,7 @@ fn collect_shape_proven_ptr_locals_impl(
     };
     if let Some(denial) = bail {
         report::early_bail(stmts, boxed_vars, module_globals, &preamble, denial);
-        return (HashMap::new(), HashMap::new());
+        return ShapeProof::default();
     }
     // `--opt-report` (#6952): binding names and loop depths for the values
     // this pass is about to accept or deny. Both walks are skipped entirely
@@ -322,7 +346,7 @@ fn collect_shape_proven_ptr_locals_impl(
         callback_seeded.insert(id);
     }
     if candidates.is_empty() && element_facts.is_empty() {
-        return (HashMap::new(), HashMap::new());
+        return ShapeProof::default();
     }
     // Class-level admission BEFORE the use walk so the walk's chain-field
     // membership tests are meaningful.
@@ -336,7 +360,7 @@ fn collect_shape_proven_ptr_locals_impl(
         }
     });
     if candidates.is_empty() && element_facts.is_empty() {
-        return (HashMap::new(), HashMap::new());
+        return ShapeProof::default();
     }
 
     // Alias pre-pass: `const alias = candidate` (the exact-receiver inliner
@@ -377,6 +401,7 @@ fn collect_shape_proven_ptr_locals_impl(
         module_dispatch,
         disqualified: HashSet::new(),
         let_counts: HashMap::new(),
+        lineage_seeded: HashSet::new(),
         field_stores: HashMap::new(),
         method_calls: HashMap::new(),
         new_args: HashMap::new(),
@@ -402,6 +427,7 @@ fn collect_shape_proven_ptr_locals_impl(
         const_local_inits,
         disq_reasons,
         field_reads,
+        lineage_seeded,
         ..
     } = walk;
     // #7770: locals whose every write is number-producing by construction —
@@ -450,6 +476,7 @@ fn collect_shape_proven_ptr_locals_impl(
         &numeric_locals,
     );
     let mut out = HashMap::new();
+    let mut lineage = HashMap::new();
     // `--opt-report`: one closure so every `continue` below has a matching
     // one-line recording. Behaviour is unchanged — `deny` is a no-op when
     // the report is off.
@@ -551,6 +578,21 @@ fn collect_shape_proven_ptr_locals_impl(
                 &numeric_locals,
             )
         };
+        if lineage_seeded.contains(id) {
+            // A field-representation fact of the template, never a layout or
+            // dispatch fact of one class object: see [`ShapeProof::lineage`].
+            let fact = PtrShapeLocal {
+                class_name: class_name.clone(),
+                numeric_fields,
+                report_name: None,
+            };
+            for (member, root) in &roots {
+                if root == id {
+                    lineage.insert(*member, fact.clone());
+                }
+            }
+            continue;
+        }
         let fact = PtrShapeLocal {
             class_name: class_name.clone(),
             numeric_fields,
@@ -662,7 +704,11 @@ fn collect_shape_proven_ptr_locals_impl(
             .is_some_and(|members| members.iter().all(|member| out.contains_key(member)))
     });
     let element_fields = element_facts.proven_array_numeric_fields(&group_numeric);
-    (out, element_fields)
+    ShapeProof {
+        exact: out,
+        element_fields,
+        lineage,
+    }
 }
 
 #[path = "ptr_shape_aliases.rs"]
@@ -819,6 +865,11 @@ struct UseWalk<'a> {
     /// read. Their `Let` init is an `Expr::IndexGet`, which rule 1 would
     /// otherwise reject as `LET_INIT_NOT_NEW`.
     element_seeded: &'a HashSet<u32>,
+    /// #11759 (c′): candidates whose provenance is a class declaration's
+    /// guarded `new` (`ClassIsFirstEvaluation ? new C(..) : new <binding>(..)`).
+    /// The object is an instance of SOME evaluation of `C`'s template, not
+    /// necessarily of the shared class: see [`ShapeProof::lineage`].
+    lineage_seeded: HashSet<u32>,
     /// #7034 §3: the element-shape-proven arrays of this region. Consulted to
     /// decide whether a `push` is a contained element position.
     element_facts: &'a ElementShapeFacts,
@@ -903,6 +954,30 @@ impl<'a> UseWalk<'a> {
                         }
                         return;
                     }
+                    // #11759 (c′): `new C(..)` through a repeatable class
+                    // declaration's binding. Both arms construct with the same
+                    // arguments through the same template constructor; the
+                    // later-evaluation arm's arguments are the same
+                    // expressions, so walking that arm alone covers them.
+                    if let Some(Expr::Conditional {
+                        condition,
+                        then_expr,
+                        else_expr,
+                    }) = init.as_ref()
+                    {
+                        if let (
+                            Expr::ClassIsFirstEvaluation { .. },
+                            Expr::New { args, .. },
+                            Expr::NewDynamic { .. },
+                        ) = (condition.as_ref(), then_expr.as_ref(), else_expr.as_ref())
+                        {
+                            self.lineage_seeded.insert(*id);
+                            self.new_args.insert(*id, args.as_slice());
+                            self.walk_expr(condition);
+                            self.walk_expr(else_expr);
+                            return;
+                        }
+                    }
                     // #7034 §4: a return-shape-seeded candidate's provenance
                     // is the CALL. It records no `new_args` — the constructor
                     // ran in the callee, so the numeric-field proof stands
diff --git a/crates/perry-codegen/src/collectors/ptr_shape_entry.rs b/crates/perry-codegen/src/collectors/ptr_shape_entry.rs
index 62aa9af318..31b2d434aa 100644
--- a/crates/perry-codegen/src/collectors/ptr_shape_entry.rs
+++ b/crates/perry-codegen/src/collectors/ptr_shape_entry.rs
@@ -25,7 +25,7 @@ pub(crate) fn collect_shape_proven_ptr_locals(
         element_facts,
         &HashSet::new(),
     )
-    .0
+    .exact
 }
 
 /// Collect pointer-local facts plus group-wide numeric layouts of proven
@@ -40,7 +40,7 @@ pub(crate) fn collect_shape_proven_ptr_locals_and_element_fields(
     not_bigint_locals: &HashSet<u32>,
     element_facts: &ElementShapeFacts,
     numeric_param_seeds: &HashSet<u32>,
-) -> (HashMap<u32, PtrShapeLocal>, HashMap<u32, HashSet<String>>) {
+) -> ShapeProof {
     collect_shape_proven_ptr_locals_impl(
         stmts,
         boxed_vars,
@@ -75,7 +75,7 @@ pub(crate) fn collect_guarded_argument_route_locals(
     // This second pass is a proof query, not a guard-free representation
     // selection. Suppress report rows for the broader optimization.
     let _quiet = report::SuppressScope::new();
-    let (mut facts, _) = collect_shape_proven_ptr_locals_impl(
+    let mut facts = collect_shape_proven_ptr_locals_impl(
         stmts,
         boxed_vars,
         module_globals,
@@ -85,7 +85,8 @@ pub(crate) fn collect_guarded_argument_route_locals(
         element_facts,
         numeric_param_seeds,
         CollectionPurpose::GuardedArgumentRoute,
-    );
+    )
+    .exact;
     // The guarded route consumes class/containment only, never a raw numeric
     // field representation claim.
     for fact in facts.values_mut() {
diff --git a/crates/perry-codegen/src/collectors/ptr_shape_group_numeric_tests.rs b/crates/perry-codegen/src/collectors/ptr_shape_group_numeric_tests.rs
index 31cb262fb3..e494093a3c 100644
--- a/crates/perry-codegen/src/collectors/ptr_shape_group_numeric_tests.rs
+++ b/crates/perry-codegen/src/collectors/ptr_shape_group_numeric_tests.rs
@@ -282,7 +282,7 @@ fn promote_with_element_fields_and_numeric_params(
         classes,
         &facts,
     );
-    collect_shape_proven_ptr_locals_and_element_fields(
+    let proof = collect_shape_proven_ptr_locals_and_element_fields(
         stmts,
         &HashSet::new(),
         &HashMap::new(),
@@ -291,7 +291,8 @@ fn promote_with_element_fields_and_numeric_params(
         &HashSet::new(),
         &els,
         numeric_param_seeds,
-    )
+    );
+    (proof.exact, proof.element_fields)
 }
 
 fn read_direct_field(array_id: u32, index_id: u32, property: &str) -> Stmt {
diff --git a/crates/perry-codegen/src/collectors/refs.rs b/crates/perry-codegen/src/collectors/refs.rs
index 93302bb7da..b874202020 100644
--- a/crates/perry-codegen/src/collectors/refs.rs
+++ b/crates/perry-codegen/src/collectors/refs.rs
@@ -912,8 +912,16 @@ pub fn collect_ref_ids_in_expr(e: &perry_hir::Expr, out: &mut HashSet<u32>) {
             computed_keys,
             computed_statics,
             captured_args,
+            shared_first_evaluation,
+            evaluated_parent,
             ..
         } => {
+            if let Some(init) = shared_first_evaluation {
+                walk(init, out);
+            }
+            if let Some(parent) = evaluated_parent {
+                walk(parent, out);
+            }
             for (_, v) in named_statics {
                 walk(v, out);
             }
diff --git a/crates/perry-codegen/src/expr/class_first_evaluation.rs b/crates/perry-codegen/src/expr/class_first_evaluation.rs
new file mode 100644
index 0000000000..57c88386e3
--- /dev/null
+++ b/crates/perry-codegen/src/expr/class_first_evaluation.rs
@@ -0,0 +1,211 @@
+//! #11759 (c′): a class declaration that may be evaluated more than once
+//! (`Expr::ClassExprFresh { shared_first_evaluation: Some(_) }`).
+//!
+//! Its first evaluation is the shared class, the one a single evaluation gets,
+//! so a definition that runs once (a bundle wrapper, a function called once)
+//! keeps the static class and every fast path keyed on it. The second and
+//! later evaluations each create a fresh class object, as node does.
+//!
+//! The first evaluation is a fact of the template: one module-private word per
+//! template, `@perry_class_first_eval.<template>`, defined once per module
+//! ([`emit_flag_globals`]), holds the NaN-boxed shared class once the first
+//! evaluation handed it out and 0 before. An evaluation loads it, compares it
+//! with 0 and branches; a guarded static form (`ClassIsFirstEvaluation`)
+//! compares it with the binding's value. The class function object is pinned
+//! for the agent's life, so the word needs no root. A declaration
+//! `lower::run_once` proves to run once never reaches here: it is lowered as
+//! the shared class with no word and no check.
+
+use anyhow::Result;
+use perry_hir::Expr;
+
+use crate::rooting::{any_operand_may_collect, with_rooted_accumulator, Arg, Repr};
+use crate::types::{DOUBLE, I32, I64};
+
+use super::{lower_expr, nanbox_pointer_inline, FnCtx};
+
+/// The flag global of `template` (an LLVM global name, with its `@`).
+pub(crate) fn flag_global_name(template: &str) -> String {
+    let mut name = String::from("@perry_class_first_eval.");
+    for c in template.chars() {
+        if c.is_ascii_alphanumeric() || matches!(c, '_' | '$' | '.') {
+            name.push(c);
+        } else {
+            name.push_str(&format!("_{:x}_", c as u32));
+        }
+    }
+    name
+}
+
+/// Define the flag of every template in `templates` (once each). The flag is
+/// per agent when the program starts workers, as a class value is.
+pub(crate) fn emit_flag_globals<'a>(
+    llmod: &mut crate::module::LlModule,
+    templates: impl IntoIterator<Item = &'a String>,
+) {
+    let tls = if crate::codegen::program_has_worker() {
+        "thread_local "
+    } else {
+        ""
+    };
+    for template in templates {
+        llmod.add_raw_global(format!(
+            "{} = private {tls}global i64 0, align 8",
+            flag_global_name(template)
+        ));
+    }
+}
+
+/// Lower one evaluation of `evaluation` (its `ClassExprFresh` node): the
+/// shared class (running `first_init` against it) when the template's flag is
+/// still clear, else a fresh class object.
+pub(crate) fn lower(
+    ctx: &mut FnCtx<'_>,
+    template: &str,
+    evaluation_owner: Option<perry_hir::types::LocalId>,
+    first_init: &Expr,
+    evaluation: &Expr,
+) -> Result<String> {
+    let Some(&cid) = ctx.class_ids.get(template) else {
+        return super::static_field_meta::lower_class_evaluation_object(ctx, evaluation);
+    };
+    let flag = flag_global_name(template);
+    let seen = ctx.block().load(I64, &flag);
+    let mut first = ctx.block().icmp_eq(I64, &seen, "0");
+    // A declaration extending a shared-first declaration of the same body
+    // shares its first evaluation only while that parent's binding holds the
+    // parent's first evaluation (the template's static heritage).
+    if let Expr::ClassExprFresh {
+        evaluated_parent: Some(parent),
+        ..
+    } = evaluation
+    {
+        let parent_template = ctx
+            .classes
+            .get(template)
+            .and_then(|c| c.extends_name.clone());
+        if let Some(parent_template) = parent_template {
+            let parent_value = lower_expr(ctx, parent)?;
+            let parent_first = ctx.block().load(I64, &flag_global_name(&parent_template));
+            let parent_bits = ctx.block().bitcast_double_to_i64(&parent_value);
+            let parent_is_first = ctx.block().icmp_eq(I64, &parent_bits, &parent_first);
+            first = ctx.block().and(crate::types::I1, &first, &parent_is_first);
+        }
+    }
+    let first_idx = ctx.new_block("classeval.first");
+    let later_idx = ctx.new_block("classeval.later");
+    let join_idx = ctx.new_block("classeval.join");
+    let first_l = ctx.block_label(first_idx);
+    let later_l = ctx.block_label(later_idx);
+    let join_l = ctx.block_label(join_idx);
+    ctx.block().cond_br(&first, &first_l, &later_l);
+
+    // First evaluation: hand out the shared class. The flag is set before any
+    // static initializer runs, so an initializer that re-enters the
+    // declaration (or throws after leaking the class) leaves the shared class
+    // with this evaluation, and every other evaluation is fresh.
+    ctx.current_block = first_idx;
+    // The class function object is pinned for the agent's life, so the value
+    // stays valid across every collection the initializers may run.
+    let shared = super::emit_class_value_cached(ctx, cid);
+    let shared_bits = ctx.block().bitcast_double_to_i64(&shared);
+    ctx.block().store(I64, &shared_bits, &flag);
+    // The shared class learns it is this declaration's first evaluation: its
+    // evaluation-state capture slot (an INT32, so no barrier), which the
+    // runtime reads to keep later evaluations from standing in for it.
+    let state_offset = crate::target_layout::closure_header_size_bytes(ctx.target_triple)
+        + 8 * crate::runtime_abi::CLASS_EVALUATION_STATE_CAPTURE as u64;
+    let blk = ctx.block();
+    let class_ptr = blk.and(I64, &shared_bits, crate::nanbox::POINTER_MASK_I64);
+    let state_addr = blk.add(I64, &class_ptr, &state_offset.to_string());
+    let state_ptr = blk.inttoptr(I64, &state_addr);
+    blk.store(
+        I64,
+        &(crate::runtime_abi::CLASS_FIRST_EVALUATION_STATE as i64).to_string(),
+        &state_ptr,
+    );
+    if let Some(owner) = evaluation_owner {
+        super::static_field_meta::store_evaluation_owner(ctx, owner, &shared);
+    }
+    publish_first_evaluation_captures(ctx, template, evaluation, &shared)?;
+    lower_expr(ctx, first_init)?;
+    let first_end = ctx.block_label(ctx.current_block);
+    ctx.block().br(&join_l);
+
+    ctx.current_block = later_idx;
+    let fresh = super::static_field_meta::lower_class_evaluation_object(ctx, evaluation)?;
+    let later_end = ctx.block_label(ctx.current_block);
+    ctx.block().br(&join_l);
+
+    ctx.current_block = join_idx;
+    Ok(ctx
+        .block()
+        .phi(DOUBLE, &[(&shared, &first_end), (&fresh, &later_end)]))
+}
+
+/// A class whose members read a guarded class environment (`ClassEnvGet {
+/// guarded }`): the first evaluation, the shared class, becomes the
+/// environment's owner and publishes its captured values into the slots, as
+/// a fresh evaluation does (`js_class_env_evaluate`).
+fn publish_first_evaluation_captures(
+    ctx: &mut FnCtx<'_>,
+    template: &str,
+    evaluation: &Expr,
+    shared: &str,
+) -> Result<()> {
+    let Expr::ClassExprFresh { captured_args, .. } = evaluation else {
+        return Ok(());
+    };
+    if captured_args.is_empty() || super::class_env::class_env_state_global(ctx, template).is_none()
+    {
+        return Ok(());
+    }
+    let cap_len = captured_args.len().to_string();
+    let caps_arr = ctx.block().call(I64, "js_array_alloc", &[(I32, &cap_len)]);
+    let protect_caps = any_operand_may_collect(ctx, captured_args.iter());
+    let caps_box = with_rooted_accumulator(
+        ctx,
+        Repr::Ptr,
+        &caps_arr,
+        protect_caps,
+        |ctx, acc| {
+            // Captured bindings may still be in their dead zone (a `const`
+            // declared after the class): the snapshot reads `undefined`, and
+            // the refresh after each initializer republishes it.
+            ctx.block().call_void("js_tdz_suppress_begin", &[]);
+            for arg in captured_args {
+                let v = lower_expr(ctx, arg)?;
+                acc.advance(ctx, "js_array_push_f64", &[Arg::Plain(DOUBLE, &v)]);
+            }
+            ctx.block().call_void("js_tdz_suppress_end", &[]);
+            Ok(())
+        },
+        |ctx, arr| Ok(nanbox_pointer_inline(ctx.block(), arr)),
+    )?;
+    super::class_env::publish_guarded(ctx, template, "js_class_env_evaluate", shared, &caps_box);
+    Ok(())
+}
+
+/// Does `value` hold the first evaluation of `template`? One load of the
+/// template's first-evaluation word and one compare; an `i1`.
+pub(crate) fn is_first_i1(ctx: &mut FnCtx<'_>, value: &Expr, template: &str) -> Result<String> {
+    let v = lower_expr(ctx, value)?;
+    let flag = flag_global_name(template);
+    let blk = ctx.block();
+    let first = blk.load(I64, &flag);
+    let bits = blk.bitcast_double_to_i64(&v);
+    Ok(blk.icmp_eq(I64, &bits, &first))
+}
+
+/// `ClassIsFirstEvaluation`: does `value` hold the first evaluation of
+/// `template`? A NaN-boxed boolean ([`is_first_i1`]).
+pub(crate) fn lower_is_first(ctx: &mut FnCtx<'_>, value: &Expr, template: &str) -> Result<String> {
+    let same = is_first_i1(ctx, value, template)?;
+    Ok(ctx.block().select(
+        crate::types::I1,
+        &same,
+        DOUBLE,
+        &crate::nanbox::double_literal(f64::from_bits(crate::nanbox::TAG_TRUE)),
+        &crate::nanbox::double_literal(f64::from_bits(crate::nanbox::TAG_FALSE)),
+    ))
+}
diff --git a/crates/perry-codegen/src/expr/dispatch.rs b/crates/perry-codegen/src/expr/dispatch.rs
index ca80c722de..2f833b6a68 100644
--- a/crates/perry-codegen/src/expr/dispatch.rs
+++ b/crates/perry-codegen/src/expr/dispatch.rs
@@ -556,6 +556,7 @@ pub(crate) fn lower_expr(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
         | Expr::RegisterClassComputedMethod { .. }
         | Expr::RegisterClassComputedAccessor { .. }
         | Expr::ClassExprFresh { .. }
+        | Expr::ClassIsFirstEvaluation { .. }
         | Expr::SetFunctionPrototype { .. }
         | Expr::RegisterPrototypeMethod { .. }
         | Expr::RegisterFunctionPrototypeMethod { .. }
diff --git a/crates/perry-codegen/src/expr/mod.rs b/crates/perry-codegen/src/expr/mod.rs
index 30d3b8c3be..aa7a77561c 100644
--- a/crates/perry-codegen/src/expr/mod.rs
+++ b/crates/perry-codegen/src/expr/mod.rs
@@ -3051,6 +3051,7 @@ pub(crate) mod calls;
 mod child_proc;
 pub(crate) mod class_env;
 pub(crate) mod class_field_push;
+pub(crate) mod class_first_evaluation;
 mod closure;
 mod compare;
 pub(crate) mod region_guard;
diff --git a/crates/perry-codegen/src/expr/static_field_meta.rs b/crates/perry-codegen/src/expr/static_field_meta.rs
index 3ffb918ae6..6ebcf68388 100644
--- a/crates/perry-codegen/src/expr/static_field_meta.rs
+++ b/crates/perry-codegen/src/expr/static_field_meta.rs
@@ -15,6 +15,37 @@ use crate::types::{DOUBLE, I32, I64, PTR};
 
 use super::{emit_root_nanbox_store_for_expr, lower_expr, nanbox_pointer_inline, FnCtx};
 
+/// Initialize a class evaluation's lexical self-binding `owner` with the
+/// evaluated class value `class_box`.
+pub(crate) fn store_evaluation_owner(
+    ctx: &mut FnCtx<'_>,
+    owner: perry_hir::types::LocalId,
+    class_box: &str,
+) {
+    let Some(slot) = ctx.locals.get(&owner).cloned() else {
+        return;
+    };
+    if matches!(
+        ctx.local_type_hint(&owner),
+        Some(perry_hir::types::Type::Array(_))
+    ) {
+        // Shared-mutable capture rewriting turns a self binding captured by
+        // its own methods into a one-element cell. Initialize the cell's
+        // value, preserving the handle stored in the local slot.
+        let cell_box = ctx.block().load(DOUBLE, &slot);
+        let cell_bits = ctx.block().bitcast_double_to_i64(&cell_box);
+        let cell = ctx
+            .block()
+            .and(I64, &cell_bits, crate::nanbox::POINTER_MASK_I64);
+        ctx.block().call_void(
+            "js_array_set_f64",
+            &[(I64, &cell), (I32, "0"), (DOUBLE, class_box)],
+        );
+    } else {
+        ctx.block().store(DOUBLE, class_box, &slot);
+    }
+}
+
 /// The compiled symbols for `template`'s `static { … }` blocks, in declaration
 /// order (#685).
 ///
@@ -605,285 +636,24 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
         Expr::ClassExprFresh {
             template,
             evaluation_owner,
-            named_statics,
-            computed_keys,
-            computed_statics,
-            static_init_order,
-            captured_args,
+            shared_first_evaluation,
+            ..
         } => {
-            let template_cid = ctx.class_ids.get(template).copied().unwrap_or(0);
-            let tcid_str = template_cid.to_string();
-            // The template's own record (its template cell), which the
-            // module's string-pool initializer defines for every template it
-            // evaluates.
-            let cell = if template_cid == 0 {
-                "null".to_string()
-            } else {
-                format!(
-                    "@{}",
-                    crate::codegen::fresh_class_templates::template_cell_global(template_cid)
-                )
-            };
-            // Room for the evaluation's own `length`, `name` and static
-            // methods, its pinned parent, its captured environment and its
-            // prototype object besides its static fields, so the template's
-            // shapes are all inline slots (`class_object_template`).
-            let own_member_slots =
-                3 + ctx.classes.get(template).map_or(0, |c| {
-                    c.static_methods.len() + usize::from(c.extends_expr.is_some())
-                }) + usize::from(!captured_args.is_empty());
-            let nfields = (named_statics.len() + own_member_slots).to_string();
-            // A static FIELD named `length` / `name` takes over the intrinsic
-            // property; it is created as an ordinary one.
-            let field_mask =
-                named_statics
-                    .iter()
-                    .fold(0u32, |mask, (name, _)| match name.as_str() {
-                        "length" => mask | 1,
-                        "name" => mask | 2,
-                        _ => mask,
-                    });
-            // #1789 / #6438: the evaluation's class object, stamped with
-            // class_id = template and marked a class object
-            // (ShapeObjectKind::Class, so `typeof` reports "function" and
-            // `new`/`instanceof` read the class_id from it), owning its
-            // `length`, `name` and static methods and pinned to THIS
-            // evaluation's parent. The lowering sequences
-            // `RegisterClassParentDynamic` immediately ahead of this node, so
-            // `CLASS_DYNAMIC_PARENT_VALUE[template]` still holds that parent;
-            // later evaluations overwrite it, but each object keeps its own
-            // edge. Every evaluation after the template's first is allocated
-            // directly in the template's final shape.
-            let obj = ctx.block().call(
-                I64,
-                "js_class_evaluation_object",
-                &[
-                    (I32, &tcid_str),
-                    (I32, &nfields),
-                    (I32, &field_mask.to_string()),
-                    (PTR, &cell),
-                ],
-            );
-            // #7154: the fresh class object is a raw SSA register while the
-            // evaluation allocates (every static initializer and captured
-            // argument), and an evacuating minor relocates it, after which each
-            // later `js_object_set_field_by_name` would write into from-space —
-            // the statics would land on the abandoned copy. So the object is
-            // always held in a rooted group (`Expr::Object`'s contract since
-            // #6951), re-read before each use. (`CLASS_OBJECT_VALUES` does not
-            // protect the register: it is a forwarded root that keeps the
-            // OBJECT alive but never rewrites `%obj`.)
-            let block_fns = static_block_fns(ctx, template);
-            let protect_handle = true;
-            with_rooted_group(ctx, 1, |ctx, group| {
-                let rooted = group.adopt_emitted(ctx, Repr::Ptr, &obj, protect_handle);
-                // A named class expression's lexical self-binding is
-                // initialized immediately after the class value is created,
-                // before computed names and static initializers run. The
-                // compiler-private owner let was emitted at body entry, so its
-                // slot is already shadow-bound and remains a GC root while the
-                // initializer sequence allocates.
-                if let Some(owner) = evaluation_owner {
-                    if let Some(slot) = ctx.locals.get(owner).cloned() {
-                        let obj = group.reread_emitted(ctx, rooted);
-                        let obj_box = nanbox_pointer_inline(ctx.block(), &obj);
-                        if matches!(
-                            ctx.local_type_hint(owner),
-                            Some(perry_hir::types::Type::Array(_))
-                        ) {
-                            // Shared-mutable capture rewriting turns a self
-                            // binding captured by its own methods into a
-                            // one-element cell. Initialize the cell's value,
-                            // preserving the handle stored in the local slot.
-                            let cell_box = ctx.block().load(DOUBLE, &slot);
-                            let cell_bits = ctx.block().bitcast_double_to_i64(&cell_box);
-                            let cell =
-                                ctx.block()
-                                    .and(I64, &cell_bits, crate::nanbox::POINTER_MASK_I64);
-                            ctx.block().call_void(
-                                "js_array_set_f64",
-                                &[(I64, &cell), (I32, "0"), (DOUBLE, &obj_box)],
-                            );
-                        } else {
-                            ctx.block().store(DOUBLE, &obj_box, &slot);
-                        }
-                    }
-                }
-                // Resolve all ComputedPropertyNames before any static field
-                // initializer, preserving class-body order. Hidden own slots
-                // carry the resulting PropertyKeys for both the static phase
-                // below and later instance construction.
-                for (name, key_expr) in computed_keys {
-                    let key_value = lower_expr(ctx, key_expr)?;
-                    let key_idx = ctx.strings.intern(name);
-                    let key_handle_global =
-                        format!("@{}", ctx.strings.entry(key_idx).handle_global);
-                    let obj = group.reread_emitted(ctx, rooted);
-                    let blk = ctx.block();
-                    let storage_key = blk.load(DOUBLE, &key_handle_global);
-                    let storage_bits = blk.bitcast_double_to_i64(&storage_key);
-                    let storage_raw = blk.and(I64, &storage_bits, crate::nanbox::POINTER_MASK_I64);
-                    blk.call_void(
-                        "js_object_set_field_by_name",
-                        &[(I64, &obj), (I64, &storage_raw), (DOUBLE, &key_value)],
-                    );
-                }
-                // #1787: snapshot the captured outer-scope values onto the class
-                // object as the `__perry_ctor_caps` own array (in the constructor's
-                // capture-param order). `new <thisClassObjectValue>()` reads it back
-                // in `js_new_function_construct` and replays the constructor with the
-                // right captured environment — which the static `new ClassName()`
-                // inlining can't do once the class escapes its defining scope.
-                if !captured_args.is_empty() {
-                    let cap_len = captured_args.len().to_string();
-                    let caps_arr = ctx.block().call(I64, "js_array_alloc", &[(I32, &cap_len)]);
-                    // #7615 slice 8: the capture snapshot is an ACCUMULATOR — the
-                    // array holds the only reference to everything pushed so far
-                    // while the next element is lowered — and it was threaded
-                    // through a bare SSA register, which is #6951's shape exactly.
-                    //
-                    // The window is EMPTY on today's HIR, and the flag says so
-                    // rather than the code assuming it: `captured_args` is built at
-                    // exactly one site (`lower/lower_expr/arm_class.rs`) as
-                    // `ids.iter().map(|id| Expr::LocalGet(*id))`, and
-                    // `expr_may_trigger_gc` answers `false` for every `LocalGet`.
-                    // So `protect_caps` is false today, `advance` threads the same
-                    // register the old code threaded, and the emitted IR is byte
-                    // for byte what it was. What changes is that the day a
-                    // non-inert expression reaches this list it is rooted by
-                    // construction instead of silently entering the window.
-                    let protect_caps = any_operand_may_collect(ctx, captured_args.iter());
-                    // #6523: these capture loads are Perry-internal materialization
-                    // at the class's DEFINITION site, same as the
-                    // `RegisterClassCaptures` snapshot loads above (#6052). A
-                    // captured `const` declared AFTER the class (bundled semver's
-                    // `class Comparator` + trailing debug/require consts) is still
-                    // in its dead zone here — legal JS, since TDZ applies at
-                    // method-call time. Without the suppression window the checked
-                    // box read threw "Cannot access undefined before
-                    // initialization" while merely DEFINING the class. Suppressed
-                    // loads snapshot `undefined`; the #6037 refresh statements
-                    // re-register the live values right after each captured
-                    // refresh the evaluated object's array right after each
-                    // captured binding's initializer runs.
-                    let caps_box = with_rooted_accumulator(
-                        ctx,
-                        Repr::Ptr,
-                        &caps_arr,
-                        protect_caps,
-                        |ctx, acc| {
-                            ctx.block().call_void("js_tdz_suppress_begin", &[]);
-                            for (index, arg) in captured_args.iter().enumerate() {
-                                let v = lower_expr(ctx, arg)?;
-                                // The evaluation publishes a class-environment
-                                // class's slots before any static initializer
-                                // or member can read them.
-                                super::class_env::store_class_env_slot(
-                                    ctx,
-                                    template,
-                                    index as u32,
-                                    &v,
-                                    arg,
-                                );
-                                acc.advance(ctx, "js_array_push_f64", &[Arg::Plain(DOUBLE, &v)]);
-                            }
-                            ctx.block().call_void("js_tdz_suppress_end", &[]);
-                            Ok(())
-                        },
-                        |ctx, arr| Ok(nanbox_pointer_inline(ctx.block(), arr)),
-                    )?;
-                    // #7154: re-read the class object — the capture lowerings above
-                    // are arbitrary expressions and may have moved it.
-                    let obj = group.reread_emitted(ctx, rooted);
-                    // Its own `__perry_ctor_caps`: one recorded transition from
-                    // the template's final shape (`class_object_template`).
-                    ctx.block().call_void(
-                        "js_class_object_set_ctor_caps",
-                        &[(I64, &obj), (DOUBLE, &caps_box), (PTR, &cell)],
-                    );
-                    // A guarded class environment learns this evaluation; the
-                    // first one publishes its captures into the slots.
-                    let obj = group.reread_emitted(ctx, rooted);
-                    let obj_box = nanbox_pointer_inline(ctx.block(), &obj);
-                    super::class_env::publish_guarded(
-                        ctx,
-                        template,
-                        "js_class_env_evaluate",
-                        &obj_box,
-                        &caps_box,
-                    );
-                }
-                // Static fields and blocks execute only after every computed
-                // name has been resolved, then in their original ClassBody
-                // order. Each vector index is recorded by HIR lowering.
-                for step in static_init_order {
-                    match step {
-                        perry_hir::ClassFreshStaticInit::Named(index) => {
-                            let Some((name, init)) = named_statics.get(*index as usize) else {
-                                continue;
-                            };
-                            let storage_name = if name.starts_with('#') {
-                                private_static_storage_name(template_cid, name)
-                            } else {
-                                name.clone()
-                            };
-                            let key_idx = ctx.strings.intern(&storage_name);
-                            let key_handle_global =
-                                format!("@{}", ctx.strings.entry(key_idx).handle_global);
-                            let value = lower_expr(ctx, init)?;
-                            let obj = group.reread_emitted(ctx, rooted);
-                            let blk = ctx.block();
-                            let key_box = blk.load(DOUBLE, &key_handle_global);
-                            let key_bits = blk.bitcast_double_to_i64(&key_box);
-                            let key_raw = blk.and(I64, &key_bits, crate::nanbox::POINTER_MASK_I64);
-                            blk.call_void(
-                                "js_object_set_field_by_name",
-                                &[(I64, &obj), (I64, &key_raw), (DOUBLE, &value)],
-                            );
-                        }
-                        perry_hir::ClassFreshStaticInit::Computed(index) => {
-                            let Some((key_slot, init)) = computed_statics.get(*index as usize)
-                            else {
-                                continue;
-                            };
-                            let value = lower_expr(ctx, init)?;
-                            let key_idx = ctx.strings.intern(key_slot);
-                            let entry = ctx.strings.entry(key_idx);
-                            let key_bytes = format!("@{}", entry.bytes_global);
-                            let key_len = entry.byte_len.to_string();
-                            let obj = group.reread_emitted(ctx, rooted);
-                            let obj_box = nanbox_pointer_inline(ctx.block(), &obj);
-                            let resolved_key = ctx.block().call(
-                                DOUBLE,
-                                "js_object_get_own_field_or_undef",
-                                &[(DOUBLE, &obj_box), (PTR, &key_bytes), (I64, &key_len)],
-                            );
-                            ctx.block().call(
-                                DOUBLE,
-                                "js_object_set_property_key",
-                                &[
-                                    (DOUBLE, &obj_box),
-                                    (DOUBLE, &resolved_key),
-                                    (DOUBLE, &value),
-                                ],
-                            );
-                        }
-                        perry_hir::ClassFreshStaticInit::Block(index) => {
-                            let Some(fn_name) = block_fns.get(*index as usize) else {
-                                continue;
-                            };
-                            let obj = group.reread_emitted(ctx, rooted);
-                            let obj_box = nanbox_pointer_inline(ctx.block(), &obj);
-                            ctx.block()
-                                .call_void("js_static_this_arm_value", &[(DOUBLE, &obj_box)]);
-                            ctx.block().call(DOUBLE, fn_name, &[]);
-                        }
-                    }
-                }
-                let obj = group.reread_emitted(ctx, rooted);
-                let obj_box = nanbox_pointer_inline(ctx.block(), &obj);
-                Ok(obj_box)
-            })
+            // #11759 (c′): the first evaluation is the shared class; the
+            // fresh class object below is every later one.
+            if let Some(first_init) = shared_first_evaluation {
+                return super::class_first_evaluation::lower(
+                    ctx,
+                    template,
+                    *evaluation_owner,
+                    first_init,
+                    expr,
+                );
+            }
+            lower_class_evaluation_object(ctx, expr)
+        }
+        Expr::ClassIsFirstEvaluation { value, template } => {
+            super::class_first_evaluation::lower_is_first(ctx, value, template)
         }
         Expr::SetFunctionPrototype {
             func,
@@ -1129,3 +899,283 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
         _ => unreachable!("expr/mod.rs dispatched a variant not handled by this submodule"),
     }
 }
+
+/// One evaluation's class object (`Expr::ClassExprFresh`): a fresh heap class
+/// object carrying the evaluation's statics, captures and self-binding.
+pub(crate) fn lower_class_evaluation_object(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
+    let Expr::ClassExprFresh {
+        template,
+        evaluation_owner,
+        named_statics,
+        computed_keys,
+        computed_statics,
+        static_init_order,
+        captured_args,
+        evaluated_parent,
+        ..
+    } = expr
+    else {
+        unreachable!("lower_class_evaluation_object takes a ClassExprFresh");
+    };
+    // #11759 (c′): this evaluation's parent is the evaluated class its
+    // binding holds; register it for `js_class_evaluation_object` to pin, as
+    // a runtime heritage value does.
+    if let Some(parent) = evaluated_parent {
+        lower_expr(
+            ctx,
+            &Expr::RegisterClassParentDynamic {
+                class_name: template.clone(),
+                parent_expr: parent.clone(),
+            },
+        )?;
+    }
+    let template_cid = ctx.class_ids.get(template).copied().unwrap_or(0);
+    let tcid_str = template_cid.to_string();
+    // The template's own record (its template cell), which the module's
+    // string-pool initializer defines for every template it evaluates.
+    let cell = if template_cid == 0 {
+        "null".to_string()
+    } else {
+        format!(
+            "@{}",
+            crate::codegen::fresh_class_templates::template_cell_global(template_cid)
+        )
+    };
+    // Room for the evaluation's own `length`, `name` and static
+    // methods, its pinned parent, its captured environment and its
+    // prototype object besides its static fields, so the template's
+    // shapes are all inline slots (`class_object_template`).
+    let own_member_slots =
+        3 + ctx.classes.get(template).map_or(0, |c| {
+            c.static_methods.len()
+                + usize::from(c.extends_expr.is_some() || evaluated_parent.is_some())
+        }) + usize::from(!captured_args.is_empty());
+    let nfields = (named_statics.len() + own_member_slots).to_string();
+    // A static FIELD named `length` / `name` takes over the intrinsic
+    // property; it is created as an ordinary one.
+    let field_mask = named_statics
+        .iter()
+        .fold(0u32, |mask, (name, _)| match name.as_str() {
+            "length" => mask | 1,
+            "name" => mask | 2,
+            _ => mask,
+        });
+    // #1789 / #6438: the evaluation's class object, stamped with
+    // class_id = template and marked a class object
+    // (ShapeObjectKind::Class, so `typeof` reports "function" and
+    // `new`/`instanceof` read the class_id from it), owning its
+    // `length`, `name` and static methods and pinned to THIS
+    // evaluation's parent. The lowering sequences
+    // `RegisterClassParentDynamic` immediately ahead of this node, so
+    // `CLASS_DYNAMIC_PARENT_VALUE[template]` still holds that parent;
+    // later evaluations overwrite it, but each object keeps its own
+    // edge. Every evaluation after the template's first is allocated
+    // directly in the template's final shape.
+    let obj = ctx.block().call(
+        I64,
+        "js_class_evaluation_object",
+        &[
+            (I32, &tcid_str),
+            (I32, &nfields),
+            (I32, &field_mask.to_string()),
+            (PTR, &cell),
+        ],
+    );
+    // #7154: the fresh class object is a raw SSA register while the
+    // evaluation allocates (every static initializer and captured
+    // argument), and an evacuating minor relocates it, after which each
+    // later `js_object_set_field_by_name` would write into from-space —
+    // the statics would land on the abandoned copy. So the object is
+    // always held in a rooted group (`Expr::Object`'s contract since
+    // #6951), re-read before each use. (`CLASS_OBJECT_VALUES` does not
+    // protect the register: it is a forwarded root that keeps the
+    // OBJECT alive but never rewrites `%obj`.)
+    let block_fns = static_block_fns(ctx, template);
+    let protect_handle = true;
+    with_rooted_group(ctx, 1, |ctx, group| {
+        let rooted = group.adopt_emitted(ctx, Repr::Ptr, &obj, protect_handle);
+        // A named class expression's lexical self-binding is
+        // initialized immediately after the class value is created,
+        // before computed names and static initializers run. The
+        // compiler-private owner let was emitted at body entry, so its
+        // slot is already shadow-bound and remains a GC root while the
+        // initializer sequence allocates.
+        if let Some(owner) = evaluation_owner {
+            let obj = group.reread_emitted(ctx, rooted);
+            let obj_box = nanbox_pointer_inline(ctx.block(), &obj);
+            store_evaluation_owner(ctx, *owner, &obj_box);
+        }
+        // Resolve all ComputedPropertyNames before any static field
+        // initializer, preserving class-body order. Hidden own slots
+        // carry the resulting PropertyKeys for both the static phase
+        // below and later instance construction.
+        for (name, key_expr) in computed_keys {
+            let key_value = lower_expr(ctx, key_expr)?;
+            let key_idx = ctx.strings.intern(name);
+            let key_handle_global = format!("@{}", ctx.strings.entry(key_idx).handle_global);
+            let obj = group.reread_emitted(ctx, rooted);
+            let blk = ctx.block();
+            let storage_key = blk.load(DOUBLE, &key_handle_global);
+            let storage_bits = blk.bitcast_double_to_i64(&storage_key);
+            let storage_raw = blk.and(I64, &storage_bits, crate::nanbox::POINTER_MASK_I64);
+            blk.call_void(
+                "js_object_set_field_by_name",
+                &[(I64, &obj), (I64, &storage_raw), (DOUBLE, &key_value)],
+            );
+        }
+        // #1787: snapshot the captured outer-scope values onto the class
+        // object as the `__perry_ctor_caps` own array (in the constructor's
+        // capture-param order). `new <thisClassObjectValue>()` reads it back
+        // in `js_new_function_construct` and replays the constructor with the
+        // right captured environment — which the static `new ClassName()`
+        // inlining can't do once the class escapes its defining scope.
+        if !captured_args.is_empty() {
+            let cap_len = captured_args.len().to_string();
+            let caps_arr = ctx.block().call(I64, "js_array_alloc", &[(I32, &cap_len)]);
+            // #7615 slice 8: the capture snapshot is an ACCUMULATOR — the
+            // array holds the only reference to everything pushed so far
+            // while the next element is lowered — and it was threaded
+            // through a bare SSA register, which is #6951's shape exactly.
+            //
+            // The window is EMPTY on today's HIR, and the flag says so
+            // rather than the code assuming it: `captured_args` is built at
+            // exactly one site (`lower/lower_expr/arm_class.rs`) as
+            // `ids.iter().map(|id| Expr::LocalGet(*id))`, and
+            // `expr_may_trigger_gc` answers `false` for every `LocalGet`.
+            // So `protect_caps` is false today, `advance` threads the same
+            // register the old code threaded, and the emitted IR is byte
+            // for byte what it was. What changes is that the day a
+            // non-inert expression reaches this list it is rooted by
+            // construction instead of silently entering the window.
+            let protect_caps = any_operand_may_collect(ctx, captured_args.iter());
+            // #6523: these capture loads are Perry-internal materialization
+            // at the class's DEFINITION site, same as the
+            // `RegisterClassCaptures` snapshot loads above (#6052). A
+            // captured `const` declared AFTER the class (bundled semver's
+            // `class Comparator` + trailing debug/require consts) is still
+            // in its dead zone here — legal JS, since TDZ applies at
+            // method-call time. Without the suppression window the checked
+            // box read threw "Cannot access undefined before
+            // initialization" while merely DEFINING the class. Suppressed
+            // loads snapshot `undefined`; the #6037 refresh statements
+            // re-register the live values right after each captured
+            // refresh the evaluated object's array right after each
+            // captured binding's initializer runs.
+            let caps_box = with_rooted_accumulator(
+                ctx,
+                Repr::Ptr,
+                &caps_arr,
+                protect_caps,
+                |ctx, acc| {
+                    ctx.block().call_void("js_tdz_suppress_begin", &[]);
+                    for (index, arg) in captured_args.iter().enumerate() {
+                        let v = lower_expr(ctx, arg)?;
+                        // The evaluation publishes a class-environment
+                        // class's slots before any static initializer
+                        // or member can read them.
+                        super::class_env::store_class_env_slot(
+                            ctx,
+                            template,
+                            index as u32,
+                            &v,
+                            arg,
+                        );
+                        acc.advance(ctx, "js_array_push_f64", &[Arg::Plain(DOUBLE, &v)]);
+                    }
+                    ctx.block().call_void("js_tdz_suppress_end", &[]);
+                    Ok(())
+                },
+                |ctx, arr| Ok(nanbox_pointer_inline(ctx.block(), arr)),
+            )?;
+            // #7154: re-read the class object — the capture lowerings above
+            // are arbitrary expressions and may have moved it.
+            let obj = group.reread_emitted(ctx, rooted);
+            // Its own `__perry_ctor_caps`: one recorded transition from
+            // the template's final shape (`class_object_template`).
+            ctx.block().call_void(
+                "js_class_object_set_ctor_caps",
+                &[(I64, &obj), (DOUBLE, &caps_box), (PTR, &cell)],
+            );
+            // A guarded class environment learns this evaluation; the
+            // first one publishes its captures into the slots.
+            let obj = group.reread_emitted(ctx, rooted);
+            let obj_box = nanbox_pointer_inline(ctx.block(), &obj);
+            super::class_env::publish_guarded(
+                ctx,
+                template,
+                "js_class_env_evaluate",
+                &obj_box,
+                &caps_box,
+            );
+        }
+        // Static fields and blocks execute only after every computed
+        // name has been resolved, then in their original ClassBody
+        // order. Each vector index is recorded by HIR lowering.
+        for step in static_init_order {
+            match step {
+                perry_hir::ClassFreshStaticInit::Named(index) => {
+                    let Some((name, init)) = named_statics.get(*index as usize) else {
+                        continue;
+                    };
+                    let storage_name = if name.starts_with('#') {
+                        private_static_storage_name(template_cid, name)
+                    } else {
+                        name.clone()
+                    };
+                    let key_idx = ctx.strings.intern(&storage_name);
+                    let key_handle_global =
+                        format!("@{}", ctx.strings.entry(key_idx).handle_global);
+                    let value = lower_expr(ctx, init)?;
+                    let obj = group.reread_emitted(ctx, rooted);
+                    let blk = ctx.block();
+                    let key_box = blk.load(DOUBLE, &key_handle_global);
+                    let key_bits = blk.bitcast_double_to_i64(&key_box);
+                    let key_raw = blk.and(I64, &key_bits, crate::nanbox::POINTER_MASK_I64);
+                    blk.call_void(
+                        "js_object_set_field_by_name",
+                        &[(I64, &obj), (I64, &key_raw), (DOUBLE, &value)],
+                    );
+                }
+                perry_hir::ClassFreshStaticInit::Computed(index) => {
+                    let Some((key_slot, init)) = computed_statics.get(*index as usize) else {
+                        continue;
+                    };
+                    let value = lower_expr(ctx, init)?;
+                    let key_idx = ctx.strings.intern(key_slot);
+                    let entry = ctx.strings.entry(key_idx);
+                    let key_bytes = format!("@{}", entry.bytes_global);
+                    let key_len = entry.byte_len.to_string();
+                    let obj = group.reread_emitted(ctx, rooted);
+                    let obj_box = nanbox_pointer_inline(ctx.block(), &obj);
+                    let resolved_key = ctx.block().call(
+                        DOUBLE,
+                        "js_object_get_own_field_or_undef",
+                        &[(DOUBLE, &obj_box), (PTR, &key_bytes), (I64, &key_len)],
+                    );
+                    ctx.block().call(
+                        DOUBLE,
+                        "js_object_set_property_key",
+                        &[
+                            (DOUBLE, &obj_box),
+                            (DOUBLE, &resolved_key),
+                            (DOUBLE, &value),
+                        ],
+                    );
+                }
+                perry_hir::ClassFreshStaticInit::Block(index) => {
+                    let Some(fn_name) = block_fns.get(*index as usize) else {
+                        continue;
+                    };
+                    let obj = group.reread_emitted(ctx, rooted);
+                    let obj_box = nanbox_pointer_inline(ctx.block(), &obj);
+                    ctx.block()
+                        .call_void("js_static_this_arm_value", &[(DOUBLE, &obj_box)]);
+                    ctx.block().call(DOUBLE, fn_name, &[]);
+                }
+            }
+        }
+        let obj = group.reread_emitted(ctx, rooted);
+        let obj_box = nanbox_pointer_inline(ctx.block(), &obj);
+        Ok(obj_box)
+    })
+}
diff --git a/crates/perry-codegen/src/stmt/class_first_loop.rs b/crates/perry-codegen/src/stmt/class_first_loop.rs
new file mode 100644
index 0000000000..8ae5dbff80
--- /dev/null
+++ b/crates/perry-codegen/src/stmt/class_first_loop.rs
@@ -0,0 +1,528 @@
+//! #11759 (c′): a loop versioned on a class declaration's first evaluation.
+//!
+//! `new C()` and `C.<static field>` through the binding of a declaration that
+//! may be evaluated more than once are guarded per use
+//! (`Conditional { ClassIsFirstEvaluation { LocalGet(C) }, static, by value }`).
+//! The guard's answer is a fact of the binding's value: the first evaluation
+//! is the shared class, and the template's first-evaluation word, once set,
+//! never changes. So while a loop cannot rebind `C`, every guard on `C` in it
+//! gives the same answer as one test before the loop. The loop is lowered
+//! twice under that one test: the first-evaluation copy holds only the static
+//! forms (so `let c = new C()` is scalar-replaced exactly as a single
+//! evaluation's would be), the later-evaluation copy only the by-value forms.
+//!
+//! The same holds for the rest of a function body after `const c = new C()`
+//! ([`try_lower_versioned_tail`]): one test at the declaration, then the
+//! remaining statements lowered twice. In the first-evaluation copy `c` is an
+//! instance of the shared class, exactly what a single evaluation's
+//! `new C()` gives, so the `Ptr<Shape>` facts its template lineage proved
+//! (`collectors::ptr_shape::ShapeProof::lineage`) apply to it unchanged:
+//! bare field loads and direct method calls.
+//!
+//! A guard left in either copy (one this rewrite does not reach) still tests
+//! at run time, so the rewrite only removes tests; it never decides one.
+
+use anyhow::Result;
+use perry_hir::{Expr, Stmt};
+
+use super::lower_stmt;
+use crate::expr::FnCtx;
+
+/// Lower `stmt` (a `For`/`While`/`DoWhile`) versioned on a first-evaluation
+/// guard it holds. `Ok(false)`: the loop holds no guard it can hoist, and the
+/// caller lowers it as usual.
+pub(super) fn try_lower_versioned_loop(ctx: &mut FnCtx<'_>, stmt: &Stmt) -> Result<bool> {
+    let Some((binding, template)) = hoistable_guard(ctx, stmt) else {
+        return Ok(false);
+    };
+    let value = Expr::LocalGet(binding);
+    let first = crate::expr::class_first_evaluation::is_first_i1(ctx, &value, &template)?;
+    let first_idx = ctx.new_block("classloop.first");
+    let later_idx = ctx.new_block("classloop.later");
+    let join_idx = ctx.new_block("classloop.join");
+    let first_l = ctx.block_label(first_idx);
+    let later_l = ctx.block_label(later_idx);
+    let join_l = ctx.block_label(join_idx);
+    ctx.block().cond_br(&first, &first_l, &later_l);
+
+    let exact = first_evaluation_instances(ctx, std::slice::from_ref(stmt), binding);
+    for (idx, is_first) in [(first_idx, true), (later_idx, false)] {
+        ctx.current_block = idx;
+        let mut copy = stmt.clone();
+        resolve_guards_in_stmt(&mut copy, binding, is_first);
+        // Scalar replacement registers a binding's field slots by id; the
+        // other copy binds the same ids and must not find this copy's.
+        let scalar_replaced = ctx.scalar_replaced.clone();
+        let overlays = is_first.then(|| install_exact(ctx, &exact));
+        lower_stmt(ctx, &copy)?;
+        if let Some(saved) = overlays {
+            restore_exact(ctx, saved);
+        }
+        ctx.scalar_replaced = scalar_replaced;
+        if !ctx.block().is_terminated() {
+            ctx.block().br(&join_l);
+        }
+    }
+    ctx.current_block = join_idx;
+    Ok(true)
+}
+
+/// The most HIR nodes a versioned function-body tail may hold: it is lowered
+/// twice, so this bounds the code it adds.
+const TAIL_NODE_LIMIT: usize = 400;
+
+/// Lower `stmts[i..]`, the rest of a function body, versioned on the
+/// first-evaluation guard of `stmts[i]` when that is `let c = new C()`
+/// through a repeatable class declaration's binding. `index_base` is
+/// `stmts[i]`'s index in the body (the shadow-slot clear plan is keyed by
+/// it). `Ok(false)`: not applicable, and the caller lowers the statement as
+/// usual.
+pub(super) fn try_lower_versioned_tail(
+    ctx: &mut FnCtx<'_>,
+    tail: &[Stmt],
+    index_base: usize,
+    emit_shadow_clears: bool,
+) -> Result<bool> {
+    let Some((binding, template)) = tail_guard(ctx, tail) else {
+        return Ok(false);
+    };
+    let value = Expr::LocalGet(binding);
+    let first = crate::expr::class_first_evaluation::is_first_i1(ctx, &value, &template)?;
+    let first_idx = ctx.new_block("classtail.first");
+    let later_idx = ctx.new_block("classtail.later");
+    let join_idx = ctx.new_block("classtail.join");
+    let first_l = ctx.block_label(first_idx);
+    let later_l = ctx.block_label(later_idx);
+    let join_l = ctx.block_label(join_idx);
+    ctx.block().cond_br(&first, &first_l, &later_l);
+
+    // The body's shadow-slot clear plan, keyed from the tail's first
+    // statement for the duration of the two copies.
+    let clears = if emit_shadow_clears {
+        let shifted = ctx
+            .shadow_slot_clears_after_stmt
+            .iter()
+            .filter(|(k, _)| **k >= index_base)
+            .map(|(k, v)| (*k - index_base, v.clone()))
+            .collect();
+        Some(std::mem::replace(
+            &mut ctx.shadow_slot_clears_after_stmt,
+            shifted,
+        ))
+    } else {
+        None
+    };
+    let exact = first_evaluation_instances(ctx, tail, binding);
+    let mut result = Ok(());
+    for (idx, is_first) in [(first_idx, true), (later_idx, false)] {
+        ctx.current_block = idx;
+        let mut copy = tail.to_vec();
+        for s in copy.iter_mut() {
+            resolve_guards_in_stmt(s, binding, is_first);
+        }
+        let scalar_replaced = ctx.scalar_replaced.clone();
+        let overlays = is_first.then(|| install_exact(ctx, &exact));
+        result = super::lower_stmts_versioned_tail(ctx, &copy, emit_shadow_clears);
+        if let Some(saved) = overlays {
+            restore_exact(ctx, saved);
+        }
+        ctx.scalar_replaced = scalar_replaced;
+        if result.is_err() {
+            break;
+        }
+        if !ctx.block().is_terminated() {
+            ctx.block().br(&join_l);
+        }
+    }
+    if let Some(clears) = clears {
+        ctx.shadow_slot_clears_after_stmt = clears;
+    }
+    result?;
+    ctx.current_block = join_idx;
+    Ok(true)
+}
+
+/// The guard `tail[0]` binds through: `let c = <first evaluation of C> ?
+/// new C(..) : new C(..)` on a binding the tail cannot rebind, in a tail
+/// small enough to lower twice that defines no code, and that gains from the
+/// split: it uses `c`, or tests the binding outside a loop (a loop versions
+/// itself).
+fn tail_guard(ctx: &FnCtx<'_>, tail: &[Stmt]) -> Option<(u32, String)> {
+    let Some(Stmt::Let {
+        id: instance,
+        init:
+            Some(Expr::Conditional {
+                condition,
+                then_expr,
+                else_expr,
+            }),
+        ..
+    }) = tail.first()
+    else {
+        return None;
+    };
+    // A class with captures stamps its first evaluation's instance with that
+    // evaluation (`ClassEnvStamp`).
+    let then_new = match then_expr.as_ref() {
+        Expr::ClassEnvStamp { instance, .. } => instance.as_ref(),
+        e => e,
+    };
+    if !matches!(then_new, Expr::New { .. })
+        || !matches!(else_expr.as_ref(), Expr::NewDynamic { .. })
+    {
+        return None;
+    }
+    let Expr::ClassIsFirstEvaluation { value, template } = condition.as_ref() else {
+        return None;
+    };
+    let Expr::LocalGet(id) = value.as_ref() else {
+        return None;
+    };
+    if ctx.boxed_vars.contains(id)
+        || ctx.module_globals.contains_key(id)
+        || ctx.reassigned_locals.contains(id)
+        || crate::collectors::rebound_locals(tail).contains(id)
+    {
+        return None;
+    }
+    let mut nodes = 0usize;
+    let mut defines_code = false;
+    for s in tail {
+        perry_hir::walker::stmt_any_expr(s, &mut |e| {
+            visit_expr(e, &mut |e| {
+                nodes += 1;
+                if matches!(e, Expr::Closure { .. } | Expr::ClassExprFresh { .. }) {
+                    defines_code = true;
+                }
+            });
+            false
+        });
+        nodes += 1;
+    }
+    if defines_code || nodes > TAIL_NODE_LIMIT {
+        return None;
+    }
+    let rest = &tail[1..];
+    if !mentions_local(rest, *instance) && !guards_outside_loops(rest, *id) {
+        return None;
+    }
+    Some((*id, template.clone()))
+}
+
+fn mentions_local(stmts: &[Stmt], id: u32) -> bool {
+    stmts.iter().any(|s| {
+        perry_hir::walker::stmt_any_expr(s, &mut |e| {
+            let mut found = false;
+            visit_expr(e, &mut |e| {
+                found |= matches!(e, Expr::LocalGet(l) if *l == id)
+            });
+            found
+        })
+    })
+}
+
+/// Does `stmts` test `binding`'s first evaluation outside a loop?
+fn guards_outside_loops(stmts: &[Stmt], binding: u32) -> bool {
+    let guards = |e: &Expr| {
+        let mut found = false;
+        visit_expr(e, &mut |e| {
+            found |= matches!(e, Expr::ClassIsFirstEvaluation { value, .. }
+                if matches!(value.as_ref(), Expr::LocalGet(l) if *l == binding));
+        });
+        found
+    };
+    stmts.iter().any(|s| match s {
+        Stmt::For { .. } | Stmt::While { .. } | Stmt::DoWhile { .. } => false,
+        Stmt::Let { init: Some(e), .. }
+        | Stmt::Return(Some(e))
+        | Stmt::Expr(e)
+        | Stmt::Throw(e) => guards(e),
+        Stmt::If {
+            condition,
+            then_branch,
+            else_branch,
+        } => {
+            guards(condition)
+                || guards_outside_loops(then_branch, binding)
+                || else_branch
+                    .as_ref()
+                    .is_some_and(|b| guards_outside_loops(b, binding))
+        }
+        Stmt::Labeled { body, .. } => guards_outside_loops(std::slice::from_ref(body), binding),
+        Stmt::Try {
+            body,
+            catch,
+            finally,
+        } => {
+            guards_outside_loops(body, binding)
+                || catch
+                    .as_ref()
+                    .is_some_and(|c| guards_outside_loops(&c.body, binding))
+                || finally
+                    .as_ref()
+                    .is_some_and(|f| guards_outside_loops(f, binding))
+        }
+        Stmt::Switch {
+            discriminant,
+            cases,
+        } => {
+            guards(discriminant)
+                || cases.iter().any(|c| {
+                    c.test.as_ref().is_some_and(guards) || guards_outside_loops(&c.body, binding)
+                })
+        }
+        // Any other statement: a guard it holds still tests at run time.
+        _ => false,
+    })
+}
+
+/// The locals `stmts` binds to a guarded `new` through `binding` that the
+/// template-lineage proof covers: in the first-evaluation copy each holds an
+/// instance of the shared class, which is the proof's missing exactness.
+fn first_evaluation_instances(
+    ctx: &FnCtx<'_>,
+    stmts: &[Stmt],
+    binding: u32,
+) -> Vec<(u32, crate::collectors::PtrShapeLocal)> {
+    let mut out = Vec::new();
+    for s in stmts {
+        collect_guarded_lets(s, binding, &mut out);
+    }
+    out.into_iter()
+        .filter_map(|id| {
+            ctx.native_facts
+                .shape_lineage_local(id)
+                .map(|fact| (id, fact.clone()))
+        })
+        .collect()
+}
+
+fn collect_guarded_lets(stmt: &Stmt, binding: u32, out: &mut Vec<u32>) {
+    let guarded = |e: &Expr| {
+        matches!(e, Expr::Conditional { condition, then_expr, .. }
+            if matches!(then_expr.as_ref(), Expr::New { .. })
+                && matches!(condition.as_ref(), Expr::ClassIsFirstEvaluation { value, .. }
+                    if matches!(value.as_ref(), Expr::LocalGet(id) if *id == binding)))
+    };
+    let nested = |body: &[Stmt], out: &mut Vec<u32>| {
+        for s in body {
+            collect_guarded_lets(s, binding, out);
+        }
+    };
+    match stmt {
+        Stmt::Let {
+            id, init: Some(e), ..
+        } if guarded(e) => out.push(*id),
+        Stmt::If {
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            nested(then_branch, out);
+            if let Some(b) = else_branch {
+                nested(b, out);
+            }
+        }
+        Stmt::While { body, .. } | Stmt::DoWhile { body, .. } => nested(body, out),
+        Stmt::For { init, body, .. } => {
+            if let Some(s) = init {
+                collect_guarded_lets(s, binding, out);
+            }
+            nested(body, out);
+        }
+        Stmt::Labeled { body, .. } => collect_guarded_lets(body, binding, out),
+        Stmt::Try {
+            body,
+            catch,
+            finally,
+        } => {
+            nested(body, out);
+            if let Some(c) = catch {
+                nested(&c.body, out);
+            }
+            if let Some(f) = finally {
+                nested(f, out);
+            }
+        }
+        Stmt::Switch { cases, .. } => {
+            for case in cases {
+                nested(&case.body, out);
+            }
+        }
+        _ => {}
+    }
+}
+
+/// Make each first-evaluation instance's lineage fact an exact `Ptr<Shape>`
+/// fact for the first-evaluation copy; returns what it displaced.
+fn install_exact(
+    ctx: &mut FnCtx<'_>,
+    exact: &[(u32, crate::collectors::PtrShapeLocal)],
+) -> Vec<(u32, Option<crate::collectors::PtrShapeLocal>)> {
+    exact
+        .iter()
+        .map(|(id, fact)| (*id, ctx.proven_shape_params.insert(*id, fact.clone())))
+        .collect()
+}
+
+fn restore_exact(ctx: &mut FnCtx<'_>, saved: Vec<(u32, Option<crate::collectors::PtrShapeLocal>)>) {
+    for (id, previous) in saved {
+        match previous {
+            Some(fact) => {
+                ctx.proven_shape_params.insert(id, fact);
+            }
+            None => {
+                ctx.proven_shape_params.remove(&id);
+            }
+        }
+    }
+}
+
+/// The first `ClassIsFirstEvaluation` guard on a local in `stmt` whose answer
+/// cannot change while `stmt` runs: the local is never rebound in this body
+/// (nor in `stmt`), is not boxed (a callee could rebind a box) and is not a
+/// module global (another body could). A loop that defines code (a closure
+/// or class) is left alone: its copies would define it twice.
+fn hoistable_guard(ctx: &FnCtx<'_>, stmt: &Stmt) -> Option<(u32, String)> {
+    let mut defines_code = false;
+    let mut guard: Option<(u32, String)> = None;
+    perry_hir::walker::stmt_any_expr(stmt, &mut |e| {
+        visit_expr(e, &mut |e| match e {
+            Expr::Closure { .. } | Expr::ClassExprFresh { .. } => defines_code = true,
+            Expr::Conditional { condition, .. } if guard.is_none() => {
+                if let Expr::ClassIsFirstEvaluation { value, template } = condition.as_ref() {
+                    if let Expr::LocalGet(id) = value.as_ref() {
+                        guard = Some((*id, template.clone()));
+                    }
+                }
+            }
+            _ => {}
+        });
+        false
+    });
+    if defines_code {
+        return None;
+    }
+    let (id, template) = guard?;
+    if ctx.boxed_vars.contains(&id)
+        || ctx.module_globals.contains_key(&id)
+        || ctx.reassigned_locals.contains(&id)
+        || crate::collectors::rebound_locals(std::slice::from_ref(stmt)).contains(&id)
+    {
+        return None;
+    }
+    Some((id, template))
+}
+
+/// Visit `expr` and every sub-expression (not into nested statement bodies).
+fn visit_expr(expr: &Expr, f: &mut impl FnMut(&Expr)) {
+    f(expr);
+    perry_hir::walker::walk_expr_children(expr, &mut |child| visit_expr(child, f));
+}
+
+/// Replace every guard on `binding` in `stmt` with the branch `is_first`
+/// selects.
+fn resolve_guards_in_stmt(stmt: &mut Stmt, binding: u32, is_first: bool) {
+    let exprs = |e: &mut Expr| resolve_guards_in_expr(e, binding, is_first);
+    let stmts = |body: &mut Vec<Stmt>| {
+        for s in body.iter_mut() {
+            resolve_guards_in_stmt(s, binding, is_first);
+        }
+    };
+    match stmt {
+        Stmt::Let { init, .. } | Stmt::Return(init) => {
+            if let Some(e) = init {
+                exprs(e);
+            }
+        }
+        Stmt::Expr(e) | Stmt::Throw(e) => exprs(e),
+        Stmt::If {
+            condition,
+            then_branch,
+            else_branch,
+        } => {
+            exprs(condition);
+            stmts(then_branch);
+            if let Some(b) = else_branch {
+                stmts(b);
+            }
+        }
+        Stmt::While { condition, body } | Stmt::DoWhile { body, condition } => {
+            exprs(condition);
+            stmts(body);
+        }
+        Stmt::For {
+            init,
+            condition,
+            update,
+            body,
+        } => {
+            if let Some(s) = init {
+                resolve_guards_in_stmt(s, binding, is_first);
+            }
+            if let Some(e) = condition {
+                exprs(e);
+            }
+            if let Some(e) = update {
+                exprs(e);
+            }
+            stmts(body);
+        }
+        Stmt::Labeled { body, .. } => resolve_guards_in_stmt(body, binding, is_first),
+        Stmt::Try {
+            body,
+            catch,
+            finally,
+        } => {
+            stmts(body);
+            if let Some(c) = catch {
+                stmts(&mut c.body);
+            }
+            if let Some(f) = finally {
+                stmts(f);
+            }
+        }
+        Stmt::Switch {
+            discriminant,
+            cases,
+        } => {
+            exprs(discriminant);
+            for case in cases {
+                if let Some(t) = &mut case.test {
+                    exprs(t);
+                }
+                stmts(&mut case.body);
+            }
+        }
+        // Any other statement holds no expression this rewrite needs; a guard
+        // it misses still tests at run time.
+        _ => {}
+    }
+}
+
+fn resolve_guards_in_expr(expr: &mut Expr, binding: u32, is_first: bool) {
+    let resolved = match expr {
+        Expr::Conditional {
+            condition,
+            then_expr,
+            else_expr,
+        } if matches!(
+            condition.as_ref(),
+            Expr::ClassIsFirstEvaluation { value, .. }
+                if matches!(value.as_ref(), Expr::LocalGet(id) if *id == binding)
+        ) =>
+        {
+            let branch = if is_first { then_expr } else { else_expr };
+            Some(std::mem::replace(branch.as_mut(), Expr::Undefined))
+        }
+        _ => None,
+    };
+    if let Some(branch) = resolved {
+        *expr = branch;
+        resolve_guards_in_expr(expr, binding, is_first);
+        return;
+    }
+    perry_hir::walker::walk_expr_children_mut(expr, &mut |child| {
+        resolve_guards_in_expr(child, binding, is_first)
+    });
+}
diff --git a/crates/perry-codegen/src/stmt/mod.rs b/crates/perry-codegen/src/stmt/mod.rs
index 210c97be8d..8ac831a58f 100644
--- a/crates/perry-codegen/src/stmt/mod.rs
+++ b/crates/perry-codegen/src/stmt/mod.rs
@@ -22,6 +22,7 @@ mod boxed_slot_no_root_tests;
 mod cached_field_index_return;
 #[cfg(test)]
 mod class_field_loop_tests;
+mod class_first_loop;
 #[cfg(test)]
 mod compound_alias_fold_tests;
 mod counter_range;
@@ -173,9 +174,37 @@ fn lower_async_rejecting_stmts_inner(
     Ok(())
 }
 
+/// #11759 (c′): one copy of a function body's versioned tail
+/// (`class_first_loop::try_lower_versioned_tail`). It never versions again on
+/// its own first statement.
+fn lower_stmts_versioned_tail(
+    ctx: &mut FnCtx<'_>,
+    stmts: &[Stmt],
+    emit_shadow_clears: bool,
+) -> Result<()> {
+    lower_stmts_from(ctx, stmts, emit_shadow_clears, false)
+}
+
 fn lower_stmts_inner(ctx: &mut FnCtx<'_>, stmts: &[Stmt], emit_shadow_clears: bool) -> Result<()> {
+    lower_stmts_from(ctx, stmts, emit_shadow_clears, emit_shadow_clears)
+}
+
+fn lower_stmts_from(
+    ctx: &mut FnCtx<'_>,
+    stmts: &[Stmt],
+    emit_shadow_clears: bool,
+    version_tails: bool,
+) -> Result<()> {
     let mut i = 0;
     while i < stmts.len() {
+        // #11759 (c′): the rest of a function body after `let c = new C()`
+        // through a repeatable class declaration's binding tests the
+        // declaration's first evaluation once (`class_first_loop`).
+        if version_tails
+            && class_first_loop::try_lower_versioned_tail(ctx, &stmts[i..], i, emit_shadow_clears)?
+        {
+            return Ok(());
+        }
         // A common memo-table method shape is
         // `if (!owner.table[i]) { ...fill... } return owner.table[i]`.
         // Before lowering the untouched statements, add a guarded direct
@@ -328,6 +357,15 @@ fn lower_return_expr(ctx: &mut FnCtx<'_>, expr: &perry_hir::Expr) -> Result<Stri
 }
 
 pub(crate) fn lower_stmt(ctx: &mut FnCtx<'_>, stmt: &Stmt) -> Result<()> {
+    // #11759 (c′): a loop holding first-evaluation guards on a binding it
+    // cannot rebind tests once, before the loop.
+    if matches!(
+        stmt,
+        Stmt::For { .. } | Stmt::While { .. } | Stmt::DoWhile { .. }
+    ) && class_first_loop::try_lower_versioned_loop(ctx, stmt)?
+    {
+        return Ok(());
+    }
     match stmt {
         Stmt::Expr(e) => {
             // #10185: the element-shape fast clone's carried-index statements
diff --git a/crates/perry-codegen/src/type_analysis/numeric.rs b/crates/perry-codegen/src/type_analysis/numeric.rs
index 8098d35368..6f01ae4c05 100644
--- a/crates/perry-codegen/src/type_analysis/numeric.rs
+++ b/crates/perry-codegen/src/type_analysis/numeric.rs
@@ -705,6 +705,20 @@ pub(crate) fn expr_produces_canonical_raw_f64(ctx: &FnCtx<'_>, e: &Expr) -> bool
             if crate::stmt::region_loop::is_f64_read(ctx, e) {
                 return true;
             }
+            // #11759 (c′): the receiver is the guarded `new` of a repeatable
+            // class declaration, an instance of SOME evaluation of the
+            // template. Which fields hold a Number on every reachable store
+            // is a template fact (`ShapeProof::lineage`), so whatever route
+            // reads the field — the scalar a replaced first-evaluation `new`
+            // keeps, or a later evaluation's guarded read — hands back the
+            // Number that was stored: canonical, since every raw-f64 store
+            // canonicalizes and every boxed read of a Number is its double.
+            if let Expr::LocalGet(id) = object.as_ref() {
+                if let Some(fact) = ctx.native_facts.shape_lineage_local(*id) {
+                    return !ctx.boxed_vars.contains(id)
+                        && fact.numeric_fields.contains(property.as_str());
+                }
+            }
             let Some(fact) = ctx.ptr_shape_receiver_fact(object.as_ref()) else {
                 return false;
             };
@@ -1050,6 +1064,7 @@ pub(crate) fn is_bool_expr(ctx: &FnCtx<'_>, e: &Expr) -> bool {
         | Expr::MapHas { .. }
         | Expr::MapDelete { .. } => true,
         Expr::ArrayIncludes { .. } => true,
+        Expr::ClassIsFirstEvaluation { .. } => true,
         Expr::LocalGet(id) => matches!(ctx.stable_local_type_proof(id), Some(HirType::Boolean)),
         _ => false,
     }
diff --git a/crates/perry-codegen/src/type_analysis/refine.rs b/crates/perry-codegen/src/type_analysis/refine.rs
index 7d7af1f7a1..23352e7de3 100644
--- a/crates/perry-codegen/src/type_analysis/refine.rs
+++ b/crates/perry-codegen/src/type_analysis/refine.rs
@@ -187,6 +187,15 @@ pub(crate) fn declared_property_type_from_annotation(
 /// default until their full lowering contract is explicitly reviewed here.
 pub(crate) fn proven_type_from_init(ctx: &FnCtx<'_>, init: &Expr) -> Option<HirType> {
     match init {
+        // #11759 (c′): `new C()` guarded on the first evaluation proves what
+        // its static construction proves.
+        Expr::Conditional {
+            condition,
+            then_expr,
+            ..
+        } if matches!(condition.as_ref(), Expr::ClassIsFirstEvaluation { .. }) => {
+            proven_type_from_init(ctx, then_expr)
+        }
         Expr::LocalGet(id) => ctx.stable_local_type_proof(id).cloned(),
         Expr::Undefined | Expr::Void(_) => Some(HirType::Void),
         Expr::Null => Some(HirType::Null),
@@ -391,6 +400,16 @@ pub(crate) fn is_imported_native_constructor_class(
 /// - **PropertyGet on a known class field** → the field's declared type
 pub(crate) fn refine_type_from_init(ctx: &FnCtx<'_>, init: &Expr) -> Option<HirType> {
     match init {
+        // #11759 (c′): `new C()` / `C.<static>` guarded on the first
+        // evaluation refines as its static form; a later evaluation builds an
+        // instance of the same class code.
+        Expr::Conditional {
+            condition,
+            then_expr,
+            ..
+        } if matches!(condition.as_ref(), Expr::ClassIsFirstEvaluation { .. }) => {
+            refine_type_from_init(ctx, then_expr)
+        }
         // Numeric literals + arithmetic results: refine to Number so the
         // for-loop counter `let i = 0` (and any other untyped numeric
         // local) gets recognized by `is_numeric_expr`. Without this,
diff --git a/crates/perry-hir/src/analysis/value_types.rs b/crates/perry-hir/src/analysis/value_types.rs
index 29ef1a1172..7bb8be6712 100644
--- a/crates/perry-hir/src/analysis/value_types.rs
+++ b/crates/perry-hir/src/analysis/value_types.rs
@@ -829,6 +829,7 @@ pub fn infer_expr_type<F: HirTypeFacts + ?Sized>(expr: &Expr, env: &F) -> Type {
             Type::Object(ObjectType::default())
         }
         Expr::ClassExprFresh { .. } => Type::Object(ObjectType::default()),
+        Expr::ClassIsFirstEvaluation { .. } => Type::Boolean,
         Expr::SetFunctionPrototype { proto, .. } => infer_expr_type(proto, env),
         Expr::GetFunctionPrototypeMethod { .. } => optional_type(function_type_for_return(None)),
         Expr::MapNew => generic_type("Map"),
diff --git a/crates/perry-hir/src/analysis/value_types_tests.rs b/crates/perry-hir/src/analysis/value_types_tests.rs
index a73012829d..233b75286b 100644
--- a/crates/perry-hir/src/analysis/value_types_tests.rs
+++ b/crates/perry-hir/src/analysis/value_types_tests.rs
@@ -1185,6 +1185,8 @@ fn infers_class_prototype_and_super_meta_value_shapes() {
                 computed_statics: Vec::new(),
                 static_init_order: Vec::new(),
                 captured_args: Vec::new(),
+                shared_first_evaluation: None,
+                evaluated_parent: None,
             },
             &env,
         ),
diff --git a/crates/perry-hir/src/ir/expr.rs b/crates/perry-hir/src/ir/expr.rs
index 307247533b..3bdcc82cbf 100644
--- a/crates/perry-hir/src/ir/expr.rs
+++ b/crates/perry-hir/src/ir/expr.rs
@@ -671,6 +671,37 @@ pub enum Expr {
         /// environment — which the static `new ClassName()` inlining
         /// can't do once the class escapes its defining scope.
         captured_args: Vec<Expr>,
+        /// #11759 (c′): a class DECLARATION whose definition may be evaluated
+        /// more than once (`lower::run_once` cannot prove otherwise) and that
+        /// has no other per-evaluation state. Its FIRST evaluation is the
+        /// shared class, `ClassRef(template)`, exactly what a single
+        /// evaluation gets; only the second and later evaluations allocate a
+        /// fresh class object. Whether the shared class was handed out is a
+        /// fact of the template (one flag codegen keeps beside the class),
+        /// tested with one compare and branch. `Some(init)` carries the first
+        /// evaluation's static initialization against the shared class (the
+        /// template-keyed statements a single-evaluation declaration runs) as
+        /// one `Sequence` evaluated for its effects. `None`: every evaluation
+        /// is fresh.
+        shared_first_evaluation: Option<Box<Expr>>,
+        /// #11759 (c′): the binding of this declaration's parent, itself a
+        /// shared-first declaration of the same body (`class D extends L`).
+        /// The template's heritage is the parent's template (its first
+        /// evaluation); an evaluation shares D's first evaluation only while
+        /// the binding holds L's first evaluation, and every other
+        /// evaluation pins the evaluated parent the binding holds.
+        evaluated_parent: Option<Box<Expr>>,
+    },
+
+    /// #11759 (c′): is `value` (a class declaration's evaluated binding) the
+    /// declaration's FIRST evaluation, the shared class of `template`? Guards
+    /// the static forms (`new`, static field reads) a single evaluation gets,
+    /// so code running in the first evaluation keeps them; a later
+    /// evaluation takes the by-value form. Codegen: one load of the
+    /// template's first-evaluation word and one compare.
+    ClassIsFirstEvaluation {
+        value: Box<Expr>,
+        template: String,
     },
 
     // Static `.prototype` assignment. Evaluates the receiver once and performs
diff --git a/crates/perry-hir/src/lower/context_new.rs b/crates/perry-hir/src/lower/context_new.rs
index dc4cc77188..e7e535df86 100644
--- a/crates/perry-hir/src/lower/context_new.rs
+++ b/crates/perry-hir/src/lower/context_new.rs
@@ -95,6 +95,9 @@ impl LoweringContext {
             class_decl_self_binding_wanted: false,
             class_decl_self_binding: None,
             per_evaluation_class_decls: HashSet::new(),
+            shared_first_class_bindings: HashMap::new(),
+            evaluated_parent_bindings: HashMap::new(),
+            shared_first_decl_locals: HashMap::new(),
             class_decl_self_binding_ids: Vec::new(),
             current_class_member_is_static: false,
             private_scopes: Vec::new(),
diff --git a/crates/perry-hir/src/lower/expr_function.rs b/crates/perry-hir/src/lower/expr_function.rs
index cbd1be8bb4..2aeb2aa68b 100644
--- a/crates/perry-hir/src/lower/expr_function.rs
+++ b/crates/perry-hir/src/lower/expr_function.rs
@@ -1293,10 +1293,14 @@ fn lower_fn_expr_anon(ctx: &mut LoweringContext, fn_expr: &ast::FnExpr) -> Resul
                         for s in body.iter_mut() {
                             crate::lower_decl::append_new_args_stmt(s, &cname, &cap_args, true);
                         }
-                        let re_reg = Stmt::Expr(Expr::RegisterClassCaptures {
-                            class_name: cname,
-                            captures,
-                        });
+                        let re_reg = crate::lower_decl::guard_shared_first_capture_snapshot(
+                            ctx,
+                            &cname,
+                            Stmt::Expr(Expr::RegisterClassCaptures {
+                                class_name: cname.clone(),
+                                captures,
+                            }),
+                        );
                         re_reg_capsets.push((re_reg.clone(), captured.iter().copied().collect()));
                         re_regs.push(re_reg);
                     }
diff --git a/crates/perry-hir/src/lower/lower_expr.rs b/crates/perry-hir/src/lower/lower_expr.rs
index f9f959e32c..af9946c9a0 100644
--- a/crates/perry-hir/src/lower/lower_expr.rs
+++ b/crates/perry-hir/src/lower/lower_expr.rs
@@ -114,8 +114,14 @@ fn lower_expr_impl(ctx: &mut LoweringContext, expr: &ast::Expr) -> Result<Expr>
         ast::Expr::Ident(ident) => lower_ident_expr(ctx, ident),
         ast::Expr::Bin(bin) => lower_bin_expr(ctx, bin),
         ast::Expr::Unary(unary) => lower_unary_expr(ctx, unary),
-        ast::Expr::Call(call) => expr_call::lower_call(ctx, call),
-        ast::Expr::Member(member) => expr_member::lower_member(ctx, member),
+        ast::Expr::Call(call) => {
+            let call = expr_call::lower_call(ctx, call)?;
+            Ok(crate::lower_decl::guard_shared_first_static_call(ctx, call))
+        }
+        ast::Expr::Member(member) => {
+            let read = expr_member::lower_member(ctx, member)?;
+            Ok(crate::lower_decl::guard_shared_first_static_get(ctx, read))
+        }
         ast::Expr::Paren(paren) => lower_expr(ctx, &paren.expr),
         ast::Expr::Assign(assign) => expr_assign::lower_assign(ctx, assign),
         ast::Expr::Cond(cond) => expr_misc::lower_cond(ctx, cond),
@@ -193,7 +199,10 @@ fn lower_expr_impl(ctx: &mut LoweringContext, expr: &ast::Expr) -> Result<Expr>
             }
             Ok(Expr::This)
         }
-        ast::Expr::New(new_expr) => expr_new::lower_new(ctx, new_expr),
+        ast::Expr::New(new_expr) => {
+            let construct = expr_new::lower_new(ctx, new_expr)?;
+            Ok(crate::lower_decl::guard_shared_first_new(ctx, construct))
+        }
         ast::Expr::Arrow(arrow) => expr_function::lower_arrow(ctx, arrow),
         ast::Expr::Fn(fn_expr) => expr_function::lower_fn_expr(ctx, fn_expr),
         ast::Expr::Await(await_expr) => expr_misc::lower_await(ctx, await_expr),
diff --git a/crates/perry-hir/src/lower/lower_expr/arm_class.rs b/crates/perry-hir/src/lower/lower_expr/arm_class.rs
index 0584df2b2c..1393076688 100644
--- a/crates/perry-hir/src/lower/lower_expr/arm_class.rs
+++ b/crates/perry-hir/src/lower/lower_expr/arm_class.rs
@@ -394,6 +394,8 @@ pub(crate) fn lower_class_expr(
             computed_statics,
             static_init_order,
             captured_args,
+            shared_first_evaluation: None,
+            evaluated_parent: None,
         };
         let mut seq: Vec<Expr> = Vec::new();
         if let Some(p) = parent_expr {
diff --git a/crates/perry-hir/src/lower/lowering_context.rs b/crates/perry-hir/src/lower/lowering_context.rs
index 08ba929f45..8fd35ac10c 100644
--- a/crates/perry-hir/src/lower/lowering_context.rs
+++ b/crates/perry-hir/src/lower/lowering_context.rs
@@ -410,6 +410,22 @@ pub struct LoweringContext {
     /// 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>,
+    /// #11759 (c′): locals that hold an evaluation of a class declaration
+    /// whose later evaluations are fresh (the declaration's binding and its
+    /// members' self-binding) → (template, its declared static field names).
+    /// `new C()` and `C.<static>` through such a local test whether it holds
+    /// the first evaluation and then take the static form.
+    pub(crate) shared_first_class_bindings: HashMap<LocalId, (String, Vec<String>)>,
+    /// #11759 (c′): declarations whose parent is a shared-first declaration of
+    /// the same body, resolved statically to its template → the parent's
+    /// binding (`ClassExprFresh::evaluated_parent`).
+    pub(crate) evaluated_parent_bindings: HashMap<String, LocalId>,
+    /// #11759 (c′): template → the declaration's own binding, for a
+    /// shared-first declaration. The template-keyed capture snapshot
+    /// (`RegisterClassCaptures`, read when the shared class is constructed by
+    /// value) belongs to the first evaluation only; later evaluations carry
+    /// their own capture arrays.
+    pub(crate) shared_first_decl_locals: HashMap<String, LocalId>,
     /// #11142: the active `class_expr_self_bindings` entries that belong to
     /// per-evaluation class DECLARATIONS. `new C()` and `x instanceof C` in
     /// such a body construct and test against the evaluation too.
diff --git a/crates/perry-hir/src/lower/shared_mutable_capture.rs b/crates/perry-hir/src/lower/shared_mutable_capture.rs
index b0725033a7..7de1019fda 100644
--- a/crates/perry-hir/src/lower/shared_mutable_capture.rs
+++ b/crates/perry-hir/src/lower/shared_mutable_capture.rs
@@ -1627,8 +1627,16 @@ fn rewrite_expr(expr: &mut Expr, shared: &HashSet<LocalId>, index_uses: &HashSet
             computed_keys,
             computed_statics,
             captured_args,
+            shared_first_evaluation,
+            evaluated_parent,
             ..
         } => {
+            if let Some(init) = shared_first_evaluation {
+                rewrite_expr(init, shared, index_uses);
+            }
+            if let Some(parent) = evaluated_parent {
+                rewrite_expr(parent, shared, index_uses);
+            }
             for (_, v) in named_statics.iter_mut() {
                 rewrite_expr(v, shared, index_uses);
             }
diff --git a/crates/perry-hir/src/lower/tests/capture_stash.rs b/crates/perry-hir/src/lower/tests/capture_stash.rs
index 43963f51c3..da7e771181 100644
--- a/crates/perry-hir/src/lower/tests/capture_stash.rs
+++ b/crates/perry-hir/src/lower/tests/capture_stash.rs
@@ -3,7 +3,9 @@
 //! for the 2000-line file cap.
 //!
 //! The fixtures declare their classes in a function that may run many times,
-//! so the classes keep the per-instance snapshot. A class evaluated once keeps
+//! and give the derived class a private element, so it keeps the per-instance
+//! snapshot (#11759 (c′): a repeatable declaration without per-evaluation
+//! state reads its captures from a guarded class environment instead). A class evaluated once keeps
 //! its captures in the class environment instead, needs no `this`, and
 //! publishes at constructor entry (the last test).
 
@@ -22,6 +24,7 @@ fn derived_ctor_capture_stash_follows_super_inside_comma_sequence() {
                 constructor(opts) { this.definition = opts.definition; }
             }
             class Derived extends Base {
+                #p = 0;
                 constructor({ definition: r, name: n }) {
                     super({ definition: r }), this.name = n, this.tag = shared.tag;
                 }
@@ -43,6 +46,7 @@ fn derived_ctor_capture_stash_follows_super_inside_if_test() {
                 constructor() { this.base = 1; }
             }
             class Derived extends Base {
+                #p = 0;
                 constructor(e) {
                     var q;
                     if (super(), this.count = 0, this.tag = shared.tag, !e) { q = 1; }
diff --git a/crates/perry-hir/src/lower/tests/class_decl_self_binding.rs b/crates/perry-hir/src/lower/tests/class_decl_self_binding.rs
index 41b5e59b66..e5f39beb71 100644
--- a/crates/perry-hir/src/lower/tests/class_decl_self_binding.rs
+++ b/crates/perry-hir/src/lower/tests/class_decl_self_binding.rs
@@ -81,29 +81,67 @@ fn private_class_decl_self_reference_reads_its_evaluation() {
 }
 
 #[test]
-fn shared_template_class_decl_keeps_its_class_ref() {
-    // No private elements and no heritage: the declaration keeps the shared
-    // template path, so a self-reference stays the cheap `ClassRef` and does
-    // not become a capture that could move the class onto the fresh path.
+fn run_once_class_decl_keeps_its_class_ref() {
+    // No private elements and no heritage, in a body that runs once: the
+    // declaration keeps the shared template path, so a self-reference stays
+    // the cheap `ClassRef` and does not become a capture that could move the
+    // class onto the fresh path.
     let hir = lower(
         r#"
-            export function factory() {
+            function factory() {
                 class Plain {
                     static make() { return new Plain(); }
                     static self() { return Plain; }
                 }
                 return Plain;
             }
+            export const made = factory();
         "#,
     );
     let self_body = static_method_body(&hir, "Plain", "self");
     assert!(
         self_body.contains("ClassRef(\"Plain\")"),
-        "a shared-template declaration keeps its ClassRef: {self_body}"
+        "a run-once declaration keeps its ClassRef: {self_body}"
     );
     let factory = factory_body(&hir);
     assert!(
         !factory.contains("ClassExprFresh"),
-        "a shared-template declaration must stay off the fresh path: {factory}"
+        "a run-once declaration must stay off the fresh path: {factory}"
+    );
+}
+
+#[test]
+fn repeatable_class_decl_shares_its_first_evaluation() {
+    // #11759 (c′): the same declaration in a function that may run more than
+    // once. Its first evaluation is the shared class and its later ones are
+    // fresh; its members read their own evaluation, and `new Plain()` through
+    // it takes the static construction while it holds the first evaluation.
+    let hir = lower(
+        r#"
+            export function factory() {
+                class Plain {
+                    static make() { return new Plain(); }
+                    static self() { return Plain; }
+                }
+                return Plain;
+            }
+        "#,
+    );
+    let factory = factory_body(&hir);
+    assert!(
+        factory.contains("ClassExprFresh") && factory.contains("shared_first_evaluation: Some("),
+        "later evaluations are fresh, the first is shared: {factory}"
+    );
+    let self_body = static_method_body(&hir, "Plain", "self");
+    assert!(
+        !self_body.contains("ClassRef(\"Plain\")"),
+        "a member reads its own evaluation, not the template: {self_body}"
+    );
+    let make = static_method_body(&hir, "Plain", "make");
+    assert!(
+        make.contains("ClassIsFirstEvaluation")
+            && make.contains("class_name: \"Plain\"")
+            && make.contains("NewDynamic"),
+        "`new Plain()` is static for the first evaluation, by value after: {make}"
     );
 }
diff --git a/crates/perry-hir/src/lower/tests/class_expr_naming_and_shadowing.rs b/crates/perry-hir/src/lower/tests/class_expr_naming_and_shadowing.rs
index 946a3af23f..3df9d503ef 100644
--- a/crates/perry-hir/src/lower/tests/class_expr_naming_and_shadowing.rs
+++ b/crates/perry-hir/src/lower/tests/class_expr_naming_and_shadowing.rs
@@ -90,7 +90,7 @@ fn nested_class_shadowing_outer_var_constructs_the_class_not_the_local() {
     let body = format!("{:#?}", mk.body);
 
     assert!(
-        !body.contains("NewDynamic"),
+        constructs_only_through_own_evaluation(&mk.body, "A"),
         "`new A()` inside A's own method must not construct through an \
          enclosing-scope local slot: {body}"
     );
@@ -535,7 +535,7 @@ fn first_of_several_same_named_nested_classes_constructs_itself() {
     let body = format!("{:#?}", mk.body);
 
     assert!(
-        !body.contains("NewDynamic"),
+        constructs_only_through_own_evaluation(&mk.body, "i"),
         "`new i()` inside i's own method must not construct through the \
          enclosing binding's slot: {body}"
     );
@@ -584,3 +584,50 @@ fn method_local_shadowing_the_class_name_still_wins_in_new() {
         "a method-scope local named after the class must still win for `new`: {body}"
     );
 }
+
+/// Every by-value `new` in `body` constructs class `class_name`'s own
+/// evaluation (#11759 (c′): a declaration that may be evaluated more than
+/// once constructs its first evaluation statically and a later one through
+/// the evaluation its member reads from the class environment), never an
+/// enclosing scope's binding of the same name.
+fn constructs_only_through_own_evaluation(body: &[crate::ir::Stmt], class_name: &str) -> bool {
+    use crate::ir::{Expr, Stmt};
+    // Locals the body binds to its class environment.
+    let own: Vec<crate::types::LocalId> = body
+        .iter()
+        .filter_map(|stmt| match stmt {
+            Stmt::Let {
+                id,
+                init: Some(Expr::ClassEnvGet { class_name: c, .. }),
+                ..
+            } if c == class_name => Some(*id),
+            _ => None,
+        })
+        .collect();
+    let reads_own = |e: &Expr| match e {
+        Expr::LocalGet(id) => own.contains(id),
+        Expr::IndexGet { object, .. } => {
+            matches!(object.as_ref(), Expr::LocalGet(id) if own.contains(id))
+        }
+        Expr::ClassEnvGet { class_name: c, .. } => c == class_name,
+        _ => false,
+    };
+    let mut ok = true;
+    fn visit(e: &Expr, check: &mut dyn FnMut(&Expr)) {
+        check(e);
+        crate::walker::walk_expr_children(e, &mut |c| visit(c, check));
+    }
+    for stmt in body {
+        crate::walker::stmt_any_expr(stmt, &mut |e| {
+            visit(e, &mut |x| {
+                if let Expr::NewDynamic { callee, .. } = x {
+                    if !reads_own(callee) {
+                        ok = false;
+                    }
+                }
+            });
+            false
+        });
+    }
+    ok
+}
diff --git a/crates/perry-hir/src/lower/tests/fresh_class_extends_renamed.rs b/crates/perry-hir/src/lower/tests/fresh_class_extends_renamed.rs
index 9c9cc72b82..b3adc966e4 100644
--- a/crates/perry-hir/src/lower/tests/fresh_class_extends_renamed.rs
+++ b/crates/perry-hir/src/lower/tests/fresh_class_extends_renamed.rs
@@ -32,38 +32,52 @@ const RENAMED_FRESH_PARENT: &str = r#"
 
 #[test]
 fn a_renamed_fresh_parent_is_read_from_its_binding() {
+    // #11759 (c′): L may be evaluated more than once, and so may D. D's
+    // template extends the renamed L's template (not the other module-level
+    // `L`), and each evaluation of D after its first pins the evaluated `L`
+    // its binding holds.
     let hir = lower(RENAMED_FRESH_PARENT);
     let d = class(&hir, "D");
+    let parent = d
+        .extends_name
+        .clone()
+        .expect("D's template extends L's template");
     assert!(
-        d.extends_expr.is_some(),
-        "D must take its parent from the evaluated `L`, got extends={:?} extends_name={:?}",
-        d.extends,
-        d.extends_name
+        parent != "L" && parent.starts_with('L'),
+        "D extends the scope-renamed L of its own body: {parent}"
     );
+    assert!(d.extends_expr.is_none(), "{:?}", d.extends_expr);
+    let make = make_body(&hir);
     assert!(
-        d.extends.is_none(),
-        "no static parent class: {:?}",
-        d.extends
-    );
-    assert!(
-        d.extends_name.is_none(),
-        "no retained parent name for the static chain walks: {:?}",
-        d.extends_name
+        make.contains("evaluated_parent: Some(LocalGet("),
+        "D's later evaluations take their parent from the evaluated `L`: {make}"
     );
 }
 
+/// The `make` function's body, as debug text.
+fn make_body(hir: &Module) -> String {
+    let body = &hir
+        .functions
+        .iter()
+        .find(|f| f.name == "make")
+        .expect("`make` must be lowered")
+        .body;
+    format!("{body:?}")
+}
+
 #[test]
 fn a_renamed_shared_parent_stays_static() {
-    // Two same-named classes, neither per evaluation: the rename resolves the
-    // heritage statically to the right one, as before.
+    // Two same-named classes, neither per evaluation (the body declaring the
+    // parent runs once): the rename resolves the heritage statically to the
+    // right one, as before.
     let hir = lower(
         r#"
         export const other = () => { class L {} return L; };
-        export function make() {
+        export const made = (function make() {
             class L { v() { return 1; } }
             class D extends L {}
             return D;
-        }
+        })();
         "#,
     );
     let d = class(&hir, "D");
@@ -74,3 +88,27 @@ fn a_renamed_shared_parent_stays_static() {
     );
     assert!(d.extends.is_some(), "a shared parent is static");
 }
+
+#[test]
+fn a_renamed_repeatable_parent_follows_its_evaluation() {
+    // #11759 (c′): the same parent in a function that may run more than once
+    // has fresh later evaluations, so the subclass's later evaluations take
+    // their parent from the evaluated class bound to `L`.
+    let hir = lower(
+        r#"
+        export const other = () => { class L {} return L; };
+        export function make() {
+            class L { v() { return 1; } }
+            class D extends L {}
+            return D;
+        }
+        "#,
+    );
+    let d = class(&hir, "D");
+    assert!(d.extends.is_some(), "D's template extends L's template");
+    let make = make_body(&hir);
+    assert!(
+        make.contains("evaluated_parent: Some(LocalGet("),
+        "D's later evaluations take their parent from the evaluated `L`: {make}"
+    );
+}
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
index 96674f9799..ba8ee641d3 100644
--- 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
@@ -40,7 +40,13 @@ fn per_evaluation_class_decl_members_use_the_evaluation() {
     );
     let bump = static_method_debug(&hir, "C", "bump");
     assert!(!bump.contains("StaticFieldSet"), "template write: {bump}");
-    assert!(!bump.contains("StaticFieldGet"), "template read: {bump}");
+    // #11759 (c′): a template read appears only as the first evaluation's
+    // static form, guarded on the binding holding the first evaluation.
+    assert_eq!(
+        bump.matches("StaticFieldGet").count(),
+        bump.matches("ClassIsFirstEvaluation").count(),
+        "unguarded template read: {bump}"
+    );
     let class = hir.classes.iter().find(|c| c.name == "C").unwrap();
     let reset = class
         .static_fields
diff --git a/crates/perry-hir/src/lower_decl/block.rs b/crates/perry-hir/src/lower_decl/block.rs
index 9fea77114b..6b8c7e26b6 100644
--- a/crates/perry-hir/src/lower_decl/block.rs
+++ b/crates/perry-hir/src/lower_decl/block.rs
@@ -677,10 +677,14 @@ pub fn lower_fn_body_block_stmt(
                         for s in body.iter_mut() {
                             super::class_captures::append_new_args_stmt(s, &cname, &cap_args, true);
                         }
-                        let re_reg = Stmt::Expr(Expr::RegisterClassCaptures {
-                            class_name: cname,
-                            captures,
-                        });
+                        let re_reg = crate::lower_decl::guard_shared_first_capture_snapshot(
+                            ctx,
+                            &cname,
+                            Stmt::Expr(Expr::RegisterClassCaptures {
+                                class_name: cname.clone(),
+                                captures,
+                            }),
+                        );
                         re_reg_capsets.push((re_reg.clone(), captured.iter().copied().collect()));
                         re_regs.push(re_reg);
                     }
diff --git a/crates/perry-hir/src/lower_decl/body_stmt.rs b/crates/perry-hir/src/lower_decl/body_stmt.rs
index cec01b8b02..b16c7be167 100644
--- a/crates/perry-hir/src/lower_decl/body_stmt.rs
+++ b/crates/perry-hir/src/lower_decl/body_stmt.rs
@@ -368,6 +368,7 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                 // #11142: a self-binding capture holds the evaluated class
                 // object, so snapshot the captures only once it exists.
                 let mut deferred_capture_snapshot = None;
+                let mut early_capture_snapshot = None;
                 if !captured_exprs.is_empty() {
                     let snapshot = Stmt::Expr(Expr::RegisterClassCaptures {
                         class_name: class.name.clone(),
@@ -376,7 +377,7 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                     if decl_self_binding.is_some() {
                         deferred_capture_snapshot = Some(snapshot);
                     } else {
-                        result.push(snapshot);
+                        early_capture_snapshot = Some(snapshot);
                     }
                 }
                 // Captures (#6465), private brands (#5893), computed names,
@@ -395,10 +396,28 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                         .iter()
                         .any(|m| m.name.starts_with("__perry_static_init_"));
                 let has_private_elements = class.has_private_elements();
-                let fresh_binding = has_private_elements
+                // Captures alone need a class object per evaluation only when
+                // the instances carry them: a guarded class environment
+                // (#11759 (c′)) gives the first evaluation the environment's
+                // slots and each later one its own capture array.
+                let per_evaluation_state = 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
+                        && !ctx.is_class_env_guarded(&class.name));
+                // #11759 (c′): a declaration that may be evaluated more than
+                // once and has no other per-evaluation state keeps the shared
+                // class for its FIRST evaluation; later ones are fresh.
+                let shares_first_evaluation = !per_evaluation_state
+                    && crate::lower_decl::class_decl::may_evaluate_repeatedly(
+                        ctx,
+                        class_decl.class.span,
+                        class.extends_expr.is_some(),
+                        class.native_extends.is_some(),
+                    );
+                let fresh_binding = per_evaluation_state
+                    || shares_first_evaluation
                     // #11157: members that captured the self-binding need it.
                     || decl_self_binding.is_some();
                 let named_statics: Vec<(String, Expr)> = if fresh_binding {
@@ -448,16 +467,45 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                 // classes initialized. Interleaved in source order (see
                 // `build_interleaved_static_init_stmts`), with lexical `this`
                 // in field initializers bound to the class ref.
-                if !fresh_binding {
-                    result.extend(
-                        crate::lower_decl::build_interleaved_static_init_stmts_after_computed_names(
-                            &class_decl.class.body,
-                            &class.name,
-                            &class.fields,
-                            &class.static_fields,
-                            &class.static_methods,
-                        ),
-                    );
+                let shared_static_init = (!fresh_binding || shares_first_evaluation).then(|| {
+                    crate::lower_decl::build_interleaved_static_init_stmts_after_computed_names(
+                        &class_decl.class.body,
+                        &class.name,
+                        &class.fields,
+                        &class.static_fields,
+                        &class.static_methods,
+                    )
+                });
+                // #11759 (c′): the template-keyed capture snapshot belongs to
+                // the first evaluation (the shared class, constructed by value
+                // from it); a later evaluation carries its own array.
+                let first_evaluation_snapshot = if shares_first_evaluation {
+                    early_capture_snapshot
+                        .take()
+                        .or_else(|| deferred_capture_snapshot.take())
+                } else {
+                    None
+                };
+                result.extend(early_capture_snapshot);
+                // The first evaluation runs the shared class's static
+                // initialization; it is a sequence of expression statements.
+                let mut shared_first_evaluation = None;
+                if let Some(stmts) = shared_static_init {
+                    if !fresh_binding {
+                        result.extend(stmts);
+                    } else {
+                        let exprs: Vec<Expr> = first_evaluation_snapshot
+                            .into_iter()
+                            .chain(stmts)
+                            .map(|stmt| match stmt {
+                                Stmt::Expr(expr) => expr,
+                                other => unreachable!(
+                                    "static initialization lowers to expression statements, got {other:?}"
+                                ),
+                            })
+                            .collect();
+                        shared_first_evaluation = Some(Box::new(Expr::Sequence(exprs)));
+                    }
                 }
                 let evaluation_owner = decl_self_binding_owner(
                     ctx,
@@ -472,6 +520,12 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                 if fresh_binding {
                     ctx.per_evaluation_class_decls.insert(template_name.clone());
                 }
+                if shares_first_evaluation {
+                    // `C.prototype.m = v` writes THIS evaluation's prototype,
+                    // never the template-keyed side table every evaluation
+                    // shares (#11134's rule for fresh class expressions).
+                    ctx.fresh_evaluation_classes.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
@@ -489,6 +543,19 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                     let binding_name = class_decl.ident.sym.to_string();
                     let class_local = ctx.define_local(binding_name.clone(), Type::Any);
                     ctx.record_local_source_span(class_local, class_decl.ident.span);
+                    if shares_first_evaluation {
+                        ctx.shared_first_decl_locals
+                            .insert(template_name.clone(), class_local);
+                        let statics = crate::lower_decl::class_decl::declared_static_field_names(
+                            &class_decl.class,
+                        );
+                        ctx.shared_first_class_bindings
+                            .insert(class_local, (template_name.clone(), statics));
+                    }
+                    let evaluated_parent = ctx
+                        .evaluated_parent_bindings
+                        .get(&template_name)
+                        .map(|id| Box::new(Expr::LocalGet(*id)));
                     result.push(Stmt::Let {
                         id: class_local,
                         name: binding_name,
@@ -503,6 +570,8 @@ fn lower_body_stmt_impl(ctx: &mut LoweringContext, stmt: &ast::Stmt) -> Result<V
                                 computed_statics,
                                 static_init_order,
                                 captured_args: captured_exprs,
+                                shared_first_evaluation,
+                                evaluated_parent,
                             },
                         )),
                         mutable: false,
diff --git a/crates/perry-hir/src/lower_decl/class_decl.rs b/crates/perry-hir/src/lower_decl/class_decl.rs
index d1b6bb9651..05a04f2d1d 100644
--- a/crates/perry-hir/src/lower_decl/class_decl.rs
+++ b/crates/perry-hir/src/lower_decl/class_decl.rs
@@ -49,7 +49,11 @@ fn is_genuine_node_stream_parent(ctx: &LoweringContext, name: &str) -> bool {
 
 mod class_heritage;
 mod decl_self_binding;
-pub(crate) use decl_self_binding::fresh_class_decl_self_binding;
+pub(crate) use decl_self_binding::{
+    declared_static_field_names, fresh_class_decl_self_binding,
+    guard_shared_first_capture_snapshot, guard_shared_first_new, guard_shared_first_static_call,
+    guard_shared_first_static_get, may_evaluate_repeatedly,
+};
 mod from_ast;
 mod member_helpers;
 mod member_registration;
@@ -176,10 +180,27 @@ pub fn lower_class_decl(
     // scope state the heritage routing below uses, before the body lowers any
     // new locals) so codegen can prefer the dynamic local over a NAME-keyed
     // built-in special case (Error/Request/Response/Event/CustomEvent/streams).
+    // #11759 (c′): `class D extends L` where `L` is a shared-first
+    // declaration of this body and D may itself evaluate more than once: D's
+    // template extends L's template (L's first evaluation), and each of D's
+    // evaluations other than its first pins the evaluated L its binding
+    // holds (`ClassExprFresh::evaluated_parent`).
+    let shared_first_parent = match class_decl.class.super_class.as_deref() {
+        Some(ast::Expr::Ident(ident))
+            if self_binding_wanted
+                && !decl_self_binding::class_body_has_private_names(&class_decl.class)
+                && !decl_self_binding::class_body_has_computed_keys(&class_decl.class)
+                && !ctx.class_definition_runs_once(class_decl.class.span) =>
+        {
+            ctx.lookup_local(ident.sym.as_ref())
+                .filter(|id| ctx.shared_first_class_bindings.contains_key(id))
+        }
+        _ => None,
+    };
     let heritage_lexically_shadowed = match class_decl.class.super_class.as_deref() {
         Some(ast::Expr::Ident(ident)) => {
             let n = ident.sym.to_string();
-            ctx.heritage_ident_is_lexical_local(&n)
+            ctx.heritage_ident_is_lexical_local(&n) && shared_first_parent.is_none()
         }
         _ => false,
     };
@@ -287,8 +308,9 @@ pub fn lower_class_decl(
                 .require_destructured_native_locals
                 .get(&parent_name)
                 .is_some_and(|key| *key == canonical_parent_name);
-            let locally_shadowed =
-                ctx.heritage_ident_is_lexical_local(&parent_name) && !require_native_reexport;
+            let locally_shadowed = ctx.heritage_ident_is_lexical_local(&parent_name)
+                && !require_native_reexport
+                && shared_first_parent.is_none();
             if native_parent.is_some() && !locally_shadowed {
                 // Keep `extends_name` populated alongside `native_extends`
                 // so SuperCall codegen + downstream chain walks still
@@ -458,12 +480,43 @@ pub fn lower_class_decl(
     };
 
     // #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.
+    // private elements is evaluated per evaluation (`ClassExprFresh`), and so
+    // are the later evaluations of one that may run more than once (#11759).
+    // Give its members the evaluated class, not the template, for its own
+    // name.
+    // #11759 (c′): a declaration that may run more than once and owns no
+    // per-evaluation heritage, private brand or computed key: its later
+    // evaluations are
+    // fresh class objects. Its members then read their captures (the
+    // self-binding included) from a GUARDED class environment, the scheme a
+    // fresh class expression uses: the first evaluation's instances carry no
+    // capture fields and read the environment directly while the class has
+    // had one evaluation.
+    let later_evaluations_fresh = self_binding_wanted
+        && !decl_self_binding::class_body_has_private_names(&class_decl.class)
+        && !decl_self_binding::class_body_has_computed_keys(&class_decl.class)
+        && may_evaluate_repeatedly(
+            ctx,
+            class_decl.class.span,
+            extends_expr.is_some(),
+            native_extends.is_some(),
+        );
     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));
+            || decl_self_binding::class_body_has_private_names(&class_decl.class)
+            || later_evaluations_fresh))
+        .then(|| {
+            decl_self_binding::push_decl_self_binding(ctx, class_decl.ident.sym.as_ref(), &name)
+        });
+    if let Some(parent_binding) = shared_first_parent.filter(|_| extends.is_some()) {
+        ctx.evaluated_parent_bindings
+            .insert(name.clone(), parent_binding);
+    }
+    if let (Some(self_id), true) = (class_self_binding, later_evaluations_fresh) {
+        let statics = decl_self_binding::declared_static_field_names(&class_decl.class);
+        ctx.shared_first_class_bindings
+            .insert(self_id, (name.clone(), statics));
+    }
 
     // Issue #10486: the branches above deliberately leave `extends_name`
     // None when the heritage identifier resolves to a lexically-scoped
@@ -1270,7 +1323,7 @@ pub fn lower_class_decl(
         &static_accessor_fn_ids,
         crate::lower_decl::CaptureDefinition::classify(
             ctx.class_definition_runs_once(class_decl.class.span),
-            false,
+            later_evaluations_fresh,
         ),
     );
 
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
index 6ab77547dd..26e44464a7 100644
--- 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
@@ -18,12 +18,24 @@
 
 use swc_ecma_ast as ast;
 
-use crate::ir::Expr;
+use crate::ir::{Expr, Stmt};
 use crate::lower::LoweringContext;
 use crate::types::LocalId;
 
 /// Syntactic private-element check: the class will report
 /// `has_private_elements()` once lowered.
+/// Syntactic computed-key check: a ClassBody member whose key is computed.
+pub(super) fn class_body_has_computed_keys(class: &ast::Class) -> bool {
+    class.body.iter().any(|member| match member {
+        ast::ClassMember::Method(m) => matches!(m.key, ast::PropName::Computed(_)),
+        ast::ClassMember::ClassProp(p) => matches!(p.key, ast::PropName::Computed(_)),
+        ast::ClassMember::AutoAccessor(a) => {
+            matches!(a.key, ast::Key::Public(ast::PropName::Computed(_)))
+        }
+        _ => false,
+    })
+}
+
 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,
@@ -34,6 +46,208 @@ pub(super) fn class_body_has_private_names(class: &ast::Class) -> bool {
     })
 }
 
+/// #11759 (c′): whether a function-body or block class declaration may be
+/// evaluated more than once, so its later evaluations must be fresh class
+/// objects (its first one stays the shared class). `lower::run_once` decides;
+/// a native-module parent stays on the template (#10623), and a runtime
+/// heritage value already makes every evaluation fresh.
+pub(crate) fn may_evaluate_repeatedly(
+    ctx: &LoweringContext,
+    span: swc_common::Span,
+    dynamic_heritage: bool,
+    native_parent: bool,
+) -> bool {
+    !dynamic_heritage && !native_parent && !ctx.class_definition_runs_once(span)
+}
+
+/// The names of `class`'s non-computed, non-private static fields.
+pub(crate) fn declared_static_field_names(class: &ast::Class) -> Vec<String> {
+    class
+        .body
+        .iter()
+        .filter_map(|member| match member {
+            ast::ClassMember::ClassProp(prop) if prop.is_static => match &prop.key {
+                ast::PropName::Ident(ident) => Some(ident.sym.to_string()),
+                ast::PropName::Str(s) => s.value.as_str().map(str::to_string),
+                _ => None,
+            },
+            _ => None,
+        })
+        .collect()
+}
+
+/// #11759 (c′): `new C(args)` through a local holding an evaluation of a
+/// shared-first class declaration: the static construction when the local
+/// holds the first evaluation (the shared class), else the by-value one.
+/// Arguments holding a function or class are left by value: the guard
+/// duplicates the arguments into both branches.
+pub(crate) fn guard_shared_first_new(ctx: &LoweringContext, expr: Expr) -> Expr {
+    let Expr::NewDynamic {
+        callee,
+        args,
+        byte_offset,
+    } = &expr
+    else {
+        return expr;
+    };
+    let Expr::LocalGet(binding) = callee.as_ref() else {
+        return expr;
+    };
+    let Some((template, _)) = ctx.shared_first_class_bindings.get(binding) else {
+        return expr;
+    };
+    if args.iter().any(defines_code) {
+        return expr;
+    }
+    let template = template.clone();
+    let mut static_args = args.clone();
+    let captures: Vec<LocalId> = ctx
+        .lookup_class_captures(&template)
+        .map(<[_]>::to_vec)
+        .unwrap_or_default();
+    let cap_args_appended = captures.len() as u32;
+    static_args.extend(captures.into_iter().map(Expr::LocalGet));
+    let construct = Expr::New {
+        class_name: template.clone(),
+        args: static_args,
+        type_args: Vec::new(),
+        byte_offset: *byte_offset,
+        cap_args_appended,
+    };
+    // A guarded class environment records the evaluation on an instance
+    // built statically once the class has had several (`ClassEnvStamp`).
+    let construct = if ctx.is_class_env_guarded(&template) {
+        Expr::ClassEnvStamp {
+            class_name: template.clone(),
+            instance: Box::new(construct),
+            evaluation: Box::new(Expr::LocalGet(*binding)),
+        }
+    } else {
+        construct
+    };
+    Expr::Conditional {
+        condition: Box::new(Expr::ClassIsFirstEvaluation {
+            value: Box::new(Expr::LocalGet(*binding)),
+            template,
+        }),
+        then_expr: Box::new(construct),
+        else_expr: Box::new(expr),
+    }
+}
+
+/// #11759 (c′): `C.<static field>` through a local holding an evaluation of a
+/// shared-first class declaration: the template's static field when the local
+/// holds the first evaluation, else the property of the evaluated object.
+pub(crate) fn guard_shared_first_static_get(ctx: &LoweringContext, expr: Expr) -> Expr {
+    let Expr::PropertyGet {
+        object, property, ..
+    } = &expr
+    else {
+        return expr;
+    };
+    let Expr::LocalGet(binding) = object.as_ref() else {
+        return expr;
+    };
+    let Some((template, statics)) = ctx.shared_first_class_bindings.get(binding) else {
+        return expr;
+    };
+    if !statics.iter().any(|name| name == property) {
+        return expr;
+    }
+    Expr::Conditional {
+        condition: Box::new(Expr::ClassIsFirstEvaluation {
+            value: Box::new(Expr::LocalGet(*binding)),
+            template: template.clone(),
+        }),
+        then_expr: Box::new(Expr::StaticFieldGet {
+            class_name: template.clone(),
+            field_name: property.clone(),
+        }),
+        else_expr: Box::new(expr),
+    }
+}
+
+/// #11759 (c′): `C.<static method>(args)` through a local holding an
+/// evaluation of a shared-first class declaration: the template's static
+/// method call when the local holds the first evaluation (what a single
+/// evaluation's `C.m()` is), else the call on the evaluated object. Arguments
+/// holding a function or class are left by value, as for `new`.
+pub(crate) fn guard_shared_first_static_call(ctx: &LoweringContext, expr: Expr) -> Expr {
+    let Expr::Call { callee, args, .. } = &expr else {
+        return expr;
+    };
+    let Expr::PropertyGet {
+        object, property, ..
+    } = callee.as_ref()
+    else {
+        return expr;
+    };
+    let Expr::LocalGet(binding) = object.as_ref() else {
+        return expr;
+    };
+    let Some((template, _)) = ctx.shared_first_class_bindings.get(binding) else {
+        return expr;
+    };
+    if !ctx.has_static_method(template, property) || args.iter().any(defines_code) {
+        return expr;
+    }
+    Expr::Conditional {
+        condition: Box::new(Expr::ClassIsFirstEvaluation {
+            value: Box::new(Expr::LocalGet(*binding)),
+            template: template.clone(),
+        }),
+        then_expr: Box::new(Expr::StaticMethodCall {
+            class_name: template.clone(),
+            method_name: property.clone(),
+            args: args.clone(),
+        }),
+        else_expr: Box::new(expr),
+    }
+}
+
+/// #11759 (c′): a template-keyed capture refresh (`RegisterClassCaptures`)
+/// of a shared-first declaration runs only while the declaration's binding
+/// holds its first evaluation; a later evaluation's captures live on its own
+/// class object.
+pub(crate) fn guard_shared_first_capture_snapshot(
+    ctx: &LoweringContext,
+    class_name: &str,
+    snapshot: Stmt,
+) -> Stmt {
+    let Some(binding) = ctx.shared_first_decl_locals.get(class_name) else {
+        return snapshot;
+    };
+    let Stmt::Expr(register) = snapshot else {
+        return snapshot;
+    };
+    Stmt::Expr(Expr::Conditional {
+        condition: Box::new(Expr::ClassIsFirstEvaluation {
+            value: Box::new(Expr::LocalGet(*binding)),
+            template: class_name.to_string(),
+        }),
+        then_expr: Box::new(register),
+        else_expr: Box::new(Expr::Undefined),
+    })
+}
+
+/// Does `expr` define a function or class (whose duplicate would be a second
+/// definition)?
+fn defines_code(expr: &Expr) -> bool {
+    let mut found = false;
+    let mut visit = |e: &Expr| {
+        if matches!(e, Expr::Closure { .. } | Expr::ClassExprFresh { .. }) {
+            found = true;
+        }
+    };
+    walk_defines(expr, &mut visit);
+    found
+}
+
+fn walk_defines(expr: &Expr, visit: &mut dyn FnMut(&Expr)) {
+    visit(expr);
+    crate::walker::walk_expr_children(expr, &mut |child| walk_defines(child, visit));
+}
+
 /// 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`].
diff --git a/crates/perry-hir/src/lower_decl/mod.rs b/crates/perry-hir/src/lower_decl/mod.rs
index 7f398006d5..892ffe9ac4 100644
--- a/crates/perry-hir/src/lower_decl/mod.rs
+++ b/crates/perry-hir/src/lower_decl/mod.rs
@@ -45,7 +45,9 @@ pub(crate) use class_computed::{
     class_computed_member_registration_expr, prepare_ordered_class_computed_names,
 };
 pub(crate) use class_decl::{
-    fresh_class_decl_self_binding, lower_class_decl, lower_class_from_ast,
+    fresh_class_decl_self_binding, guard_shared_first_capture_snapshot, guard_shared_first_new,
+    guard_shared_first_static_call, guard_shared_first_static_get, lower_class_decl,
+    lower_class_from_ast,
 };
 pub(crate) use class_members::{
     lower_class_method, lower_class_method_with_name, lower_class_prop, lower_constructor,
diff --git a/crates/perry-hir/src/monomorph/defaults.rs b/crates/perry-hir/src/monomorph/defaults.rs
index 77c4289cd8..4b8235cb32 100644
--- a/crates/perry-hir/src/monomorph/defaults.rs
+++ b/crates/perry-hir/src/monomorph/defaults.rs
@@ -250,6 +250,17 @@ fn fill_defaults_in_expr(expr: &mut Expr, cx: &DefaultFill) {
         Expr::Update { .. } => {
             // Update expressions (++/--) don't contain sub-expressions
         }
+        // A guarded class environment's static construction (a fresh class
+        // expression's `new K()`, and #11759 (c′)'s first-evaluation
+        // `new C()`) is a `New` like any other.
+        Expr::ClassEnvStamp {
+            instance,
+            evaluation,
+            ..
+        } => {
+            fill_defaults_in_expr(instance, cx);
+            fill_defaults_in_expr(evaluation, cx);
+        }
         Expr::Conditional {
             condition,
             then_expr,
diff --git a/crates/perry-hir/src/monomorph/tests.rs b/crates/perry-hir/src/monomorph/tests.rs
index f16d6f5a9a..a405c7ea5b 100644
--- a/crates/perry-hir/src/monomorph/tests.rs
+++ b/crates/perry-hir/src/monomorph/tests.rs
@@ -1182,16 +1182,35 @@ fn fill_defaults_pads_before_appended_class_captures() {
         .expect("child method");
     let mut found = None;
     fn find_new<'a>(stmts: &'a [Stmt], out: &mut Option<(&'a Vec<Expr>, u32)>) {
+        // #11759 (c′): `outer` may run more than once, so `new Doc(...)` is
+        // the static construction guarded on Doc's first evaluation
+        // (recorded on the instance in a guarded class environment).
+        fn construct<'a>(e: &'a Expr) -> Option<&'a Expr> {
+            match e {
+                Expr::Conditional {
+                    condition,
+                    then_expr,
+                    ..
+                } if matches!(condition.as_ref(), Expr::ClassIsFirstEvaluation { .. }) => {
+                    construct(then_expr)
+                }
+                Expr::ClassEnvStamp { instance, .. } => construct(instance),
+                Expr::New { .. } => Some(e),
+                _ => None,
+            }
+        }
         for stmt in stmts {
-            if let Stmt::Return(Some(Expr::New {
-                class_name,
-                args,
-                cap_args_appended,
-                ..
-            })) = stmt
-            {
-                if class_name == "Doc" {
-                    *out = Some((args, *cap_args_appended));
+            if let Stmt::Return(Some(ret)) = stmt {
+                if let Some(Expr::New {
+                    class_name,
+                    args,
+                    cap_args_appended,
+                    ..
+                }) = construct(ret)
+                {
+                    if class_name == "Doc" {
+                        *out = Some((args, *cap_args_appended));
+                    }
                 }
             }
         }
diff --git a/crates/perry-hir/src/stable_hash/expr.rs b/crates/perry-hir/src/stable_hash/expr.rs
index d7ed0ef3c1..f5b67828b5 100644
--- a/crates/perry-hir/src/stable_hash/expr.rs
+++ b/crates/perry-hir/src/stable_hash/expr.rs
@@ -658,7 +658,8 @@ impl SH for Expr {
             Expr::RegisterClassStaticSymbol { class_name, key_expr, value_expr, } => { tag(h, 12025); class_name.hash(h); key_expr.as_ref().hash(h); value_expr.as_ref().hash(h); }
             Expr::RegisterClassComputedMethod { class_name, key_expr, method_name, is_static, param_count, has_rest, definition_order } => { tag(h, 12233); class_name.hash(h); key_expr.as_ref().hash(h); method_name.hash(h); is_static.hash(h); param_count.hash(h); has_rest.hash(h); definition_order.hash(h); }
             Expr::RegisterClassComputedAccessor { class_name, key_expr, getter_name, setter_name, is_static, definition_order } => { tag(h, 12234); class_name.hash(h); key_expr.as_ref().hash(h); getter_name.hash(h); setter_name.hash(h); is_static.hash(h); definition_order.hash(h); }
-            Expr::ClassExprFresh { template, evaluation_owner, named_statics, computed_keys, computed_statics, static_init_order, captured_args, } => { tag(h, 12026); template.hash(h); evaluation_owner.hash(h); for (n, v) in named_statics { n.hash(h); v.hash(h); } for (n, k) in computed_keys { n.hash(h); k.hash(h); } for (n, v) in computed_statics { n.hash(h); v.hash(h); } for step in static_init_order { match step { ClassFreshStaticInit::Named(index) => { tag(h, 0); index.hash(h); }, ClassFreshStaticInit::Computed(index) => { tag(h, 1); index.hash(h); }, ClassFreshStaticInit::Block(index) => { tag(h, 2); index.hash(h); }, } } for a in captured_args { a.hash(h); } }
+            Expr::ClassIsFirstEvaluation { value, template } => { tag(h, 12512); value.hash(h); template.hash(h); }
+            Expr::ClassExprFresh { template, evaluation_owner, named_statics, computed_keys, computed_statics, static_init_order, captured_args, shared_first_evaluation, evaluated_parent, } => { tag(h, 12026); match shared_first_evaluation { Some(init) => { tag(h, 1); init.hash(h); } None => tag(h, 0), } match evaluated_parent { Some(parent) => { tag(h, 1); parent.hash(h); } None => tag(h, 0), } template.hash(h); evaluation_owner.hash(h); for (n, v) in named_statics { n.hash(h); v.hash(h); } for (n, k) in computed_keys { n.hash(h); k.hash(h); } for (n, v) in computed_statics { n.hash(h); v.hash(h); } for step in static_init_order { match step { ClassFreshStaticInit::Named(index) => { tag(h, 0); index.hash(h); }, ClassFreshStaticInit::Computed(index) => { tag(h, 1); index.hash(h); }, ClassFreshStaticInit::Block(index) => { tag(h, 2); index.hash(h); }, } } for a in captured_args { a.hash(h); } }
             Expr::SetFunctionPrototype { func, proto, strict } => { tag(h, 448); func.as_ref().hash(h); proto.as_ref().hash(h); strict.hash(h); }
             Expr::RegisterPrototypeMethod { class_name, method_name, value, } => { tag(h, 463); class_name.hash(h); method_name.hash(h); value.as_ref().hash(h); }
             Expr::RegisterFunctionPrototypeMethod { func, method_name, value, } => { tag(h, 464); func.as_ref().hash(h); method_name.hash(h); value.as_ref().hash(h); }
diff --git a/crates/perry-hir/src/walker/expr_mut.rs b/crates/perry-hir/src/walker/expr_mut.rs
index 43a4aa3891..5e6011110a 100644
--- a/crates/perry-hir/src/walker/expr_mut.rs
+++ b/crates/perry-hir/src/walker/expr_mut.rs
@@ -641,8 +641,16 @@ where
             computed_keys,
             computed_statics,
             captured_args,
+            shared_first_evaluation,
+            evaluated_parent,
             ..
         } => {
+            if let Some(init) = shared_first_evaluation {
+                f(init);
+            }
+            if let Some(parent) = evaluated_parent {
+                f(parent);
+            }
             for (_, v) in named_statics.iter_mut() {
                 f(v);
             }
@@ -656,6 +664,9 @@ where
                 f(a);
             }
         }
+        Expr::ClassIsFirstEvaluation { value, .. } => {
+            f(value);
+        }
         Expr::SetFunctionPrototype { func, proto, .. } => {
             f(func);
             f(proto);
diff --git a/crates/perry-hir/src/walker/expr_ref.rs b/crates/perry-hir/src/walker/expr_ref.rs
index dfc6a014fe..fa67c9bcec 100644
--- a/crates/perry-hir/src/walker/expr_ref.rs
+++ b/crates/perry-hir/src/walker/expr_ref.rs
@@ -642,8 +642,16 @@ where
             computed_keys,
             computed_statics,
             captured_args,
+            shared_first_evaluation,
+            evaluated_parent,
             ..
         } => {
+            if let Some(init) = shared_first_evaluation {
+                f(init);
+            }
+            if let Some(parent) = evaluated_parent {
+                f(parent);
+            }
             for (_, v) in named_statics {
                 f(v);
             }
@@ -657,6 +665,9 @@ where
                 f(a);
             }
         }
+        Expr::ClassIsFirstEvaluation { value, .. } => {
+            f(value);
+        }
         Expr::SetFunctionPrototype { func, proto, .. } => {
             f(func);
             f(proto);
diff --git a/crates/perry-hir/tests/class_self_new_shadowing.rs b/crates/perry-hir/tests/class_self_new_shadowing.rs
index a0aee8617f..528af816ca 100644
--- a/crates/perry-hir/tests/class_self_new_shadowing.rs
+++ b/crates/perry-hir/tests/class_self_new_shadowing.rs
@@ -10,6 +10,40 @@ fn lower_src(src: &str) -> perry_hir::Module {
         .expect("lowering should succeed")
 }
 
+/// `ret` constructs `class_name` statically. A class declared in a function
+/// that may run more than once (#11759 (c′)) constructs its first evaluation
+/// statically and a later one through its own evaluation: the static form is
+/// the guarded branch, and the by-value branch never reads a module-level
+/// binding of the same name.
+fn constructs_own_class(module: &perry_hir::Module, ret: &Expr, class_name: &str) -> bool {
+    match ret {
+        Expr::New { class_name: c, .. } => c == class_name,
+        Expr::ClassEnvStamp { instance, .. } => constructs_own_class(module, instance, class_name),
+        Expr::Conditional {
+            condition,
+            then_expr,
+            else_expr,
+        } if matches!(condition.as_ref(), Expr::ClassIsFirstEvaluation { .. }) => {
+            let outer: Vec<_> = module
+                .init
+                .iter()
+                .filter_map(|stmt| match stmt {
+                    Stmt::Let { id, name, .. } if name == "h" => Some(*id),
+                    _ => None,
+                })
+                .collect();
+            let by_value_is_outer = matches!(
+                else_expr.as_ref(),
+                Expr::NewDynamic { callee, .. }
+                    if matches!(callee.as_ref(), Expr::LocalGet(id) if outer.contains(id))
+                        || matches!(callee.as_ref(), Expr::GlobalGet(_))
+            );
+            constructs_own_class(module, then_expr, class_name) && !by_value_is_outer
+        }
+        _ => false,
+    }
+}
+
 #[test]
 fn class_self_new_wins_over_same_named_outer_local() {
     let module = lower_src(
@@ -40,7 +74,7 @@ fn class_self_new_wins_over_same_named_outer_local() {
     assert!(
         instance.body.iter().any(|stmt| matches!(
             stmt,
-            Stmt::Return(Some(Expr::New { class_name, .. })) if class_name == "h"
+            Stmt::Return(Some(ret)) if constructs_own_class(&module, ret, "h")
         )),
         "class self-construction must bind to the class, not the outer local: {:#?}",
         instance.body
@@ -77,7 +111,7 @@ fn collision_renamed_class_self_new_uses_unique_class_name() {
     assert!(
         instance.body.iter().any(|stmt| matches!(
             stmt,
-            Stmt::Return(Some(Expr::New { class_name, .. })) if class_name == &class.name
+            Stmt::Return(Some(ret)) if constructs_own_class(&module, ret, &class.name)
         )),
         "renamed class self-construction must use its unique name: {:#?}",
         instance.body
diff --git a/crates/perry-runtime/src/object/class_registry.rs b/crates/perry-runtime/src/object/class_registry.rs
index 4ebe645b67..e65d53b9f3 100644
--- a/crates/perry-runtime/src/object/class_registry.rs
+++ b/crates/perry-runtime/src/object/class_registry.rs
@@ -85,6 +85,7 @@ pub(crate) use state::async_resource_prototype_value;
 #[cfg(test)]
 pub(crate) use state::class_decl_prototype_object_root_store;
 pub(crate) use state::retire_displaced_decl_prototype;
+pub(crate) use state::stashed_dynamic_parent_value;
 pub(crate) use state::{
     builtin_parent_ctor_in_chain, class_decl_prototype_method_names, class_decl_prototype_object,
     class_decl_prototype_value, class_decl_prototype_value_for_instance_class,
diff --git a/crates/perry-runtime/src/object/class_registry/parent_static.rs b/crates/perry-runtime/src/object/class_registry/parent_static.rs
index 805ecf7f08..3b10374631 100644
--- a/crates/perry-runtime/src/object/class_registry/parent_static.rs
+++ b/crates/perry-runtime/src/object/class_registry/parent_static.rs
@@ -336,7 +336,10 @@ pub extern "C" fn js_register_class_parent_dynamic(class_id: u32, mut parent_val
     // the CLASS_PROTOTYPE_OBJECTS map (the same #711/#809 vehicle), resolved
     // via `resolve_proto_chain_field`; the class_id parent edge above keeps
     // method/`new`/instanceof dispatch on the existing fast path.
-    if tag == POINTER_TAG {
+    // #11759 (c′): a later evaluation pins its parent on its own class object;
+    // the template's static parent stays the first evaluation's.
+    if tag == POINTER_TAG && !crate::object::class_value::class_value_is_first_evaluation(class_id)
+    {
         let ptr = crate::value::js_nanbox_get_pointer(parent_value) as *mut ObjectHeader;
         if !ptr.is_null() && js_object_get_class_id(ptr as *const ObjectHeader) != 0 {
             class_prototype_object_root_store(class_id, ptr);
@@ -531,12 +534,11 @@ pub(crate) fn template_dynamic_parent_value(class_id: u32) -> f64 {
     if class_id == 0 {
         return f64::from_bits(TAG_UNDEFINED);
     }
-    let dynamic_parent = CLASS_DYNAMIC_PARENT_VALUE.with(|table| {
-        let guard = table.read().unwrap();
-        guard.as_ref().and_then(|m| m.get(&class_id).copied())
-    });
-    if let Some(bits) = dynamic_parent {
-        return f64::from_bits(bits);
+    // #11759 (c′): a first evaluation keeps its static heritage.
+    if !crate::object::class_value::class_value_is_first_evaluation(class_id) {
+        if let Some(parent) = super::stashed_dynamic_parent_value(class_id) {
+            return parent;
+        }
     }
     // #5957/#806: no dynamic VALUE stashed — fall back to the STATIC
     // parent-id edge as a ClassRef. An `extends <call>(...)` mixin
diff --git a/crates/perry-runtime/src/object/class_registry/state.rs b/crates/perry-runtime/src/object/class_registry/state.rs
index 554c06e60b..7e98e2d914 100644
--- a/crates/perry-runtime/src/object/class_registry/state.rs
+++ b/crates/perry-runtime/src/object/class_registry/state.rs
@@ -681,6 +681,18 @@ crate::perry_thread_local! {
     pub static CLASS_DYNAMIC_PARENT_VALUE: RwLock<Option<HashMap<u32, u64>>> = RwLock::new(None);
 }
 
+/// The `js_register_class_parent_dynamic` stash for `class_id`: the parent
+/// value its latest evaluation registered.
+pub(crate) fn stashed_dynamic_parent_value(class_id: u32) -> Option<f64> {
+    CLASS_DYNAMIC_PARENT_VALUE.with(|table| {
+        let guard = table.read().unwrap();
+        guard
+            .as_ref()
+            .and_then(|m| m.get(&class_id).copied())
+            .map(f64::from_bits)
+    })
+}
+
 crate::perry_thread_local! {
     /// #6530: maps a template class_id to the raw NaN-boxed POINTER bits of the
     /// per-evaluation CLASS OBJECT the class statement materialized as (marked by
@@ -708,6 +720,13 @@ pub(crate) fn class_object_value_root_store(class_id: u32, obj_ptr: *mut ObjectH
     if class_id == 0 || obj_ptr.is_null() {
         return;
     }
+    // #11759 (c′): the class function object is the declaration's first
+    // evaluation, and a later evaluation is a class of its own. It never
+    // stands in for the template: `C.x` on the first evaluation and the
+    // `constructor` of its instances stay the first evaluation's.
+    if crate::object::class_value::class_value_is_first_evaluation(class_id) {
+        return;
+    }
     CLASS_OBJECT_EVER.store(true, std::sync::atomic::Ordering::Relaxed);
     let bits = crate::value::js_nanbox_pointer(obj_ptr as i64).to_bits();
     CLASS_OBJECT_VALUES.with(|table| {
diff --git a/crates/perry-runtime/src/object/class_value.rs b/crates/perry-runtime/src/object/class_value.rs
index 299d0babc9..cca15e6975 100644
--- a/crates/perry-runtime/src/object/class_value.rs
+++ b/crates/perry-runtime/src/object/class_value.rs
@@ -228,10 +228,32 @@ fn class_value_slot(class_id: u32) -> *mut *mut ClosureHeader {
     }
 }
 
+/// Capture slot of a class function object holding its evaluation state, an
+/// INT32. `0`: the object names the class's evaluations as a group, so a
+/// per-evaluation class object's static writes are mirrored into it (#6530).
+/// `1`: the object IS its declaration's first evaluation (#11759 (c′)), a
+/// class of its own; later evaluations never write into it. Generated code
+/// sets it when the first evaluation hands the shared class out.
+const CLASS_EVALUATION_STATE_SLOT: usize = crate::codegen_abi::CLASS_EVALUATION_STATE_CAPTURE;
+
+/// Is class `class_id`'s function object its declaration's first evaluation
+/// (see [`CLASS_EVALUATION_STATE_SLOT`])? A class whose function object was
+/// never minted has no evaluation to protect.
+pub(crate) fn class_value_is_first_evaluation(class_id: u32) -> bool {
+    class_value_cached(class_id).is_some_and(|closure| {
+        // SAFETY: a live class function object minted with two capture slots.
+        unsafe {
+            *crate::closure::closure_capture_slots_mut(closure).add(CLASS_EVALUATION_STATE_SLOT)
+                == crate::codegen_abi::CLASS_FIRST_EVALUATION_STATE
+        }
+    })
+}
+
 /// Allocate the class function object for `class_id`: a closure born in the
 /// old generation and pinned (it lives as long as the agent and never moves),
 /// code pointer
-/// [`js_class_constructor_called`], capture slot 0 = the class id as INT32.
+/// [`js_class_constructor_called`], capture slot 0 = the class id as INT32,
+/// capture slot 1 = its evaluation state ([`CLASS_EVALUATION_STATE_SLOT`]).
 ///
 /// Never collects: callers hold raw receiver pointers across the lookup, so
 /// the old-arena allocation runs under a [`crate::gc::GcSuppressScope`].
@@ -243,16 +265,17 @@ fn class_value_mint(class_id: u32) -> *mut ClosureHeader {
         "a class function object belongs to a compiled class id, never a builtin or synthetic band: {class_id:#x}"
     );
     let _no_collect = crate::gc::GcSuppressScope::new();
-    let payload = crate::closure::closure_payload_size(1);
+    let payload = crate::closure::closure_payload_size(2);
     let ptr = crate::arena::arena_alloc_gc_old_born_tenured(
         payload,
         std::mem::align_of::<ClosureHeader>(),
         crate::gc::GC_TYPE_CLOSURE,
     ) as *mut ClosureHeader;
     unsafe {
-        // GC_STORE_AUDIT(INIT): fresh class function object; the one capture
-        // is an INT32 class id and the props edge is null — pointer-free.
-        (*ptr).capture_count = 1;
+        // GC_STORE_AUDIT(INIT): fresh class function object; both captures
+        // are INT32s (class id, evaluation state) and the props edge is null —
+        // pointer-free.
+        (*ptr).capture_count = 2;
         (*ptr).shape_id = crate::closure::shape::function_class_shape();
         (*ptr).info = &CLASS_CONSTRUCTOR_INFO;
         (*ptr).props = std::ptr::null_mut();
@@ -260,6 +283,10 @@ fn class_value_mint(class_id: u32) -> *mut ClosureHeader {
             crate::closure::closure_capture_slots_mut(ptr),
             crate::value::INT32_TAG | class_id as u64,
         );
+        std::ptr::write(
+            crate::closure::closure_capture_slots_mut(ptr).add(CLASS_EVALUATION_STATE_SLOT),
+            crate::value::INT32_TAG,
+        );
         crate::gc::layout_init_pointer_free(ptr as *mut u8);
         // Born old AND pinned: the address is the class's identity for the
         // agent's life (compiled code keeps it in registers and allocas, the
diff --git a/crates/perry-runtime/src/object/field_get_set/class_object_props.rs b/crates/perry-runtime/src/object/field_get_set/class_object_props.rs
index 7e984702ca..94fdef20db 100644
--- a/crates/perry-runtime/src/object/field_get_set/class_object_props.rs
+++ b/crates/perry-runtime/src/object/field_get_set/class_object_props.rs
@@ -547,6 +547,14 @@ pub(super) unsafe fn instance_constructor_value(
     if let Some(v) = super::super::class_registry::class_object_value_for_cid(class_id) {
         return Some(JSValue::from_bits(v.to_bits()));
     }
+    // #11759 (c′): an instance of a later evaluation of a declaration whose
+    // first evaluation is the class function object reads `constructor` from
+    // its own evaluation's prototype (the generic walk).
+    if crate::object::class_value::class_value_is_first_evaluation(class_id)
+        && super::super::prototype_chain::object_static_prototype(obj as usize).is_some()
+    {
+        return None;
+    }
     // #5834: WeakMap/WeakSet instances carry a reserved class_id
     // (not a registered declared-class one), so none of the
     // arms below resolve them and `(new WeakMap()).constructor`
diff --git a/crates/perry-runtime/src/object/field_get_set/class_object_template.rs b/crates/perry-runtime/src/object/field_get_set/class_object_template.rs
index 4ec5646c77..b7b0abe48a 100644
--- a/crates/perry-runtime/src/object/field_get_set/class_object_template.rs
+++ b/crates/perry-runtime/src/object/field_get_set/class_object_template.rs
@@ -346,7 +346,16 @@ pub extern "C" fn js_class_evaluation_object(
     // body. A template recorded without heritage has none to read.
     let has_parent = template.is_none_or(|t| t.2);
     let parent = if has_parent {
-        crate::object::parent_static::template_dynamic_parent_value(template_class_id)
+        // #11759 (c′): when the template's class function object is the
+        // declaration's first evaluation, this is a later one: it pins the
+        // parent its own heritage registered, which the template no longer
+        // answers with (its class function object keeps the static heritage).
+        crate::object::class_value::class_value_is_first_evaluation(template_class_id)
+            .then(|| crate::object::class_registry::stashed_dynamic_parent_value(template_class_id))
+            .flatten()
+            .unwrap_or_else(|| {
+                crate::object::parent_static::template_dynamic_parent_value(template_class_id)
+            })
     } else {
         f64::from_bits(crate::value::TAG_UNDEFINED)
     };
diff --git a/crates/perry-runtime/src/object/field_set_by_name/write_helpers.rs b/crates/perry-runtime/src/object/field_set_by_name/write_helpers.rs
index 45a6955e9d..0f28b31886 100644
--- a/crates/perry-runtime/src/object/field_set_by_name/write_helpers.rs
+++ b/crates/perry-runtime/src/object/field_set_by_name/write_helpers.rs
@@ -62,7 +62,11 @@ pub(super) unsafe fn string_key_eq(key: *const crate::StringHeader, expected: &[
 /// rejected assignment never desyncs the ClassRef read path from the class
 /// object's real state. Internal `__perry_*` markers (the pinned-parent
 /// edge) stay object-local. Last-wins across evaluations of the same class
-/// statement, matching the established template-cid compromise.
+/// statement, matching the established template-cid compromise — except
+/// when the class function object is itself the declaration's first
+/// evaluation (#11759 (c′)): then it is a class of its own, compiled code
+/// reaches every later evaluation through its evaluated value, and a later
+/// evaluation's statics must never overwrite the first one's.
 pub(super) unsafe fn mirror_class_object_static_write(
     obj: *const ObjectHeader,
     key: *const crate::StringHeader,
@@ -71,6 +75,7 @@ pub(super) unsafe fn mirror_class_object_static_write(
     if !crate::object::is_class_object_ptr(obj as *const u8)
         || (*obj).class_id == 0
         || key.is_null()
+        || crate::object::class_value::class_value_is_first_evaluation((*obj).class_id)
     {
         return;
     }
diff --git a/crates/perry-runtime/src/object/instanceof/dynamic_dispatch.rs b/crates/perry-runtime/src/object/instanceof/dynamic_dispatch.rs
index eaa553fbee..13660d00fe 100644
--- a/crates/perry-runtime/src/object/instanceof/dynamic_dispatch.rs
+++ b/crates/perry-runtime/src/object/instanceof/dynamic_dispatch.rs
@@ -139,6 +139,19 @@ pub extern "C" fn js_instanceof_dynamic(value: f64, type_ref: f64) -> f64 {
     // ref) must fall through to the unresolved-RHS `TypeError` below
     // instead of being dispatched into `js_instanceof` as a bogus class id.
     if let Some(class_id) = class_ref_id(type_ref) {
+        // #11759 (c′): the class function object is the first evaluation of a
+        // declaration whose later evaluations share its template id. A value
+        // with an individually recorded prototype chain (an instance of a
+        // later evaluation) answers by its actual chain.
+        if crate::object::class_value::class_value_is_first_evaluation(class_id)
+            && super::prototype_chain::object_static_prototype(value_addr(value)).is_some()
+        {
+            return f64::from_bits(if ordinary_has_instance_prototype_walk(value, type_ref) {
+                crate::value::TAG_TRUE
+            } else {
+                TAG_FALSE
+            });
+        }
         return js_instanceof(value, class_id);
     }
     // #9502: a heap class object's template id identifies its code, not its
@@ -149,9 +162,15 @@ pub extern "C" fn js_instanceof_dynamic(value: f64, type_ref: f64) -> f64 {
         // without attaching an evaluated prototype. Retain that representation's
         // class-id check; a recorded prototype (a fact of the receiver's
         // shape) is authoritative.
-        if super::prototype_chain::object_static_prototype(value_addr(value)).is_none() {
-            let obj = crate::JSValue::from_bits(bits).as_pointer::<ObjectHeader>();
-            return js_instanceof(value, js_object_get_class_id(obj));
+        let obj = crate::JSValue::from_bits(bits).as_pointer::<ObjectHeader>();
+        let template = js_object_get_class_id(obj);
+        // #11759 (c′): when the template's class function object is the
+        // declaration's first evaluation, a template-id instance belongs to
+        // THAT evaluation, never to this later one: the chain decides.
+        if super::prototype_chain::object_static_prototype(value_addr(value)).is_none()
+            && !crate::object::class_value::class_value_is_first_evaluation(template)
+        {
+            return js_instanceof(value, template);
         }
         return f64::from_bits(if ordinary_has_instance_prototype_walk(value, type_ref) {
             crate::value::TAG_TRUE
diff --git a/crates/perry-transform/src/inline/call_inliner.rs b/crates/perry-transform/src/inline/call_inliner.rs
index 37eb94a19c..2fb2927500 100644
--- a/crates/perry-transform/src/inline/call_inliner.rs
+++ b/crates/perry-transform/src/inline/call_inliner.rs
@@ -373,7 +373,10 @@ pub fn inline_calls_in_stmts(
                 local_types.insert(*id, class_name.clone());
             }
             // Also check if init is a New expression
-            if let Some(Expr::New { class_name, .. }) = init {
+            if let Some(class_name) = init
+                .as_ref()
+                .and_then(super::exact_receivers::constructed_class)
+            {
                 local_types.insert(*id, class_name.clone());
             }
         }
diff --git a/crates/perry-transform/src/inline/exact_receivers.rs b/crates/perry-transform/src/inline/exact_receivers.rs
index 53b235119b..d755cd7e6d 100644
--- a/crates/perry-transform/src/inline/exact_receivers.rs
+++ b/crates/perry-transform/src/inline/exact_receivers.rs
@@ -280,6 +280,33 @@ pub fn intersect_exact_receiver_facts(
         .collect()
 }
 
+/// The class `init` constructs: `new C()`, or #11759 (c′)'s `new C()`
+/// through a declaration that may be evaluated more than once, which builds
+/// the first evaluation statically and a later one by value. Every evaluation
+/// runs C's constructor and carries C's declaration-time method table on its
+/// prototype; a write to any evaluation's `prototype` goes through the
+/// binding, which `collect_module_prototype_facts` counts as opaque.
+pub(crate) fn constructed_class(init: &Expr) -> Option<&String> {
+    match init {
+        Expr::New { class_name, .. } => Some(class_name),
+        Expr::Conditional {
+            condition,
+            then_expr,
+            ..
+        } if matches!(condition.as_ref(), Expr::ClassIsFirstEvaluation { .. }) => {
+            match then_expr.as_ref() {
+                Expr::ClassEnvStamp { instance, .. } => match instance.as_ref() {
+                    Expr::New { class_name, .. } => Some(class_name),
+                    _ => None,
+                },
+                Expr::New { class_name, .. } => Some(class_name),
+                _ => None,
+            }
+        }
+        _ => None,
+    }
+}
+
 pub fn apply_exact_receiver_stmt_effect(stmt: &Stmt, facts: &mut ExactReceiverFacts) {
     match stmt {
         Stmt::Let { id, init, .. } => {
@@ -287,7 +314,7 @@ pub fn apply_exact_receiver_stmt_effect(stmt: &Stmt, facts: &mut ExactReceiverFa
             if let Some(init) = init {
                 invalidate_exact_receivers_for_expr(init, facts);
                 kill_referenced_exact_receivers(init, facts);
-                if let Expr::New { class_name, .. } = init {
+                if let Some(class_name) = constructed_class(init) {
                     facts.insert(
                         *id,
                         ExactReceiverFact {
diff --git a/crates/perry-transform/src/inline/factory_specialize.rs b/crates/perry-transform/src/inline/factory_specialize.rs
index 17500e1ca7..1b130ff7a3 100644
--- a/crates/perry-transform/src/inline/factory_specialize.rs
+++ b/crates/perry-transform/src/inline/factory_specialize.rs
@@ -1163,6 +1163,8 @@ pub fn fresh_export_dynamic_heritage_factories(module: &mut Module) {
             computed_statics: Vec::new(),
             static_init_order: Vec::new(),
             captured_args: Vec::new(),
+            shared_first_evaluation: None,
+            evaluated_parent: None,
         });
     }
 }
diff --git a/crates/perry-transform/src/inline/substitute.rs b/crates/perry-transform/src/inline/substitute.rs
index 523874f803..2276e4699e 100644
--- a/crates/perry-transform/src/inline/substitute.rs
+++ b/crates/perry-transform/src/inline/substitute.rs
@@ -472,6 +472,8 @@ mod tests {
             computed_statics: vec![("value".into(), Expr::LocalGet(7))],
             static_init_order: vec![],
             captured_args: vec![Expr::LocalGet(7), Expr::LocalGet(8)],
+            shared_first_evaluation: None,
+            evaluated_parent: None,
         }
     }
 
diff --git a/crates/perry/tests/issue_11759_class_first_evaluation.rs b/crates/perry/tests/issue_11759_class_first_evaluation.rs
new file mode 100644
index 0000000000..837c432bc9
--- /dev/null
+++ b/crates/perry/tests/issue_11759_class_first_evaluation.rs
@@ -0,0 +1,317 @@
+//! #11759 (c′): a class declaration that may be evaluated more than once keeps
+//! the shared class for its FIRST evaluation and creates a fresh class object
+//! for each later one. The check is one load of the template's flag, a compare
+//! and a branch, and it is emitted only where `lower::run_once` cannot prove
+//! the definition runs once.
+use std::path::PathBuf;
+use std::process::Command;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+const FLAG: &str = "@perry_class_first_eval.";
+const FRESH: &str = "call i64 @js_class_evaluation_object(";
+
+struct TestDir(PathBuf);
+impl Drop for TestDir {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
+
+fn compile(source: &str) -> (String, String) {
+    static NEXT: AtomicUsize = AtomicUsize::new(0);
+    let dir = TestDir(std::env::temp_dir().join(format!(
+        "perry-11759-{}-{}",
+        std::process::id(),
+        NEXT.fetch_add(1, Ordering::Relaxed)
+    )));
+    std::fs::create_dir_all(&dir.0).unwrap();
+    let entry = dir.0.join("main.ts");
+    let binary = dir.0.join("main_bin");
+    std::fs::write(&entry, source).unwrap();
+    let build = Command::new(env!("CARGO_BIN_EXE_perry"))
+        .current_dir(&dir.0)
+        .args([
+            "compile",
+            "--no-auto-optimize",
+            "--no-cache",
+            "--trace",
+            "llvm",
+        ])
+        .arg(&entry)
+        .arg("-o")
+        .arg(&binary)
+        .output()
+        .unwrap();
+    assert!(
+        build.status.success(),
+        "compile failed: {}",
+        String::from_utf8_lossy(&build.stderr)
+    );
+    let ir = std::fs::read_to_string(dir.0.join(".perry-trace/llvm/main_ts.ll")).unwrap();
+    let run = Command::new(&binary).output().unwrap();
+    assert!(
+        run.status.success(),
+        "execution failed: {}",
+        String::from_utf8_lossy(&run.stderr)
+    );
+    (ir, String::from_utf8(run.stdout).unwrap())
+}
+
+/// The lines that use `needle` outside its own definition.
+fn uses(ir: &str, needle: &str) -> usize {
+    ir.lines()
+        .filter(|line| line.contains(needle) && !line.starts_with('@'))
+        .count()
+}
+
+#[test]
+fn a_repeatable_declaration_tests_the_template_flag_and_its_later_evaluations_are_fresh() {
+    let (ir, stdout) = compile(
+        r#"
+function f() { class K { static n = 1; } return K; }
+const a: any = f(), b: any = f(), c: any = f();
+b.n = 2;
+console.log(a === b, b === c, a.n, b.n, c.n, new b() instanceof a, new c() instanceof c);
+"#,
+    );
+    assert_eq!(stdout, "false false 1 2 1 false true\n");
+    assert!(
+        ir.lines()
+            .any(|line| line.starts_with(FLAG) && line.contains("global i64 0")),
+        "the template flag is defined once per module:\n{ir}"
+    );
+    assert!(
+        uses(&ir, FLAG) >= 2,
+        "the evaluation loads and sets the flag"
+    );
+    assert!(
+        uses(&ir, FRESH) >= 1,
+        "a later evaluation is a fresh class object"
+    );
+}
+
+#[test]
+fn a_module_top_loop_body_declaration_is_repeatable() {
+    let (ir, stdout) = compile(
+        r#"
+const cs: any[] = [];
+for (let i = 0; i < 3; i++) { class L { static k = i; } cs.push(L); }
+console.log(cs[0] === cs[1], cs[1] === cs[2], cs.map((c: any) => c.k).join());
+"#,
+    );
+    assert_eq!(stdout, "false false 0,1,2\n");
+    assert!(uses(&ir, FLAG) >= 2, "a loop body is not run once:\n{ir}");
+}
+
+#[test]
+fn a_definition_proven_to_run_once_emits_no_check() {
+    let (ir, stdout) = compile(
+        r#"
+const once: any = (function () { class O { static tag = "o"; } return O; })();
+let blockClass: any;
+{ class B { static tag = "b"; } blockClass = B; }
+function wrapper() { class W { static tag = "w"; } return W; }
+const w: any = wrapper();
+console.log(once.tag, new once() instanceof once, blockClass.tag, w.tag);
+"#,
+    );
+    assert_eq!(stdout, "o true b w\n");
+    assert_eq!(
+        uses(&ir, FLAG),
+        0,
+        "an IIFE body, a module-top block and a function called once from module top run once:\n{ir}"
+    );
+    assert!(
+        !ir.contains(FLAG),
+        "no flag is defined for a run-once class"
+    );
+    assert_eq!(
+        uses(&ir, FRESH),
+        0,
+        "a run-once class is never a fresh class object"
+    );
+}
+
+#[test]
+fn an_esbuild_lazy_wrapper_keeps_its_one_class() {
+    // esbuild's `__esm` arrow runs its body at most once, which only the
+    // runtime can see: the flag check is emitted and its first (only)
+    // evaluation is the shared class.
+    let (ir, stdout) = compile(
+        r#"
+var __esm = (fn: any, res?: any) => function () {
+  return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
+};
+let E1: any;
+const init_x: any = __esm({ "x.ts"() { class EK { static q = 3; } E1 = EK; } });
+init_x();
+const e1 = E1;
+init_x();
+console.log(e1 === E1, E1.q, new E1() instanceof e1);
+"#,
+    );
+    assert_eq!(stdout, "true 3 true\n");
+    assert!(
+        uses(&ir, FLAG) >= 2,
+        "the wrapper body is not provably run once:\n{ir}"
+    );
+}
+
+/// A loop that cannot rebind the class binding tests the first evaluation
+/// once, before the loop, and lowers itself twice: the first-evaluation copy
+/// holds the static `new` (which scalar replacement then sees) and the static
+/// field read, the later-evaluation copy the by-value forms.
+#[test]
+fn a_loop_over_a_repeatable_class_tests_its_first_evaluation_once() {
+    let (ir, out) = compile(
+        r#"
+function run(n: number) {
+  class C { x: number; constructor(x: number) { this.x = x; } static s = 3; }
+  let t = 0;
+  for (let i = 0; i < n; i++) { const c = new C(i); t += c.x + C.s; }
+  return t;
+}
+console.log(run(3));
+console.log(run(3));
+"#,
+    );
+    assert_eq!(out, "12\n12\n");
+    assert!(
+        ir.contains("classloop.first"),
+        "the loop is versioned:\n{ir}"
+    );
+    assert!(
+        ir.contains("classloop.later"),
+        "the loop is versioned:\n{ir}"
+    );
+}
+
+/// A loop that rebinds the class binding keeps its per-use tests: the
+/// binding can stop holding the first evaluation mid-loop.
+#[test]
+fn a_loop_that_rebinds_the_class_keeps_its_per_use_tests() {
+    let (ir, out) = compile(
+        r#"
+function run(k: number) {
+  class C { static s = 1; }
+  let r = 0;
+  for (let i = 0; i < 2; i++) {
+    r += C.s;
+    if (k) { (C as any) = class { static s = 10; }; }
+  }
+  return r;
+}
+console.log(run(1));
+console.log(run(0));
+"#,
+    );
+    assert_eq!(out, "11\n2\n");
+    assert!(
+        !ir.contains("classloop.first"),
+        "a rebinding loop is not versioned:\n{ir}"
+    );
+}
+
+/// The bodies of every emitted copy of the module function `name`.
+fn function_bodies(ir: &str, name: &str) -> String {
+    let mut out = String::new();
+    let mut inside = false;
+    for line in ir.lines() {
+        if line.starts_with("define ") {
+            inside = line.contains(&format!("@perry_fn_main_ts__{name}("))
+                || line.contains(&format!("@perry_fn_main_ts__{name}$"));
+        }
+        if inside {
+            out.push_str(line);
+            out.push('\n');
+            if line == "}" {
+                inside = false;
+            }
+        }
+    }
+    out
+}
+
+/// Which fields of an instance hold a Number is a fact of the class
+/// template, so `t += c.x` keeps `t` a Number in both copies of a versioned
+/// loop: the first-evaluation copy reads the scalar of the replaced `new`, the
+/// later-evaluation copy reads a later evaluation's instance, and neither
+/// routes the add through the dynamic `+`.
+#[test]
+fn an_accumulator_over_a_repeatable_class_field_stays_a_number() {
+    let (ir, out) = compile(
+        r#"
+function run(n: number) {
+  class C { x: number; constructor(x: number) { this.x = x * 0.5; } }
+  let t = 0;
+  for (let i = 0; i < n; i++) { const c = new C(i); t += c.x; }
+  return t;
+}
+console.log(run(4));
+console.log(run(4));
+"#,
+    );
+    assert_eq!(out, "3\n3\n");
+    let run = function_bodies(&ir, "run");
+    assert!(
+        run.contains("classloop.later"),
+        "the loop is versioned:\n{run}"
+    );
+    assert!(
+        !run.contains("@js_dynamic_string_or_number_add("),
+        "the accumulator is a Number in both copies:\n{run}"
+    );
+}
+
+/// The rest of a function body after `const c = new C()` tests the first
+/// evaluation once and lowers twice; in the first-evaluation copy `c` is an
+/// instance of the shared class, so its method call is the direct one. A
+/// later evaluation still runs its own methods.
+#[test]
+fn the_rest_of_a_body_after_new_tests_the_first_evaluation_once() {
+    let (ir, out) = compile(
+        r#"
+function run(n: number, k: number) {
+  class C { x: number; constructor(x: number) { this.x = x; } m() { return this.x + k; } }
+  const c = new C(1);
+  let t = 0;
+  for (let i = 0; i < n; i++) { t += c.m(); }
+  return t;
+}
+console.log(run(3, 1));
+console.log(run(3, 2));
+"#,
+    );
+    assert_eq!(out, "6\n9\n");
+    let run = function_bodies(&ir, "run");
+    assert!(
+        run.contains("classtail.first"),
+        "the tail is versioned:\n{run}"
+    );
+    assert!(
+        run.contains("classtail.later"),
+        "the tail is versioned:\n{run}"
+    );
+}
+
+/// A tail that defines code (here a closure) is not versioned: its copies
+/// would define it twice.
+#[test]
+fn a_tail_that_defines_a_closure_is_not_versioned() {
+    let (ir, out) = compile(
+        r#"
+function run(k: number) {
+  class C { x: number; constructor(x: number) { this.x = x; } }
+  const c = new C(k);
+  const f = () => c.x + 1;
+  return f;
+}
+const fs = [run(1), run(2)];
+console.log(fs[0]());
+console.log(fs[1]());
+"#,
+    );
+    assert_eq!(out, "2\n3\n");
+    let run = function_bodies(&ir, "run");
+    assert!(!run.contains("classtail.first"), "not versioned:\n{run}");
+}
diff --git a/test-files/test_gap_11759_class_decl_evaluations_gc.ts b/test-files/test_gap_11759_class_decl_evaluations_gc.ts
new file mode 100644
index 0000000000..af2a022612
--- /dev/null
+++ b/test-files/test_gap_11759_class_decl_evaluations_gc.ts
@@ -0,0 +1,38 @@
+// #11759: later evaluations of a class declaration are heap class objects.
+// Create and drop many of them under allocation pressure (moving minors and
+// full collections) and check each stays intact: its statics, prototype,
+// captured name and instances.
+
+function make(n: number) {
+  class Item {
+    static serial = n;
+    static all: Item[] = [];
+    v: number;
+    label: string;
+    constructor(v: number) { this.v = v; this.label = "item" + v; Item.all.push(this); }
+    twice() { return this.v * 2 + Item.serial; }
+  }
+  return Item;
+}
+
+function churn(k: number): number {
+  let s = 0;
+  for (let i = 0; i < 200; i++) { const o = { a: i, b: "s" + i, c: [i, k] }; s += o.c.length; }
+  return s;
+}
+
+const kept: any[] = [];
+let ok = true;
+for (let i = 0; i < 400; i++) {
+  const C: any = make(i);
+  const a = new C(i), b = new C(i + 1);
+  churn(i);
+  if (a.twice() !== i * 2 + i || b.label !== "item" + (i + 1) || C.all.length !== 2) ok = false;
+  if (!(a instanceof C) || (kept.length > 0 && a instanceof kept[kept.length - 1])) ok = false;
+  if (i % 40 === 0) kept.push(C);
+}
+churn(1);
+const sums = kept.map((C: any) => C.serial + ":" + C.all.length + ":" + new C(1).twice()).join(",");
+console.log("ok", ok, kept.length);
+console.log("kept", sums);
+console.log("distinct", new Set(kept).size, kept[0] === make(0));
diff --git a/test-files/test_gap_11759_class_decl_first_evaluation_versions.ts b/test-files/test_gap_11759_class_decl_first_evaluation_versions.ts
new file mode 100644
index 0000000000..b126b5cfb0
--- /dev/null
+++ b/test-files/test_gap_11759_class_decl_first_evaluation_versions.ts
@@ -0,0 +1,49 @@
+// #11759 (c′): code after a repeatable class declaration is lowered twice,
+// once for its first evaluation (the shared class) and once for later ones.
+// Both versions must behave identically: numeric fields, captured values,
+// methods, instanceof, and an instance created before a loop.
+function make(k: number, n: number) {
+  class C {
+    x: number;
+    y = k * 2;
+    constructor(x: number) { this.x = x + k; }
+    m() { return this.x + this.y; }
+    static s = k;
+  }
+  const c0 = new C(1);
+  let t = 0;
+  for (let i = 0; i < n; i++) {
+    const c = new C(i);
+    t += c.x + c.y;
+    t += c0.m();
+  }
+  for (let i = 0; i < n; i++) { t += C.s; }
+  return [t, c0.m(), c0 instanceof C, C.s, typeof c0.x];
+}
+console.log(JSON.stringify(make(1, 3)));
+console.log(JSON.stringify(make(2, 3)));
+console.log(JSON.stringify(make(0.5, 4)));
+
+// A field that holds a string on every evaluation stays a string.
+function strings(tag: string) {
+  class S { v: string; constructor(v: string) { this.v = v + tag; } }
+  let out = "";
+  for (let i = 0; i < 3; i++) { const s = new S(String(i)); out += s.v; }
+  const s0 = new S("!");
+  for (let i = 0; i < 2; i++) { out += s0.v; }
+  return out;
+}
+console.log(strings("a"));
+console.log(strings("b"));
+
+// The binding is rebound in the tail: no versioning, the per-use test stays.
+function rebinding(k: number) {
+  let K = class { v = 1; };
+  class D { w: number; constructor() { this.w = k; } }
+  const d = new D();
+  let r = d.w;
+  if (k > 1) { K = class { v = 2; }; }
+  r += new K().v;
+  return r;
+}
+console.log(rebinding(1), rebinding(2), rebinding(3));
diff --git a/test-files/test_gap_11759_class_decl_fresh_per_evaluation.ts b/test-files/test_gap_11759_class_decl_fresh_per_evaluation.ts
new file mode 100644
index 0000000000..0f83ff5220
--- /dev/null
+++ b/test-files/test_gap_11759_class_decl_fresh_per_evaluation.ts
@@ -0,0 +1,74 @@
+// #11759: a class DECLARATION evaluated more than once is a fresh class per
+// evaluation, as in node. Perry keeps the shared (static) class for the
+// FIRST evaluation and gives every later evaluation its own class object
+// (option (c′)); each line below compares the two against node.
+
+function f() { class K {} return K; }
+console.log("fn-identity", f() === f());
+const a: any = f(), b: any = f();
+a.prototype.x = 1;
+console.log("proto-isolation", new b().x, new a().x, a.prototype === b.prototype);
+console.log("instanceof-across", new a() instanceof b, new b() instanceof a, new a() instanceof a, new b() instanceof b);
+console.log("getproto", Object.getPrototypeOf(new b()) === b.prototype, Object.getPrototypeOf(new a()) === a.prototype);
+console.log("ctor", new b().constructor === b, new a().constructor === a, new b().constructor === a);
+console.log("name", a.name, b.name, typeof b, a.length, b.length);
+console.log("string", String(a), String(b));
+
+// Statics: each evaluation owns its own, including through the class name
+// and `this` inside static methods.
+function h() {
+  class T { static count = 0; static make() { T.count++; return new T(); } }
+  return T;
+}
+const h1: any = h(), h2: any = h();
+h1.make(); h1.make(); h2.make();
+console.log("static-count", h1.count, h2.count);
+console.log("make-instanceof", h2.make() instanceof h2, h2.make() instanceof h1, h1.make() instanceof h1);
+function hs() { class U { static tag = "u"; static who() { return this.tag; } } return U; }
+const u1: any = hs(), u2: any = hs();
+u1.tag = "changed";
+console.log("static-this", u1.who(), u2.who());
+function del() { class D { static z = 1; static m() { return 2; } } return D; }
+const d1: any = del(), d2: any = del();
+delete d2.z;
+delete d1.m;
+console.log("delete", d1.z, d2.z, typeof d1.m, typeof d2.m);
+console.log("own-names", Object.getOwnPropertyNames(d1).sort().join(), Object.getOwnPropertyNames(d2).sort().join());
+
+// Captured values and the class's own name inside its members.
+function mk(tag: string) {
+  class S { static t = tag; static n = 0; static inc() { return ++S.n; } who() { return S.t; } }
+  S.prototype.extra = function () { return "x" + S.t; };
+  return S;
+}
+const s1: any = mk("a"), s2: any = mk("b"), s3: any = mk("c");
+s1.inc(); s1.inc(); s2.inc();
+console.log("captures", s1.t, s2.t, s3.t, s1.n, s2.n, s3.n);
+console.log("members", new s1().who(), new s2().who(), new s3().who(), new s1().extra(), new s3().extra());
+console.log("proto-patch-isolated", s1.prototype.extra === s2.prototype.extra);
+function selfref() {
+  class R { static made = 0; clone() { R.made++; return new R(); } }
+  return R;
+}
+const r1: any = selfref(), r2: any = selfref();
+const c1 = new r1().clone(), c2 = new r2().clone();
+console.log("selfref", c1 instanceof r1, c1 instanceof r2, c2 instanceof r2, c2 instanceof r1, r1.made, r2.made);
+
+// Instance fields and accessors are per evaluation too.
+function fld() { class P { x = 1; y = 2; get s() { return this.x + this.y; } } return P; }
+const p1 = new (fld() as any)(), p2 = new (fld() as any)();
+console.log("fields", p1.s, p2.s, Object.keys(p1).join(), Object.keys(p2).join());
+
+// A definition that runs once (an IIFE) has one class, as in node.
+const once: any = (function () { class O { static tag = "o"; } return O; })();
+console.log("iife", once.tag, new once() instanceof once);
+
+// Many evaluations: every one distinct and self-consistent.
+function many() { class M { m() { return 1; } } return M; }
+let ok = true;
+const firstM = many();
+for (let i = 0; i < 50; i++) {
+  const M: any = many();
+  if (M === firstM || !(new M() instanceof M) || new M() instanceof firstM || new M().m() !== 1) ok = false;
+}
+console.log("many", ok);
diff --git a/test-files/test_gap_11759_class_decl_loop_extends_wrapper.ts b/test-files/test_gap_11759_class_decl_loop_extends_wrapper.ts
new file mode 100644
index 0000000000..b6c93c431e
--- /dev/null
+++ b/test-files/test_gap_11759_class_decl_loop_extends_wrapper.ts
@@ -0,0 +1,75 @@
+// #11759: class declarations in a module-top loop body, `extends` of an
+// evaluated class, instanceof across evaluations, and an esbuild-style lazy
+// `__esm` wrapper whose body runs once (it keeps one class).
+
+const top: any[] = [];
+for (let i = 0; i < 4; i++) {
+  class L { static k = i; v() { return i; } }
+  top.push(L);
+}
+console.log("loop-distinct", top[0] === top[1], top[2] === top[3]);
+console.log("loop-statics", top.map((c: any) => c.k).join(), top.map((c: any) => new c().v()).join());
+console.log("loop-instanceof", new top[3]() instanceof top[0], new top[0]() instanceof top[3], new top[3]() instanceof top[3]);
+
+// `extends` of a class evaluated in the same body follows that evaluation.
+function chain() {
+  class P { p() { return "p"; } }
+  class Q extends P { q() { return "q" + this.p(); } }
+  return [P, Q];
+}
+const [P1, Q1]: any = chain(), [P2, Q2]: any = chain();
+console.log("extends", P1 === P2, Q1 === Q2, new Q2().q(), new Q1().q());
+console.log("extends-instanceof", new Q2() instanceof P2, new Q2() instanceof P1, new Q1() instanceof P1, new Q1() instanceof P2);
+console.log("extends-proto", Object.getPrototypeOf(Q2) === P2, Object.getPrototypeOf(Q1) === P1, Object.getPrototypeOf(Q2.prototype) === P2.prototype);
+
+// A module-level parent shared by every evaluation of the subclass.
+class Base { hi() { return "hi"; } }
+function sub() { class D extends Base { static s = 1; } return D; }
+const d1: any = sub(), d2: any = sub();
+d2.s = 2;
+console.log("ext-base", d1 === d2, new d1().hi(), new d2() instanceof Base, new d2() instanceof d1, d1.s, d2.s);
+
+// esbuild's lazy ESM wrapper: the init arrow runs its body at most once.
+var __esm = (fn: any, res?: any) => function () {
+  return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
+};
+let E1: any;
+const init_x: any = __esm({ "x.ts"() { class EK { static q = 3; } E1 = EK; } });
+init_x();
+const e1 = E1;
+init_x();
+console.log("esm", e1 === E1, E1.q, new E1() instanceof e1);
+
+// A CommonJS-style factory body called twice.
+function factory(exports: any) { class C { static id = Math.random(); } exports.C = C; return exports; }
+const m1 = factory({}), m2 = factory({});
+console.log("cjs-twice", m1.C === m2.C, m1.C.id === m2.C.id, new m1.C() instanceof m2.C);
+
+// A three-level chain declared in one body, evaluated three times: super
+// calls, super method calls, inherited statics and every cross-evaluation
+// instanceof.
+function chain3(tag: string) {
+  class A { static kind = "A" + tag; a: string; constructor() { this.a = tag; } who() { return "A" + this.a; } }
+  class B extends A { b = 1; who() { return "B" + super.who(); } }
+  class C extends B { static extra = 2; who() { return "C" + super.who(); } }
+  return { A, B, C };
+}
+const k1: any = chain3("1"), k2: any = chain3("2"), k3: any = chain3("3");
+for (const k of [k1, k2, k3]) {
+  const c = new k.C();
+  console.log("chain3", c.who(), c.b, k.C.kind, k.C.extra, c instanceof k.A, c instanceof k.B,
+    Object.getPrototypeOf(k.C) === k.B, Object.getPrototypeOf(k.B) === k.A,
+    Object.getPrototypeOf(k.C.prototype) === k.B.prototype, c.constructor === k.C);
+}
+console.log("chain3-cross", new k2.C() instanceof k1.A, new k1.C() instanceof k2.B, new k3.B() instanceof k3.A,
+  k1.C === k2.C, k1.A === k3.A);
+
+// A subclass declared in a nested function, extending the enclosing body's class.
+function outer(n: number) {
+  class Base2 { n = n; }
+  function inner() { class Sub2 extends Base2 { twice() { return this.n * 2; } } return Sub2; }
+  return [Base2, inner(), inner()];
+}
+const [ob1, os1, os1b]: any = outer(1), [ob2, os2]: any = outer(2);
+console.log("nested-extends", new os1().twice(), new os2().twice(), new os2() instanceof ob2, new os2() instanceof ob1,
+  new os1b() instanceof ob1, os1 === os1b, Object.getPrototypeOf(os2) === ob2);