Fix closure capture for destructuring, catch params, and class decls

Remaining define_local() calls in destructuring patterns, catch
parameters, and class declarations did not check captured_names,
causing closures that capture these variables to fail at runtime.
Replace all with define_local_ext() + proper cell allocation, and
remove the now-unused define_local() method.

Co-Authored-By: Claude Opus 4.6 (1M context) <[e-mail]>

crates/js/src/compiler.rs

···
             .unwrap_or(false)
     }
 
-    /// Define a local variable.
-    fn define_local(&mut self, name: &str) -> Reg {
-        self.define_local_ext(name, false, false)
-    }
-
     /// Define a local variable with capture and const flags.
     fn define_local_ext(&mut self, name: &str, is_captured: bool, is_const: bool) -> Reg {
         let reg = self.alloc_reg();
···
                 // Bind the catch parameter if present.
                 if let Some(param) = &catch.param {
                     if let PatternKind::Identifier(name) = &param.kind {
-                        let local = fc.define_local(name);
-                        fc.builder.emit_reg_reg(Op::Move, local, catch_reg);
+                        let is_captured = fc.captured_names.contains(name.as_str());
+                        let local = fc.define_local_ext(name, is_captured, false);
+                        if is_captured {
+                            fc.builder.emit_reg(Op::NewCell, local);
+                            fc.builder.emit_reg_reg(Op::CellStore, local, catch_reg);
+                        } else {
+                            fc.builder.emit_reg_reg(Op::Move, local, catch_reg);
+                        }
                     }
                 }
 
···
 ) -> Result<(), JsError> {
     match &pattern.kind {
         PatternKind::Identifier(name) => {
-            let reg = fc.define_local(name);
-            fc.builder.emit_reg_reg(Op::Move, reg, src);
+            let is_captured = fc.captured_names.contains(name.as_str());
+            let reg = fc.define_local_ext(name, is_captured, false);
+            if is_captured {
+                fc.builder.emit_reg(Op::NewCell, reg);
+                fc.builder.emit_reg_reg(Op::CellStore, reg, src);
+            } else {
+                fc.builder.emit_reg_reg(Op::Move, reg, src);
+            }
         }
         PatternKind::Object {
             properties,
···
 
 fn compile_class_decl(fc: &mut FunctionCompiler, class_def: &ClassDef) -> Result<(), JsError> {
     let name = class_def.id.clone().unwrap_or_default();
-    let reg = fc.define_local(&name);
+    let is_captured = fc.captured_names.contains(name.as_str());
+    let reg = fc.define_local_ext(&name, is_captured, false);
+
+    // For captured classes, build the constructor into a temp register so we can
+    // set prototype methods on it before wrapping it in a cell.
+    let ctor_reg = if is_captured { fc.alloc_reg() } else { reg };
 
     // Find constructor or create empty one.
     let ctor = class_def.body.iter().find(|m| {
···
         if let ClassMemberKind::Method { value, .. } = &member.kind {
             let inner = compile_function_body_with_captures(fc, value)?;
             let func_idx = fc.builder.add_function(inner);
-            fc.builder.emit_reg_u16(Op::CreateClosure, reg, func_idx);
+            fc.builder
+                .emit_reg_u16(Op::CreateClosure, ctor_reg, func_idx);
         }
     } else {
         // No constructor: create a minimal function that returns undefined.
···
         empty.emit_reg(Op::LoadUndefined, r);
         empty.emit_reg(Op::Return, r);
         let func_idx = fc.builder.add_function(empty.finish());
-        fc.builder.emit_reg_u16(Op::CreateClosure, reg, func_idx);
+        fc.builder
+            .emit_reg_u16(Op::CreateClosure, ctor_reg, func_idx);
     }
 
     // Compile methods: set them as properties on the constructor's prototype.
···
                 fc.builder
                     .emit_reg_u16(Op::CreateClosure, method_reg, func_idx);
                 let name_idx = fc.builder.add_name(&method_name);
-                fc.builder.emit_set_prop_name(reg, name_idx, method_reg);
+                fc.builder
+                    .emit_set_prop_name(ctor_reg, name_idx, method_reg);
                 fc.free_reg(method_reg);
             }
             ClassMemberKind::Property { .. } => {
                 // Class fields are set in constructor; skip here.
             }
         }
+    }
+
+    if is_captured {
+        fc.builder.emit_reg(Op::NewCell, reg);
+        fc.builder.emit_reg_reg(Op::CellStore, reg, ctor_reg);
+        fc.free_reg(ctor_reg);
     }
 
     Ok(())