@nocobase/plugin-workflow-javascript 2.1.0-beta.10 → 2.1.0-beta.12

package/dist/node_modules/isolated-vm/src/module/transferable.cc

@@ -0,0 +1,268 @@
+#include "external_copy/external_copy.h"
+#include "isolate/class_handle.h"
+#include "isolate/util.h"
+#include "lib/lockable.h"
+#include "callback.h"
+#include "reference_handle.h"
+#include "transferable.h"
+#include "transferable.h"
+#include "external_copy_handle.h"
+#include <deque>
+
+using namespace v8;
+
+namespace ivm {
+namespace {
+
+// Shared state for `TransferablePromise` and `TransferablePromiseHolder`
+struct TransferablePromiseStateStruct {
+	std::shared_ptr<Transferable> value;
+	// This would be a good case for a unique_ptr version of RemoteHandle
+	std::deque<RemoteTuple<Promise::Resolver, v8::Context>> waiting;
+	bool did_throw = false;
+	bool resolved = false;
+};
+
+using TransferablePromiseState = lockable_t<TransferablePromiseStateStruct>;
+
+// Responsible for waiting for the promise in the isolate in which it was created
+class TransferablePromiseHolder final : public ClassHandle {
+	public:
+		explicit TransferablePromiseHolder(
+			std::shared_ptr<TransferablePromiseState> state,
+			TransferOptions transfer_options
+		) :
+			state{std::move(state)}, transfer_options{transfer_options} {}
+
+		TransferablePromiseHolder(const TransferablePromiseHolder&) = delete;
+
+		~TransferablePromiseHolder() final {
+			Save(true, [&]() {
+				return std::make_shared<ExternalCopyError>(ExternalCopyError::ErrorType::Error, "Promise was abandoned");
+			});
+		}
+
+		auto operator=(const TransferablePromiseHolder&) = delete;
+
+		static auto Definition() -> v8::Local<v8::FunctionTemplate> {
+			return MakeClass("PromiseHolder", nullptr);
+		}
+
+		void Accept(Local<Promise> promise) {
+			auto state = promise->State();
+			if (state == Promise::PromiseState::kPending) {
+				auto* isolate = Isolate::GetCurrent();
+				auto context = isolate->GetCurrentContext();
+				auto handle = This();
+				promise = Unmaybe(promise->Then(context, Unmaybe(
+					Function::New(context,
+						FreeFunctionWithData<decltype(&Resolved), &Resolved>{}.callback, handle)
+				)));
+				Unmaybe(promise->Catch(context, Unmaybe(
+					Function::New(context,
+						FreeFunctionWithData<decltype(&Rejected), &Rejected>{}.callback, handle)
+				)));
+			} else {
+				if (state == Promise::PromiseState::kFulfilled) {
+					Resolved(*this, promise->Result());
+				} else {
+					IsolateEnvironment::GetCurrent().PromiseWasHandled(promise);
+					Rejected(*this, promise->Result());
+				}
+			}
+		}
+
+		static void Resolved(TransferablePromiseHolder& that, Local<Value> value) {
+			that.Save(false, [&]() {
+				return TransferOut(value, that.transfer_options);
+			});
+		}
+
+	private:
+		template <class Function>
+		void Save(bool did_throw, Function callback) {
+			std::shared_ptr<Transferable> resolved_value;
+			auto pending_tasks = [&]() -> std::deque<RemoteTuple<Promise::Resolver, v8::Context>> {
+				auto lock = state->write();
+				if (!lock->resolved) {
+					lock->resolved = true;
+					FunctorRunners::RunCatchExternal(Isolate::GetCurrent()->GetCurrentContext(), [&]() {
+						lock->value = callback();
+						lock->did_throw = did_throw;
+					}, [&](std::unique_ptr<ExternalCopy> error) {
+						lock->value = std::move(error);
+						did_throw = lock->did_throw = true;
+					});
+				}
+				resolved_value = lock->value;
+				return std::exchange(lock->waiting, {});
+			}();
+			for (auto& resolver : pending_tasks) {
+				auto holder = resolver.GetIsolateHolder();
+				holder->ScheduleTask(
+					std::make_unique<ResolveTask>(std::move(resolver), resolved_value, did_throw),
+					false, true);
+			}
+		}
+
+		static void Rejected(TransferablePromiseHolder& that, Local<Value> value) {
+			that.Save(true, [&]() {
+				return ExternalCopy::CopyThrownValue(value);
+			});
+		}
+
+		struct ResolveTask : Runnable {
+			ResolveTask(RemoteTuple<Promise::Resolver, v8::Context> resolver, std::shared_ptr<Transferable> value, bool did_throw) :
+				resolver{std::move(resolver)}, value{std::move(value)}, did_throw{did_throw} {}
+
+			void Run() final {
+				auto context = this->resolver.Deref<1>();
+				Context::Scope context_scope{context};
+				auto resolver = this->resolver.Deref<0>();
+				if (did_throw) {
+					Unmaybe(resolver->Reject(context, value->TransferIn()));
+				} else {
+					Unmaybe(resolver->Resolve(context, value->TransferIn()));
+				}
+			}
+
+			RemoteTuple<Promise::Resolver, v8::Context> resolver;
+			std::shared_ptr<Transferable> value;
+			bool did_throw;
+		};
+
+		std::shared_ptr<TransferablePromiseState> state;
+		TransferOptions transfer_options;
+};
+
+// Internal ivm promise transferable
+class TransferablePromise : public Transferable {
+	public:
+		TransferablePromise(Local<Promise> promise, TransferOptions transfer_options) :
+				state{std::make_shared<TransferablePromiseState>()} {
+			MakeHolder(transfer_options).Accept(promise);
+		}
+
+		TransferablePromise(Local<Value> value, TransferOptions transfer_options) :
+				state{std::make_shared<TransferablePromiseState>()} {
+			TransferablePromiseHolder::Resolved(MakeHolder(transfer_options), value);
+		}
+
+		auto TransferIn() -> Local<Value> final {
+			auto* isolate = Isolate::GetCurrent();
+			auto context = isolate->GetCurrentContext();
+			auto resolver = Unmaybe(Promise::Resolver::New(context));
+			auto lock = state->write();
+			if (lock->resolved) {
+				if (lock->did_throw) {
+					Unmaybe(resolver->Reject(context, lock->value->TransferIn()));
+				} else {
+					Unmaybe(resolver->Resolve(context, lock->value->TransferIn()));
+				}
+			} else {
+				lock->waiting.emplace_back(resolver, context);
+			}
+			return resolver->GetPromise();
+		}
+
+	private:
+		auto MakeHolder(TransferOptions transfer_options) -> TransferablePromiseHolder& {
+			transfer_options.promise = false;
+			auto holder = ClassHandle::NewInstance<TransferablePromiseHolder>(state, transfer_options);
+			auto* object = ClassHandle::Unwrap<TransferablePromiseHolder>(holder);
+			return *object;
+		}
+
+		std::shared_ptr<TransferablePromiseState> state;
+};
+
+} // anonymous namespace
+
+TransferOptions::TransferOptions(Local<Object> options, Type fallback) : fallback{fallback} {
+	ParseOptions(options);
+}
+
+TransferOptions::TransferOptions(MaybeLocal<Object> maybe_options, Type fallback) : fallback{fallback} {
+	Local<Object> options;
+	if (maybe_options.ToLocal(&options)) {
+		ParseOptions(options);
+	}
+}
+
+void TransferOptions::TransferOptions::ParseOptions(Local<Object> options) {
+	bool copy = ReadOption<bool>(options, StringTable::Get().copy, false);
+	bool externalCopy = ReadOption<bool>(options, StringTable::Get().externalCopy, false);
+	bool reference = ReadOption<bool>(options, StringTable::Get().reference, false);
+	if ((copy && externalCopy) || (copy && reference) || (externalCopy && reference)) {
+		throw RuntimeTypeError("Only one of `copy`, `externalCopy`, or `reference` may be set");
+	}
+	if (copy) {
+		type = Type::Copy;
+	} else if (externalCopy) {
+		type = Type::ExternalCopy;
+	} else if (reference) {
+		type = Type::Reference;
+	}
+	promise = ReadOption<bool>(options, StringTable::Get().promise, false);
+}
+
+auto OptionalTransferOut(Local<Value> value, TransferOptions options) -> std::unique_ptr<Transferable> {
+	auto TransferWithType = [&](TransferOptions::Type type) -> std::unique_ptr<Transferable> {
+		switch (type) {
+			default:
+				return nullptr;
+
+			case TransferOptions::Type::Copy:
+				return ExternalCopy::Copy(value);
+
+			case TransferOptions::Type::ExternalCopy:
+				return std::make_unique<ExternalCopyHandle::ExternalCopyTransferable>(ExternalCopy::Copy(value));
+
+			case TransferOptions::Type::DeepReference:
+				return std::make_unique<ReferenceHandleTransferable>(value, true);
+
+			case TransferOptions::Type::Reference:
+				return std::make_unique<ReferenceHandleTransferable>(value);
+		}
+	};
+
+	if (options.promise) {
+		if (value->IsPromise()) {
+			return std::make_unique<TransferablePromise>(value.As<Promise>(), options);
+		} else {
+			return std::make_unique<TransferablePromise>(value, options);
+		}
+	}
+
+	switch (options.type) {
+		case TransferOptions::Type::None: {
+			if (value->IsObject()) {
+				auto* ptr = ClassHandle::Unwrap<TransferableHandle>(value.As<Object>());
+				if (ptr != nullptr) {
+					return ptr->TransferOut();
+				}
+				if (value->IsFunction()) {
+					return std::make_unique<CallbackTransferable>(value.As<Function>());
+				}
+			}
+			auto result = ExternalCopy::CopyIfPrimitive(value);
+			if (result) {
+				return result;
+			}
+			return TransferWithType(options.fallback);
+		}
+
+		default:
+			return TransferWithType(options.type);
+	}
+}
+
+auto TransferOut(Local<Value> value, TransferOptions options) -> std::unique_ptr<Transferable> {
+	auto copy = OptionalTransferOut(value, options);
+	if (!copy) {
+		throw RuntimeTypeError("A non-transferable value was passed");
+	}
+	return copy;
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/transferable.h

@@ -0,0 +1,42 @@
+#pragma once
+#include "isolate/class_handle.h"
+#include "isolate/transferable.h"
+#include <v8.h>
+#include <memory>
+
+namespace ivm {
+
+class TransferableHandle : public ClassHandle {
+	public:
+		static auto Definition() -> v8::Local<v8::FunctionTemplate> {
+			return MakeClass("Transferable", nullptr);
+		}
+
+		virtual auto TransferOut() -> std::unique_ptr<Transferable> = 0;
+};
+
+class TransferOptions {
+	public:
+		enum class Type { None, Copy, ExternalCopy, Reference, DeepReference };
+
+		TransferOptions() = default;
+		explicit TransferOptions(Type fallback) : fallback{fallback} {};
+		explicit TransferOptions(v8::Local<v8::Object> options, Type fallback = Type::None);
+		explicit TransferOptions(v8::MaybeLocal<v8::Object> maybe_options, Type fallback = Type::None);
+
+		auto operator==(const TransferOptions& that) const -> bool {
+			return type == that.type && fallback == that.fallback && promise == that.promise;
+		}
+
+		Type type = Type::None;
+		Type fallback = Type::None;
+		bool promise = false;
+
+	private:
+		void ParseOptions(v8::Local<v8::Object> options);
+};
+
+auto OptionalTransferOut(v8::Local<v8::Value> value, TransferOptions options = {}) -> std::unique_ptr<Transferable>;
+auto TransferOut(v8::Local<v8::Value> value, TransferOptions options = {}) -> std::unique_ptr<Transferable>;
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/vendor/v8_inspector/nodejs_v18.0.0.h

@@ -0,0 +1,360 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_V8_INSPECTOR_H_
+#define V8_V8_INSPECTOR_H_
+
+#include <stdint.h>
+
+#include <cctype>
+#include <memory>
+
+#include "v8-isolate.h"       // NOLINT(build/include_directory)
+#include "v8-local-handle.h"  // NOLINT(build/include_directory)
+
+namespace v8 {
+class Context;
+class Name;
+class Object;
+class StackTrace;
+class Value;
+}  // namespace v8
+
+namespace v8_inspector {
+
+namespace internal {
+class V8DebuggerId;
+}  // namespace internal
+
+namespace protocol {
+namespace Debugger {
+namespace API {
+class SearchMatch;
+}
+}
+namespace Runtime {
+namespace API {
+class RemoteObject;
+class StackTrace;
+class StackTraceId;
+}
+}
+namespace Schema {
+namespace API {
+class Domain;
+}
+}
+}  // namespace protocol
+
+class V8_EXPORT StringView {
+ public:
+  StringView() : m_is8Bit(true), m_length(0), m_characters8(nullptr) {}
+
+  StringView(const uint8_t* characters, size_t length)
+      : m_is8Bit(true), m_length(length), m_characters8(characters) {}
+
+  StringView(const uint16_t* characters, size_t length)
+      : m_is8Bit(false), m_length(length), m_characters16(characters) {}
+
+  bool is8Bit() const { return m_is8Bit; }
+  size_t length() const { return m_length; }
+
+  // TODO(dgozman): add DCHECK(m_is8Bit) to accessors once platform can be used
+  // here.
+  const uint8_t* characters8() const { return m_characters8; }
+  const uint16_t* characters16() const { return m_characters16; }
+
+ private:
+  bool m_is8Bit;
+  size_t m_length;
+  union {
+    const uint8_t* m_characters8;
+    const uint16_t* m_characters16;
+  };
+};
+
+class V8_EXPORT StringBuffer {
+ public:
+  virtual ~StringBuffer() = default;
+  virtual StringView string() const = 0;
+  // This method copies contents.
+  static std::unique_ptr<StringBuffer> create(StringView);
+};
+
+class V8_EXPORT V8ContextInfo {
+ public:
+  V8ContextInfo(v8::Local<v8::Context> context, int contextGroupId,
+                StringView humanReadableName)
+      : context(context),
+        contextGroupId(contextGroupId),
+        humanReadableName(humanReadableName),
+        hasMemoryOnConsole(false) {}
+
+  v8::Local<v8::Context> context;
+  // Each v8::Context is a part of a group. The group id must be non-zero.
+  int contextGroupId;
+  StringView humanReadableName;
+  StringView origin;
+  StringView auxData;
+  bool hasMemoryOnConsole;
+
+  static int executionContextId(v8::Local<v8::Context> context);
+
+  // Disallow copying and allocating this one.
+  enum NotNullTagEnum { NotNullLiteral };
+  void* operator new(size_t) = delete;
+  void* operator new(size_t, NotNullTagEnum, void*) = delete;
+  void* operator new(size_t, void*) = delete;
+  V8ContextInfo(const V8ContextInfo&) = delete;
+  V8ContextInfo& operator=(const V8ContextInfo&) = delete;
+};
+
+// This debugger id tries to be unique by generating two random
+// numbers, which should most likely avoid collisions.
+// Debugger id has a 1:1 mapping to context group. It is used to
+// attribute stack traces to a particular debugging, when doing any
+// cross-debugger operations (e.g. async step in).
+// See also Runtime.UniqueDebuggerId in the protocol.
+class V8_EXPORT V8DebuggerId {
+ public:
+  V8DebuggerId() = default;
+  V8DebuggerId(const V8DebuggerId&) = default;
+  V8DebuggerId& operator=(const V8DebuggerId&) = default;
+
+  std::unique_ptr<StringBuffer> toString() const;
+  bool isValid() const;
+  std::pair<int64_t, int64_t> pair() const;
+
+ private:
+  friend class internal::V8DebuggerId;
+  explicit V8DebuggerId(std::pair<int64_t, int64_t>);
+
+  int64_t m_first = 0;
+  int64_t m_second = 0;
+};
+
+class V8_EXPORT V8StackTrace {
+ public:
+  virtual StringView firstNonEmptySourceURL() const = 0;
+  virtual bool isEmpty() const = 0;
+  virtual StringView topSourceURL() const = 0;
+  virtual int topLineNumber() const = 0;
+  virtual int topColumnNumber() const = 0;
+  virtual int topScriptId() const = 0;
+  virtual StringView topFunctionName() const = 0;
+
+  virtual ~V8StackTrace() = default;
+  virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
+  buildInspectorObject(int maxAsyncDepth) const = 0;
+  virtual std::unique_ptr<StringBuffer> toString() const = 0;
+
+  // Safe to pass between threads, drops async chain.
+  virtual std::unique_ptr<V8StackTrace> clone() = 0;
+};
+
+class V8_EXPORT V8InspectorSession {
+ public:
+  virtual ~V8InspectorSession() = default;
+
+  // Cross-context inspectable values (DOM nodes in different worlds, etc.).
+  class V8_EXPORT Inspectable {
+   public:
+    virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
+    virtual ~Inspectable() = default;
+  };
+  class V8_EXPORT CommandLineAPIScope {
+   public:
+    virtual ~CommandLineAPIScope() = default;
+  };
+  virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;
+
+  // Dispatching protocol messages.
+  static bool canDispatchMethod(StringView method);
+  virtual void dispatchProtocolMessage(StringView message) = 0;
+  virtual std::vector<uint8_t> state() = 0;
+  virtual std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
+  supportedDomains() = 0;
+
+  virtual std::unique_ptr<V8InspectorSession::CommandLineAPIScope>
+  initializeCommandLineAPIScope(int executionContextId) = 0;
+
+  // Debugger actions.
+  virtual void schedulePauseOnNextStatement(StringView breakReason,
+                                            StringView breakDetails) = 0;
+  virtual void cancelPauseOnNextStatement() = 0;
+  virtual void breakProgram(StringView breakReason,
+                            StringView breakDetails) = 0;
+  virtual void setSkipAllPauses(bool) = 0;
+  virtual void resume(bool setTerminateOnResume = false) = 0;
+  virtual void stepOver() = 0;
+  virtual std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
+  searchInTextByLines(StringView text, StringView query, bool caseSensitive,
+                      bool isRegex) = 0;
+
+  // Remote objects.
+  virtual std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
+      v8::Local<v8::Context>, v8::Local<v8::Value>, StringView groupName,
+      bool generatePreview) = 0;
+
+  virtual bool unwrapObject(std::unique_ptr<StringBuffer>* error,
+                            StringView objectId, v8::Local<v8::Value>*,
+                            v8::Local<v8::Context>*,
+                            std::unique_ptr<StringBuffer>* objectGroup) = 0;
+  virtual void releaseObjectGroup(StringView) = 0;
+  virtual void triggerPreciseCoverageDeltaUpdate(StringView occasion) = 0;
+};
+
+class V8_EXPORT V8InspectorClient {
+ public:
+  virtual ~V8InspectorClient() = default;
+
+  virtual void runMessageLoopOnPause(int contextGroupId) {}
+  virtual void quitMessageLoopOnPause() {}
+  virtual void runIfWaitingForDebugger(int contextGroupId) {}
+
+  virtual void muteMetrics(int contextGroupId) {}
+  virtual void unmuteMetrics(int contextGroupId) {}
+
+  virtual void beginUserGesture() {}
+  virtual void endUserGesture() {}
+
+  virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
+    return nullptr;
+  }
+  virtual std::unique_ptr<StringBuffer> descriptionForValueSubtype(
+      v8::Local<v8::Context>, v8::Local<v8::Value>) {
+    return nullptr;
+  }
+  virtual bool isInspectableHeapObject(v8::Local<v8::Object>) { return true; }
+
+  virtual v8::Local<v8::Context> ensureDefaultContextInGroup(
+      int contextGroupId) {
+    return v8::Local<v8::Context>();
+  }
+  virtual void beginEnsureAllContextsInGroup(int contextGroupId) {}
+  virtual void endEnsureAllContextsInGroup(int contextGroupId) {}
+
+  virtual void installAdditionalCommandLineAPI(v8::Local<v8::Context>,
+                                               v8::Local<v8::Object>) {}
+  virtual void consoleAPIMessage(int contextGroupId,
+                                 v8::Isolate::MessageErrorLevel level,
+                                 const StringView& message,
+                                 const StringView& url, unsigned lineNumber,
+                                 unsigned columnNumber, V8StackTrace*) {}
+  virtual v8::MaybeLocal<v8::Value> memoryInfo(v8::Isolate*,
+                                               v8::Local<v8::Context>) {
+    return v8::MaybeLocal<v8::Value>();
+  }
+
+  virtual void consoleTime(const StringView& title) {}
+  virtual void consoleTimeEnd(const StringView& title) {}
+  virtual void consoleTimeStamp(const StringView& title) {}
+  virtual void consoleClear(int contextGroupId) {}
+  virtual double currentTimeMS() { return 0; }
+  typedef void (*TimerCallback)(void*);
+  virtual void startRepeatingTimer(double, TimerCallback, void* data) {}
+  virtual void cancelTimer(void* data) {}
+
+  // TODO(dgozman): this was added to support service worker shadow page. We
+  // should not connect at all.
+  virtual bool canExecuteScripts(int contextGroupId) { return true; }
+
+  virtual void maxAsyncCallStackDepthChanged(int depth) {}
+
+  virtual std::unique_ptr<StringBuffer> resourceNameToUrl(
+      const StringView& resourceName) {
+    return nullptr;
+  }
+
+  // The caller would defer to generating a random 64 bit integer if
+  // this method returns 0.
+  virtual int64_t generateUniqueId() { return 0; }
+};
+
+// These stack trace ids are intended to be passed between debuggers and be
+// resolved later. This allows to track cross-debugger calls and step between
+// them if a single client connects to multiple debuggers.
+struct V8_EXPORT V8StackTraceId {
+  uintptr_t id;
+  std::pair<int64_t, int64_t> debugger_id;
+  bool should_pause = false;
+
+  V8StackTraceId();
+  V8StackTraceId(const V8StackTraceId&) = default;
+  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id);
+  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id,
+                 bool should_pause);
+  explicit V8StackTraceId(StringView);
+  V8StackTraceId& operator=(const V8StackTraceId&) = default;
+  V8StackTraceId& operator=(V8StackTraceId&&) noexcept = default;
+  ~V8StackTraceId() = default;
+
+  bool IsInvalid() const;
+  std::unique_ptr<StringBuffer> ToString();
+};
+
+class V8_EXPORT V8Inspector {
+ public:
+  static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
+  virtual ~V8Inspector() = default;
+
+  // Contexts instrumentation.
+  virtual void contextCreated(const V8ContextInfo&) = 0;
+  virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
+  virtual void resetContextGroup(int contextGroupId) = 0;
+  virtual v8::MaybeLocal<v8::Context> contextById(int contextId) = 0;
+  virtual V8DebuggerId uniqueDebuggerId(int contextId) = 0;
+
+  // Various instrumentation.
+  virtual void idleStarted() = 0;
+  virtual void idleFinished() = 0;
+
+  // Async stack traces instrumentation.
+  virtual void asyncTaskScheduled(StringView taskName, void* task,
+                                  bool recurring) = 0;
+  virtual void asyncTaskCanceled(void* task) = 0;
+  virtual void asyncTaskStarted(void* task) = 0;
+  virtual void asyncTaskFinished(void* task) = 0;
+  virtual void allAsyncTasksCanceled() = 0;
+
+  virtual V8StackTraceId storeCurrentStackTrace(StringView description) = 0;
+  virtual void externalAsyncTaskStarted(const V8StackTraceId& parent) = 0;
+  virtual void externalAsyncTaskFinished(const V8StackTraceId& parent) = 0;
+
+  // Exceptions instrumentation.
+  virtual unsigned exceptionThrown(v8::Local<v8::Context>, StringView message,
+                                   v8::Local<v8::Value> exception,
+                                   StringView detailedMessage, StringView url,
+                                   unsigned lineNumber, unsigned columnNumber,
+                                   std::unique_ptr<V8StackTrace>,
+                                   int scriptId) = 0;
+  virtual void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
+                                StringView message) = 0;
+  virtual bool associateExceptionData(v8::Local<v8::Context>,
+                                      v8::Local<v8::Value> exception,
+                                      v8::Local<v8::Name> key,
+                                      v8::Local<v8::Value> value) = 0;
+
+  // Connection.
+  class V8_EXPORT Channel {
+   public:
+    virtual ~Channel() = default;
+    virtual void sendResponse(int callId,
+                              std::unique_ptr<StringBuffer> message) = 0;
+    virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
+    virtual void flushProtocolNotifications() = 0;
+  };
+  virtual std::unique_ptr<V8InspectorSession> connect(int contextGroupId,
+                                                      Channel*,
+                                                      StringView state) = 0;
+
+  // API methods.
+  virtual std::unique_ptr<V8StackTrace> createStackTrace(
+      v8::Local<v8::StackTrace>) = 0;
+  virtual std::unique_ptr<V8StackTrace> captureStackTrace(bool fullStack) = 0;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_V8_INSPECTOR_H_