fix(locker): remove unnecessary Enter/Exit in Locker::new()

The Enter+Exit calls before Locker::Initialize() were a no-op.
The C++ Locker only checks IsLockedByCurrentThread() and
RestoreThread(), neither of which depends on the entry stack.
top_level_ is always true in our usage (no Locker/Unlocker nesting).

Also fix incorrect doc comments claiming the isolate must be in
"entered" state for raw::Locker::init().

Author: max-lt

src/isolate.rs

@@ -2533,48 +2533,19 @@ impl AsRef<Isolate> for Isolate {
 /// only on the thread where it was created. The underlying `UnenteredIsolate`
 /// implements `Send`, allowing it to be transferred between threads, but a new
 /// `Locker` must be created on each thread that needs to access the isolate.
-///
-/// # Panic Safety
-///
-/// `Locker::new()` is panic-safe. If a panic occurs during construction,
-/// the isolate will be properly exited via a drop guard.
 pub struct Locker<'a> {
   raw: std::mem::ManuallyDrop<crate::scope::raw::Locker>,
   isolate: &'a mut UnenteredIsolate,
 }
 
-/// Drop guard that calls `Isolate::Exit()` to undo the temporary Enter
-/// in `Locker::new()`. On the success path, the guard is dropped normally
-/// (calling Exit). On panic, Drop runs the same cleanup.
-struct IsolateExitGuard(*mut RealIsolate);
-
-impl Drop for IsolateExitGuard {
-  fn drop(&mut self) {
-    unsafe { v8__Isolate__Exit(self.0) };
-  }
-}
-
 impl<'a> Locker<'a> {
   /// Creates a new `Locker` for the given isolate.
   ///
   /// Acquires V8's per-isolate mutex. The isolate is **not** entered after
   /// construction — use [`Locker::enter()`] to get an [`IsolateScope`].
   pub fn new(isolate: &'a mut UnenteredIsolate) -> Self {
-    let isolate_ptr = isolate.cxx_isolate;
-
-    // Temporarily enter the isolate so the C++ Locker constructor sees
-    // IsCurrent()==true → sets top_level_=false → skips its own Enter/Exit.
-    unsafe { v8__Isolate__Enter(isolate_ptr.as_ptr()) };
-
-    // Guard: calls Exit on both success and panic paths.
-    let exit_guard = IsolateExitGuard(isolate_ptr.as_ptr());
-
-    // Initialize the C++ Locker (acts as pure mutex since top_level_=false).
     let mut raw = unsafe { crate::scope::raw::Locker::uninit() };
-    unsafe { raw.init(isolate_ptr) };
-
-    // Undo the temporary Enter — isolate is now locked but not entered.
-    drop(exit_guard);
+    unsafe { raw.init(isolate.cxx_isolate) };
 
     Self {
       raw: std::mem::ManuallyDrop::new(raw),

src/scope/raw.rs

@@ -236,8 +236,7 @@ impl Drop for AllowJavascriptExecutionScope {
 ///    the `Locker` is dropped. Dropping an uninitialized `Locker` is undefined
 ///    behavior because `Drop` will call the C++ destructor on garbage data.
 ///
-/// 2. **Isolate State**: The isolate passed to `init()` must be in "entered" state
-///    (via `v8::Isolate::Enter()`) before calling `init()`.
+/// 2. **Isolate Pointer**: The isolate pointer passed to `init()` must be valid.
 ///
 /// 3. **Single Initialization**: `init()` must be called exactly once. Calling it
 ///    multiple times is undefined behavior.
@@ -278,7 +277,7 @@ impl Locker {
   /// # Safety
   ///
   /// - This must be called exactly once after `uninit()`
-  /// - The isolate must be valid and in "entered" state
+  /// - The isolate pointer must be valid
   /// - The isolate must not be locked by another `Locker`
   /// - After this call, the `Locker` owns the V8 lock until dropped
   #[inline]