Base = 1 << 0,

Primitive = 1 << 1,

Enum = 1 << 2,

Struct = 1 << 3,

StructType = 1 << 4,

ObjCAllocObject = 1 << 5,

ObjCObject = 1 << 6,

ObjCClass = 1 << 7,

ObjCProtocol = 1 << 8,

Function = 1 << 9,

AnonymousFunction = 1 << 10,

Block = 1 << 11,

Reference = 1 << 12,

ReferenceType = 1 << 13,

Pointer = 1 << 14,

PointerType = 1 << 15,

FunctionReference = 1 << 16,

FunctionReferenceType = 1 << 17,

ExtVector = 1 << 18,

Worker = 1 << 19,

UnmanagedType = 1 << 20,

public:

virtual v8::Local<v8::Value> operator[](int i) const = 0;

virtual size_t Length() const = 0;

public:

V8FunctionCallbackArgs(const v8::FunctionCallbackInfo<v8::Value>& info)

: info_(info) {}

v8::Local<v8::Value> operator[](int i) const override {

return this->info_[i];

}

size_t Length() const override { return this->info_.Length(); }

private:

const v8::FunctionCallbackInfo<v8::Value>& info_;

public:

V8VectorArgs(const std::vector<v8::Local<v8::Value>>& args) : args_(args) {}

v8::Local<v8::Value> operator[](int i) const override {

return this->args_[i];

}

size_t Length() const override { return this->args_.size(); }

private:

const std::vector<v8::Local<v8::Value>>& args_;

public:

V8SimpleValueArgs(v8::Local<v8::Value>& value) : value_(value) {}

v8::Local<v8::Value> operator[](int i) const override { return this->value_; }

size_t Length() const override { return 1; }

private:

v8::Local<v8::Value>& value_;

public:

v8::Local<v8::Value> operator[](int i) const override {

return v8::Local<v8::Value>();

}

size_t Length() const override { return 0; }

public:

StructField(ptrdiff_t offset, ffi_type* ffiType, std::string name,

const TypeEncoding* encoding)

: offset_(offset), ffiType_(ffiType), name_(name), encoding_(encoding) {}

ptrdiff_t Offset() const { return this->offset_; }

ffi_type* FFIType() const { return this->ffiType_; }

const std::string& Name() const { return this->name_; }

const TypeEncoding* Encoding() const { return this->encoding_; }

private:

ptrdiff_t offset_;

ffi_type* ffiType_;

std::string name_;

const TypeEncoding* encoding_;

public:

StructInfo(std::string name, ffi_type* ffiType,

std::vector<StructField> fields)

: name_(std::move(name)), ffiType_(ffiType), fields_(std::move(fields)) {}

StructInfo(const StructInfo&) = delete;

StructInfo& operator=(const StructInfo&) = delete;

const std::string& Name() const { return this->name_; }

ffi_type* FFIType() const { return this->ffiType_; }

const std::vector<StructField>& Fields() const { return this->fields_; }

private:

std::string name_;

ffi_type* ffiType_;

std::vector<StructField> fields_;

public:

BaseDataWrapper() : gcProtected_(false) {}

virtual ~BaseDataWrapper() = default;

const virtual WrapperType Type() { return WrapperType::Base; }

bool IsGcProtected() { return this->gcProtected_; }

void GcProtect() { this->gcProtected_ = true; }

void GcUnprotect() { this->gcProtected_ = false; }

ExternalMemoryCharge* ExternalCharge() { return this->externalCharge_.get(); }

void SetExternalCharge(std::unique_ptr<ExternalMemoryCharge> charge) {

this->externalCharge_ = std::move(charge);

}

private:

bool gcProtected_;

std::unique_ptr<ExternalMemoryCharge> externalCharge_;

public:

EnumDataWrapper(std::string jsCode)

: jsCode_(jsCode), hasCachedValue_(false), cachedValue_(0) {}

const WrapperType Type() { return WrapperType::Enum; }

std::string JSCode() { return jsCode_; }

// Numeric value memoized by Interop::WriteValue so the enum's JS snippet is

// compiled and evaluated at most once per wrapper.

bool HasCachedValue() const { return hasCachedValue_; }

double CachedValue() const { return cachedValue_; }

void SetCachedValue(double value) {

cachedValue_ = value;

hasCachedValue_ = true;

}

private:

std::string jsCode_;

bool hasCachedValue_;

double cachedValue_;

public:

PointerWrapper(void* data) : data_(data), isAdopted_(false) {}

const WrapperType Type() { return WrapperType::Pointer; }

void* Data() const { return this->data_; }

void SetData(void* data) { this->data_ = data; }

bool IsAdopted() const { return this->isAdopted_; }

void SetAdopted(bool value) { this->isAdopted_ = value; }

private:

void* data_;

bool isAdopted_;

public:

ReferenceWrapper(BaseDataWrapper* typeWrapper,

v8::Persistent<v8::Value>* value)

: typeWrapper_(typeWrapper),

value_(value),

encoding_(nullptr),

data_(nullptr),

disposeData_(false) {}

~ReferenceWrapper() {

if (this->value_ != nullptr) {

value_->Reset();

delete value_;

}

if (this->data_ != nullptr && this->disposeData_) {

std::free(this->data_);

}

}

const WrapperType Type() { return WrapperType::Reference; }

BaseDataWrapper* TypeWrapper() { return this->typeWrapper_; }

v8::Persistent<v8::Value>* Value() { return this->value_; }

void SetValue(v8::Persistent<v8::Value>* value) {

if (this->value_ != nullptr) {

this->value_->Reset();

}

this->value_ = value;

}

const TypeEncoding* Encoding() { return this->encoding_; }

void SetEncoding(const TypeEncoding* encoding) { this->encoding_ = encoding; }

void* Data() const { return this->data_; }

void SetData(void* data, bool disposeData = false) {

if (this->data_ != nullptr && this->disposeData_) {

std::free(this->data_);

}

this->data_ = data;

this->disposeData_ = disposeData;

}

private:

BaseDataWrapper* typeWrapper_;

v8::Persistent<v8::Value>* value_;

const TypeEncoding* encoding_;

void* data_;

bool disposeData_;

public:

PrimitiveDataWrapper(size_t size, const TypeEncoding* typeEncoding,

bool autoDeleteEncoding)

: size_(size),

typeEncoding_(typeEncoding),

autoDeleteEncoding_(autoDeleteEncoding) {}

~PrimitiveDataWrapper() {

if (autoDeleteEncoding_) {

std::free((struct TypeEncoding*)typeEncoding_);

}

}

const WrapperType Type() { return WrapperType::Primitive; }

size_t Size() { return this->size_; }

const TypeEncoding* TypeEncoding() { return this->typeEncoding_; }

private:

size_t size_;

const struct TypeEncoding* typeEncoding_;

bool autoDeleteEncoding_;

public:

StructTypeWrapper(const struct StructInfo& structInfo)

: structInfo_(&structInfo) {}

const WrapperType Type() { return WrapperType::StructType; }

const struct StructInfo& StructInfo() const { return *this->structInfo_; }

private:

const struct StructInfo* structInfo_;

// The struct object owns a copy of the bytes.

kCopy,

// The struct object aliases bytes owned by whatever its parent field holds.

kAlias,

public:

// Internal fields of a struct object after the wrapper (field 0). The parent

// field holds whatever keeps aliased bytes alive: a view's parent struct

// object, or the Pointer object a pointer-backed struct was built over. From

// kFirstViewField on, one slot per struct-typed field caches its view.

static constexpr int kParentField = 1;

static constexpr int kStorageField = 2;

static constexpr int kFirstViewField = 3;

StructWrapper(const struct StructInfo& structInfo, void* data)

: StructTypeWrapper(structInfo), data_(data) {}

const WrapperType Type() { return WrapperType::Struct; }

void* Data() const { return this->data_; }

private:

void* data_;

public:

ObjCAllocDataWrapper(Class klass) : klass_(klass) {}

const WrapperType Type() { return WrapperType::ObjCAllocObject; }

Class Klass() { return this->klass_; }

private:

Class klass_;

public:

UnmanagedTypeWrapper(uint8_t* data, const TypeEncoding* typeEncoding)

: data_(data), typeEncoding_(typeEncoding), valueTaken_(false) {}

const WrapperType Type() { return WrapperType::UnmanagedType; }

uint8_t* Data() {

this->valueTaken_ = true;

return this->data_;

}

const TypeEncoding* TypeEncoding() { return this->typeEncoding_; }

bool ValueTaken() { return this->valueTaken_; }

private:

uint8_t* data_;

const tns::TypeEncoding* typeEncoding_;

bool valueTaken_;

public:

ObjCDataWrapper(id data, const TypeEncoding* typeEncoding = nullptr)

: data_(data),

typeEncoding_(typeEncoding),

klass_(object_getClass(data)) {}

const WrapperType Type() { return WrapperType::ObjCObject; }

id Data() { return this->data_; }

// True for the claim a collection adapter attaches to the plain JS object it

// was built from. The adapter owns that claim exclusively -- it must stay

// deletable from the adapter's -dealloc even after isolate teardown -- so no

// other retirement path may free it.

bool IsAdapterClaim() { return this->adapterClaim_; }

void MarkAdapterClaim() { this->adapterClaim_ = true; }

const TypeEncoding* TypeEncoding() { return this->typeEncoding_; }

// The class Data() had when this wrapper was built. Data() alone cannot tell

// whether the wrapper still describes the object living at that address, so

// anything keyed on the raw pointer needs this to detect a recycled slot.

Class Klass() { return this->klass_; }

private:

bool adapterClaim_ = false;

id data_;

const tns::TypeEncoding* typeEncoding_;

Class klass_;

public:

ObjCClassWrapper(Class klazz, bool extendedClass = false)

: klass_(klazz), extendedClass_(extendedClass) {}

const WrapperType Type() { return WrapperType::ObjCClass; }

Class Klass() { return this->klass_; }

bool ExtendedClass() { return this->extendedClass_; }

private:

Class klass_;

bool extendedClass_;

public:

ObjCProtocolWrapper(Protocol* proto, const ProtocolMeta* protoMeta)

: proto_(proto), protoMeta_(protoMeta) {}

const WrapperType Type() { return WrapperType::ObjCProtocol; }

Protocol* Proto() { return this->proto_; }

const ProtocolMeta* ProtoMeta() { return this->protoMeta_; }

private:

Protocol* proto_;

const ProtocolMeta* protoMeta_;

public:

FunctionWrapper(const FunctionMeta* meta) : meta_(meta) {}

const WrapperType Type() { return WrapperType::Function; }

const FunctionMeta* Meta() { return this->meta_; }

private:

const FunctionMeta* meta_;

public:

AnonymousFunctionWrapper(void* functionPointer,

const TypeEncoding* parametersEncoding,

size_t parametersCount)

: data_(functionPointer), parametersEncoding_(parametersEncoding) {}

const WrapperType Type() { return WrapperType::AnonymousFunction; }

void* Data() { return this->data_; }

const TypeEncoding* ParametersEncoding() { return this->parametersEncoding_; }

private:

void* data_;

const TypeEncoding* parametersEncoding_;

public:

BlockWrapper(void* block, const TypeEncoding* typeEncoding, bool ownsBlock)

: block_(block), typeEncoding_(typeEncoding), ownsBlock_(ownsBlock) {}

const WrapperType Type() { return WrapperType::Block; }

void* Block() { return this->block_; }

const TypeEncoding* Encodings() { return this->typeEncoding_; }

bool OwnsBlock() { return this->ownsBlock_; }

private:

void* block_;

const TypeEncoding* typeEncoding_;

bool ownsBlock_;

public:

FunctionReferenceWrapper(std::shared_ptr<v8::Persistent<v8::Value>> function)

: function_(function), data_(nullptr), encoding_(nullptr) {}

const WrapperType Type() { return WrapperType::FunctionReference; }

std::shared_ptr<v8::Persistent<v8::Value>> Function() {

return this->function_;

}

void* Data() const { return this->data_; }

const TypeEncoding* Encoding() const { return this->encoding_; }

void SetData(void* data, const TypeEncoding* encoding = nullptr) {

this->data_ = data;

this->encoding_ = encoding;

}

private:

std::shared_ptr<v8::Persistent<v8::Value>> function_;

void* data_;

const TypeEncoding* encoding_;

public:

ExtVectorWrapper(void* data, ffi_type* ffiType,

const TypeEncoding* innerTypeEncoding,

const TypeEncoding* typeEncoding)

: data_(data),

ffiType_(ffiType),

innerTypeEncoding_(innerTypeEncoding),

typeEncoding_(typeEncoding) {}

const WrapperType Type() { return WrapperType::ExtVector; }

void* Data() { return this->data_; }

ffi_type* FFIType() { return this->ffiType_; }

const TypeEncoding* InnerTypeEncoding() { return this->innerTypeEncoding_; }

const TypeEncoding* TypeEncoding() { return this->typeEncoding_; }

private:

void* data_;

ffi_type* ffiType_;

const struct TypeEncoding* innerTypeEncoding_;

const struct TypeEncoding* typeEncoding_;

public:

WorkerWrapper(v8::Isolate* mainIsolate,

std::function<void(v8::Isolate*, v8::Local<v8::Object> thiz,

std::shared_ptr<worker::Message>)>

onMessage);

// Debugger support (no-ops in release builds). CreateInspector runs on the

// worker thread after the worker Runtime is initialized; DestroyInspector

// runs on the worker thread during teardown, before the Runtime is deleted.

void CreateInspector(v8::Isolate* isolate, const std::string& scriptPath);

void DestroyInspector();

// `func` runs on the worker thread: it creates the worker's runtime, hands

// the isolate to PublishIsolate once the runtime is initialized, and runs

// the entry script.

void Start(std::shared_ptr<v8::Persistent<v8::Value>> poWorker,

std::function<void()> func,

std::optional<int> qualityOfService = std::nullopt);

// Worker thread, once the runtime is initialized and before the entry script

// runs. From here Terminate() reaches V8: it interrupts whatever JS the

// worker runs, the entry script included, and flags the module pumps so a

// parked graph stops waiting. A terminate() that landed earlier is honored by

// the caller checking IsTerminating() right after this, before any app code.

void PublishIsolate(v8::Isolate* isolate);

// Both reporters take the isolate from their caller, which is running on

// it: they are reachable while the entry script is still evaluating.

void CallOnErrorHandlers(v8::Isolate* isolate, v8::TryCatch& tc);

// Reports a rejected entry-evaluation promise. A rejection carries a reason

// rather than a TryCatch, so it cannot go through CallOnErrorHandlers, but it

// follows the same web order: the worker scope's `onerror` first, then — only

// if that did not handle it — the parent's Worker error event.

void ReportEntryEvaluationRejection(v8::Isolate* isolate,

v8::Local<v8::Context> context,

v8::Local<v8::Value> reason);

void PassUncaughtExceptionFromWorkerToMain(v8::Local<v8::Context> context,

v8::TryCatch& tc,

bool async = true);

// Overload to pass a pre-built error payload when a TryCatch isn't available.

// `thrown` is the value the worker threw, when there is one: its name and

// message are read here, on the worker's isolate, for the parent to rebuild

// the error from. Without it the parent's error is an Error carrying

// `message`. Only strings cross to the parent's isolate.

void PassUncaughtExceptionFromWorkerToMain(

const std::string& message, const std::string& source,

const std::string& stackTrace, int lineNumber, bool async = true,

v8::Local<v8::Value> thrown = v8::Local<v8::Value>());

// Forwards a drained unhandled promise rejection to the main isolate's

// worker.onerror, guarded against teardown. Shares marshaling with the

// exception overload above.

void PassUncaughtRejectionToMain(

const std::string& message, const std::string& source,

const std::string& stackTrace, int lineNumber, bool async = true,

v8::Local<v8::Value> thrown = v8::Local<v8::Value>());

void PostMessage(std::shared_ptr<worker::Message> message);

// WHATWG parity: the worker's implicit port message queue starts disabled;

// Worker.mm calls this once the entry script has finished evaluating

// (including after a pending top-level await settles). From then on every

// buffered and future message dispatches whether or not a handler exists —

// a handler installed later (e.g. from a timer) misses earlier messages,

// exactly as on the web.

void EnableMessageQueue();

void Close();

void Terminate();

// Arms the near-heap-limit callback on the worker's own isolate. Runs on the

// worker thread right after the isolate exists; without it an isolate that

// reaches its heap cap aborts the whole process instead of surfacing as an

// error on the parent's Worker object. `maxOldGenerationSizeBytes` is only

// used to name the cap in the message forwarded to the parent.

void WatchHeapLimit(v8::Isolate* isolate, const std::string& scriptPath,

std::optional<size_t> maxOldGenerationSizeBytes);

// The JS Worker object is a GC root from a successful start until the worker

// ends, so a running worker is reachable the way a browser's is rather than

// depending on its finalizer to keep it. Both of these run on the main

// isolate's thread only -- they re-arm that isolate's global handle -- and

// the unroot is idempotent, so an end reached by more than one path re-arms

// the finalizer once.

void RootWorkerObject();

void UnrootWorkerObject();

// Dispatches the end-of-worker event and unroots. Main isolate's thread,

// with the isolate entered and locked by the caller.

void EndWrapperLifetime();

~WorkerWrapper();

const WrapperType Type();

const int Id();

const bool IsRunning();

const bool IsClosing();

// Set by Terminate() from any thread, by the near-heap-limit callback, and by

// the worker thread itself once a close() takes effect. One-way.

const bool IsTerminating();

const int WorkerId();

const inline v8::Isolate* GetMainIsolate() { return mainIsolate_; }

// The only route from the worker thread to the parent: see mainLoop_.

std::weak_ptr<EventLoop> MainLoop() const { return mainLoop_; }

// Deletion is decided by who still holds the wrapper. The parent's Worker

// object holds it from construction; Start() adds the worker thread. Each

// side lets go exactly once, with a compare-and-swap out of Holders::Both,

// so exactly one of them finds itself the last holder and deletes.

//

// Parent's thread, during the final disposal of the parent isolate. Returns

// true when the worker thread is already done with the wrapper (or never

// had it), which leaves the delete to the caller; false when the worker

// thread still uses it and deletes it when it ends.

bool ReleaseFromParent();

// Parent's thread, from the Worker object's finalizer. True when the worker

// thread is done with the wrapper (or never had it), so the caller may

// delete; nothing changes when false.

bool HeldByParentOnly() const;

// Worker thread, as its last touch of the wrapper and after it removed the

// wrapper's Caches::Workers entry. Deletes the wrapper when the parent has

// already let go; otherwise the parent may delete it from here on.

void ReleaseFromWorkerThread();

private:

enum class Holders : uint8_t { Parent, Both, WorkerThread };

v8::Isolate* mainIsolate_;

// Written by the worker thread only: published by PublishIsolate once the

// worker's runtime is initialized and before its entry script runs,

// withdrawn before the runtime is deleted. Any other thread reads and uses

// it under workerIsolateMutex_. Null while the runtime is being set up, so a

// Terminate() in that window cannot interrupt the builtins Runtime::Init

// evaluates; the startup function checks the terminating flag right after

// publishing instead.

v8::Isolate* workerIsolate_;

std::mutex workerIsolateMutex_;

std::atomic<bool> isRunning_;

std::atomic<bool> isClosing_;

std::atomic<bool> isTerminating_;

// The worker thread has started tearing down. Worker thread only; who

// deletes the wrapper is holders_, not this.

std::atomic<bool> isDisposed_;

std::atomic<Holders> holders_;

// False until the entry script has finished evaluating (EnableMessageQueue);

// DrainPendingTasks leaves the queue untouched while disabled.

std::atomic<bool> messagesEnabled_;

std::function<void(v8::Isolate*, v8::Local<v8::Object> thiz,

std::shared_ptr<worker::Message>)>

onMessage_;

std::shared_ptr<v8::Persistent<v8::Value>> poWorker_;

// The parent's event loop, taken on the parent's thread at construction.

// Every worker-thread post to the parent goes through it and never through

// the parent isolate: the parent runtime may be mid-teardown or its isolate

// already disposed when the post runs, whereas a loop that has shut down

// drops the post, and an expired pointer means the parent is gone entirely.

std::weak_ptr<EventLoop> mainLoop_;

ConcurrentQueue queue_;

static std::atomic<int> nextId_;

int workerId_;

// Owned by the worker thread; inspectorMutex_ makes Terminate() (main

// thread) and DestroyInspector() (worker thread) agree on liveness.

v8_inspector::WorkerInspectorClient* inspector_ = nullptr;

std::mutex inspectorMutex_;

// The isolate the near-heap-limit callback is armed on. Worker thread only.

// Kept apart from workerIsolate_ because the callback is armed before the

// isolate is published and can fire during Runtime::Init, and because

// removing a callback V8 never had registered is fatal: non-null here means

// exactly "armed, remove at teardown".

v8::Isolate* heapLimitIsolate_ = nullptr;

std::string heapLimitMessage_;

std::string heapLimitSource_;

std::atomic<bool> heapLimitExceeded_{false};

// Runs on the worker thread from inside a GC, where no JS may run and no

// handle may be created.

static size_t OnNearHeapLimit(void* data, size_t current_heap_limit,

size_t initial_heap_limit);

// Parked while the Worker object is rooted, so the unroot can re-arm the very

// finalizer ObjectManager::Register installed. Main isolate's thread only.

ObjectWeakCallbackState* weakCallbackState_ = nullptr;

bool workerObjectRooted_ = false;

// Cleared by the destructor, so a task posted from the worker thread can tell

// whether this wrapper still exists once it reaches the main isolate. The

// parent deletes the wrapper with that isolate locked, which is what the task

// takes before reading this. The worker thread only deletes it after the

// parent's final disposal, which follows the shutdown of the loop such a

// task would run on.

std::shared_ptr<std::atomic<WorkerWrapper*>> selfRef_;

void BackgroundLooper(std::function<void()> func);

void DrainPendingTasks();

void ForwardErrorPayloadToMain(const std::string& message,

const std::string& source,

const std::string& stackTrace, int lineNumber,

bool async, v8::Local<v8::Value> thrown);