feat(inspector): attach Chrome DevTools to Web Worker isolates

Workers were invisible to the debugger: the inspector only served the
main isolate and even dropped worker console output on the floor.
DevTools discovers extra isolates through the Target domain with
flat-session multiplexing, so implement that surface in the runtime:

- Add WorkerInspectorClient: a per-worker V8Inspector + session that
  lives entirely on the worker's thread. Incoming CDP messages queue
  through a dedicated CFRunLoopSource on the worker's runloop; while
  paused at a breakpoint a nested loop on the worker thread pumps the
  same queue without re-entering the runloop, so postMessage deliveries
  stay queued during a pause (matching Chrome's semantics).
- Turn JsV8InspectorClient into the root session + router: handle
  Target.setAutoAttach natively (announce workers via
  Target.attachedToTarget, detach on death), route messages carrying a
  top-level sessionId to the worker's thread directly from the socket
  thread, and make the frontend sender thread-safe. Routing off the
  socket thread means a worker stays debuggable while the main isolate
  is paused, and vice versa.
- Debugger.pause for a busy worker uses RequestInterrupt keyed by
  workerId, so a late-firing interrupt after worker death is a no-op.
  This also fixes the main-session fast path, which used to interrupt
  the main isolate for a pause aimed at any session.
- Serve Network.loadNetworkResource and IO.read/IO.close on the socket
  thread for any session (sessionId echoed), so worker source maps
  load too.
- Route worker console.* to the worker's own inspector and deliver
  through V8ConsoleMessageStorage::addMessage instead of the live-only
  runtime agent path: messages logged before the frontend attaches (or
  before Runtime.enable reaches a session) are stored and replayed as
  console history. Applies to the main isolate as well.
- Name execution contexts ("main" / worker script url) so the DevTools
  console context selector rows are labeled and selectable.
- Worker lifecycle: inspector is created on the worker thread before
  RunModule (debug builds only), terminate() kicks a paused worker out
  of its nested pause loop, teardown unregisters the target before the
  isolate is disposed, and frontend reconnects reset worker sessions.

waitForDebuggerOnStart (pause new workers before their first line) is
left as future work; workers currently announce waitingForDebugger:
false.

Author: edusperoni

NativeScript/inspector/JsV8InspectorClient.h

@@ -5,6 +5,7 @@
 
 #include <functional>
 #include <map>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -15,6 +16,8 @@
 
 namespace v8_inspector {
 
+class WorkerInspectorClient;
+
 class JsV8InspectorClient : V8InspectorClient, V8Inspector::Channel {
  public:
   JsV8InspectorClient(tns::Runtime* runtime);
@@ -23,6 +26,20 @@ class JsV8InspectorClient : V8InspectorClient, V8Inspector::Channel {
   void disconnect();
   void dispatchMessage(const std::string& message);
 
+  // The single instance debugging the main isolate (created when IsDebug);
+  // also acts as the router for worker sessions. Null in release builds.
+  static JsV8InspectorClient* GetInstance();
+
+  // Thread-safe write to the connected frontend (no-op when disconnected).
+  void SendToFrontend(const std::string& message);
+
+  // Worker targets (Chrome DevTools Target domain, flat-session mode).
+  // Register/Unregister are called on the worker's own thread.
+  void RegisterWorkerTarget(int workerId, WorkerInspectorClient* client);
+  void UnregisterWorkerTarget(int workerId);
+  // Called on a worker thread by the Debugger.pause interrupt.
+  void SchedulePauseInWorker(int workerId);
+
   // Overrides of V8Inspector::Channel
   void sendResponse(int callId, std::unique_ptr<StringBuffer> message) override;
   void sendNotification(std::unique_ptr<StringBuffer> message) override;
@@ -63,13 +80,39 @@ class JsV8InspectorClient : V8InspectorClient, V8Inspector::Channel {
 
   // Streams backing Network.loadNetworkResource responses, read by the
   // frontend through IO.read/IO.close (how Chrome DevTools fetches source
-  // maps from the target). Only touched from dispatchMessage (main thread).
+  // maps from the target). Served on the socket thread for any session;
+  // guarded by resourceStreamsMutex_.
   struct ResourceStream {
     std::string data;
     size_t offset = 0;
   };
   std::map<std::string, ResourceStream> resourceStreams_;
   int lastStreamId_ = 0;
+  std::mutex resourceStreamsMutex_;
+
+  // Worker targets announced to the frontend via Target.attachedToTarget,
+  // keyed by their flat-protocol sessionId. Guarded by workerTargetsMutex_;
+  // a registered client pointer stays valid until UnregisterWorkerTarget
+  // (which runs on the worker's own thread, before the client is deleted).
+  struct WorkerTarget {
+    int workerId;
+    WorkerInspectorClient* client;
+    bool announced = false;
+  };
+  std::map<std::string, WorkerTarget> workerTargets_;
+  std::mutex workerTargetsMutex_;
+  bool autoAttach_ = false;  // guarded by workerTargetsMutex_
+
+  static JsV8InspectorClient* instance_;
+
+  std::mutex senderMutex_;
+
+  // Routes a frontend message carrying a sessionId to its worker session
+  // (socket thread). msgId is -1 when the message has no id.
+  void RouteToWorker(const std::string& sessionId, const std::string& method,
+                     long long msgId, const std::string& message);
+  // Announces all not-yet-announced workers (after Target.setAutoAttach).
+  void AnnounceWorkerTargets();
 
   // Override of V8InspectorClient
   v8::Local<v8::Context> ensureDefaultContextInGroup(
@@ -90,10 +133,15 @@ class JsV8InspectorClient : V8InspectorClient, V8Inspector::Channel {
       const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // Source map delivery to Chrome DevTools (Network.loadNetworkResource + IO
-  // domain). V8's inspector doesn't implement these embedder domains.
-  void HandleLoadNetworkResource(int msgId, const std::string& url);
-  void HandleIORead(int msgId, const std::string& handle, int size);
-  void HandleIOClose(int msgId, const std::string& handle);
+  // domain). V8's inspector doesn't implement these embedder domains. The
+  // handlers are filesystem-only and thread-safe; they serve any session
+  // (sessionId is echoed in the reply when non-empty).
+  void HandleLoadNetworkResource(int msgId, const std::string& url,
+                                 const std::string& sessionId);
+  void HandleIORead(int msgId, const std::string& handle, int size,
+                    const std::string& sessionId);
+  void HandleIOClose(int msgId, const std::string& handle,
+                     const std::string& sessionId);
 
   // {N} specific helpers
   bool CallDomainHandlerFunction(v8::Local<v8::Context> context,