fix: concurrent isolate interleaving + warm reuse test

Add test_concurrent_pinned_interleaving that reproduces the
"PinnedRef and Context do not belong to the same Isolate" panic
when two execute_pinned tasks interleave on the same thread.

Fix incorrect comments about Locker safety in worker_pool.rs.
Bump runtime-v8 to v0.13.5 (IsolateGuard fix).
Bump to 0.13.8.

Author: max-lt

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "openworkers-runner"
-version = "0.13.7"
+version = "0.13.8"
 edition = "2024"
 license = "MIT"
 default-run = "openworkers-runner"
@@ -62,7 +62,7 @@ openworkers-core = { git = "https://github.com/openworkers/openworkers-core", ta
 openworkers-transform = { git = "https://github.com/openworkers/openworkers-transform", tag = "v0.1.0" }
 
 # Runtime backend (v8 only for now, others require older version of core)
-openworkers-runtime-v8 = { git = "https://github.com/openworkers/openworkers-runtime-v8", tag = "v0.13.4", optional = true, features = ["ptrcomp"] }
+openworkers-runtime-v8 = { git = "https://github.com/openworkers/openworkers-runtime-v8", tag = "v0.13.5", optional = true, features = ["ptrcomp"] }
 
 # WASM runtime (optional)
 # openworkers-runtime-wasm = { path = "../openworkers-runtime-wasm", optional = true }

Cargo.toml

@@ -73,8 +73,11 @@ impl SequentialWorkerPool {
 
                     // Persistent LocalSet enables interleaved execution:
                     // while one task awaits I/O, the LocalSet polls other tasks.
-                    // Each task holds its own V8 locker on its own isolate,
-                    // so there's no V8 contention — just cooperative scheduling.
+                    // Each task holds its own V8 locker on its own isolate.
+                    // NOTE: V8 Lockers call Isolate::Enter() which sets the
+                    // thread-local "current isolate". With cooperative scheduling,
+                    // multiple Lockers coexist and IsolateGuard (enter/exit per
+                    // V8 work block) ensures GetCurrent() returns the correct isolate.
                     rt.block_on(async {
                         let local = tokio::task::LocalSet::new();
 

src/worker_pool.rs

@@ -330,3 +330,65 @@ async fn test_warm_reuse_after_rejected_waituntil() {
     })
     .await;
 }
+
+// =============================================================================
+// Concurrent interleaving test (V8 Locker + spawn_local)
+// =============================================================================
+
+/// Two concurrent execute_pinned calls with async yields on the same thread.
+///
+/// This reproduces the V8 isolate interleaving bug:
+/// 1. Task A creates Locker(X), enters isolate X → GetCurrent() = X
+/// 2. Task A's worker does setTimeout(50ms) → event loop returns Pending
+/// 3. LocalSet polls Task B → Locker(Y) enters isolate Y → GetCurrent() = Y
+/// 4. Task B's worker also yields (setTimeout)
+/// 5. Task A resumes, creates HandleScope from X's raw pointer
+/// 6. ContextScope::new checks: X's pointer != GetCurrent() (Y) → PANIC
+///
+/// The panic: "PinnedRef and Context do not belong to the same Isolate"
+///
+/// This happens because v8::Locker calls Isolate::Enter() which sets the
+/// thread-local "current isolate". With cooperative scheduling (spawn_local),
+/// multiple Lockers coexist on the same thread with non-LIFO ordering.
+#[tokio::test]
+async fn test_concurrent_pinned_interleaving() {
+    init_pool();
+
+    run_local(|| async {
+        let script = Script::new(
+            r#"
+            addEventListener('fetch', (event) => {
+                // Force async yield: respond after a delay.
+                // During this delay, the event loop returns Pending,
+                // allowing the LocalSet to poll another task.
+                setTimeout(() => {
+                    event.respondWith(new Response('ok'));
+                }, 50);
+            });
+            "#,
+        );
+
+        // Spawn two concurrent tasks on the same LocalSet (same OS thread).
+        // They get DIFFERENT isolates because they have different worker_ids.
+        let handle_a = tokio::task::spawn_local({
+            let script = script.clone();
+            async move { pinned_fetch("interleave-a", 1, script).await }
+        });
+
+        let handle_b = tokio::task::spawn_local({
+            let script = script.clone();
+            async move { pinned_fetch("interleave-b", 1, script).await }
+        });
+
+        let (result_a, result_b) = tokio::join!(handle_a, handle_b);
+
+        let (status_a, body_a) = result_a.expect("Task A should not panic");
+        let (status_b, body_b) = result_b.expect("Task B should not panic");
+
+        assert_eq!(status_a, 200);
+        assert_eq!(body_a, "ok");
+        assert_eq!(status_b, 200);
+        assert_eq!(body_b, "ok");
+    })
+    .await;
+}