using is_transparent = void;

size_t operator()(std::string_view key) const {

return robin_hood::hash_bytes(key.data(), key.size());

}

using is_transparent = void;

bool operator()(std::string_view lhs, std::string_view rhs) const {

return lhs == rhs;

}

public:

class WorkerState {

public:

WorkerState(v8::Isolate* isolate,

std::shared_ptr<v8::Persistent<v8::Value>> poWorker,

void* userData)

: isolate_(isolate), poWorker_(poWorker), userData_(userData) {}

v8::Isolate* GetIsolate() { return this->isolate_; }

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

return this->poWorker_;

}

void* UserData() { return this->userData_; }

private:

v8::Isolate* isolate_;

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

void* userData_;

};

Caches(v8::Isolate* isolate, const int& isolateId_ = -1);

~Caches();

bool isWorker = false;

static std::shared_ptr<ConcurrentMap<std::string, const Meta*>> Metadata;

static std::shared_ptr<

ConcurrentMap<int, std::shared_ptr<Caches::WorkerState>>>

Workers;

inline static std::shared_ptr<Caches> Init(v8::Isolate* isolate,

const int& isolateId) {

auto cache = std::make_shared<Caches>(isolate, isolateId);

// create a new shared_ptr that will live until Remove is called

isolate->SetData(0, static_cast<void*>(new std::shared_ptr<Caches>(cache)));

return cache;

}

inline static std::shared_ptr<Caches> Get(v8::Isolate* isolate) {

auto cache = isolate->GetData(0);

if (cache != nullptr) {

return *reinterpret_cast<std::shared_ptr<Caches>*>(cache);

}

// this should only happen when an isolate is accessed after disposal

// so we return a dummy cache

return std::make_shared<Caches>(isolate);

}

static void Remove(v8::Isolate* isolate);

// Per-isolate storage for subsystem state, so a subsystem can declare its

// state struct in its own .cpp instead of adding members here (and instead

// of a process-wide map keyed by v8::Isolate*, whose container is shared

// across runtimes tearing down on their own threads). The first call

// default-constructs T; it is destroyed with this Caches, under the teardown

// Locker while the isolate is still alive, so T may hold v8::Persistent

// members. Returns null once teardown has begun (InvalidateIsolate) or the

// isolate's Caches is gone — callers must bail, not recreate state. Access

// from the isolate's thread only, like every other member.

template <typename T>

static T* StateFor(v8::Isolate* isolate) {

auto raw = isolate->GetData(0);

if (raw == nullptr) {

return nullptr;

}

Caches* cache = reinterpret_cast<std::shared_ptr<Caches>*>(raw)->get();

if (!cache->IsValid()) {

return nullptr;

}

return cache->GetOrCreateState<T>();

}

inline int getIsolateId() { return isolateId_; }

// The id assigned at Init; unlike getIsolateId() it survives

// InvalidateIsolate, so it still names this isolate's gate during teardown.

// -1 for the stand-in Get() returns once the isolate's Caches is gone.

inline int getGateId() const { return gateId_; }

inline void InvalidateIsolate() { isolateId_ = -1; }

inline bool IsValid() { return isolateId_ != -1; }

void SetContext(v8::Local<v8::Context> context);

v8::Local<v8::Context> GetContext();

// GetContext crashes before SetContext; work can run in that window (v8

// posts foreground tasks during Isolate::New)

inline bool HasContext() { return context_ != nullptr; }

// Per-isolate unhandled promise rejection tracking. Fed by

// NativeScriptException::OnPromiseRejected and drained once per runloop turn.

std::unique_ptr<PromiseRejectionTracker> PromiseRejections;

// Head of the intrusive list of wrappers registered by

// ObjectManager::Register(). V8 no longer offers a way to enumerate

// persistent handles, so teardown disposal walks this instead. Entries unlink

// themselves when the wrapper is disposed, so the list only ever holds live

// wrappers.

ObjectWeakCallbackState* ObjectManagedValues = nullptr;

robin_hood::unordered_map<const Meta*,

std::unique_ptr<v8::Persistent<v8::Value>>>

Prototypes;

robin_hood::unordered_map<std::string,

std::unique_ptr<v8::Persistent<v8::Object>>,

TransparentStringHash, TransparentStringEqual>

ClassPrototypes;

robin_hood::unordered_map<const Meta*,

std::unique_ptr<v8::Persistent<v8::Object>>>

MetaInstancePrototypes;

robin_hood::unordered_map<

const BaseClassMeta*,

std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>>

CtorFuncTemplates;

robin_hood::unordered_map<std::string,

std::unique_ptr<v8::Persistent<v8::Function>>>

CtorFuncs;

robin_hood::unordered_map<std::string,

std::unique_ptr<v8::Persistent<v8::Function>>>

ProtocolCtorFuncs;

robin_hood::unordered_map<BinaryTypeEncodingType,

std::unique_ptr<v8::Persistent<v8::Object>>>

PrimitiveInteropTypes;

robin_hood::unordered_map<std::string,

std::unique_ptr<v8::Persistent<v8::Function>>>

CFunctions;

robin_hood::unordered_map<id, std::shared_ptr<v8::Persistent<v8::Value>>>

Instances;

robin_hood::unordered_map<const void*,

std::shared_ptr<v8::Persistent<v8::Object>>>

PointerInstances;

// ExternalMemory's size estimator per class, resolved on first sight.

robin_hood::unordered_map<Class, uint8_t> ExternalSizeEstimators;

// Live IsolateTracked instances (URL, URLSearchParams, URLPattern). Their

// weak-callback finalizers never fire at isolate disposal, so teardown

// sweeps this set to delete whatever GC didn't get to.

robin_hood::unordered_set<IsolateTracked*> TrackedInstances;

std::function<v8::Local<v8::FunctionTemplate>(

v8::Local<v8::Context>, const BaseClassMeta*, KnownUnknownClassPair,

const std::vector<std::string>&)>

ObjectCtorInitializer;

// Builds a struct object over `data`: a copy of it (kCopy; zero-filled when

// `data` is null) or an alias kept alive by `parent` (kAlias). Indirected

// through std::function so this header stays free of MetadataBuilder.

std::function<v8::Local<v8::Object>(v8::Local<v8::Context>, const StructInfo&,

void* data, StructStorage storage,

v8::Local<v8::Object> parent)>

StructInstanceFactory;

robin_hood::unordered_map<const InterfaceMeta*,

std::vector<const MethodMeta*>>

Initializers;

std::unique_ptr<v8::Persistent<v8::Function>> EmptyObjCtorFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> SliceFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> OriginalExtendsFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> WeakRefGetterFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> WeakRefClearFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

// console formatter (internal/inspect.js), initialized by Console::Init.

std::unique_ptr<v8::Persistent<v8::Function>> InspectFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

// ns:util's format, used by console.* for %-substitution.

std::unique_ptr<v8::Persistent<v8::Function>> FormatFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

bool FormatFuncUnavailable = false;

std::unique_ptr<v8::Persistent<v8::Function>> InteropReferenceCtorFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> PointerCtorFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> FunctionReferenceCtorFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> UnmanagedTypeCtorFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

// Synthetic ES modules wrapping the `ns:`/`node:` builtin modules

// (NsBuiltinModules), keyed by specifier. Per isolate: a builtin module is a

// singleton per realm, so workers get their own. The exports they wrap live

// in the per-isolate builtin exports cache (BuiltinLoader::GetExports).

robin_hood::unordered_map<std::string,

std::unique_ptr<v8::Persistent<v8::Module>>>

BuiltinModules;

// Specifiers currently being built, so a shim requiring back into the module

// that is loading it fails instead of recursing.

robin_hood::unordered_set<std::string> BuiltinModulesInProgress;

// The `require` handed to every builtin, resolving builtin specifiers only.

std::unique_ptr<v8::Persistent<v8::Function>> BuiltinRequire =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

// Frozen intrinsics snapshot returned by internal/primordials.js, passed to

// every builtin as its second fixed parameter (BuiltinLoader::RunBuiltin).

// Per isolate, so workers snapshot their own realm's intrinsics.

std::unique_ptr<v8::Persistent<v8::Object>> Primordials =

std::unique_ptr<v8::Persistent<v8::Object>>(nullptr);

// Internal EventTarget instance backing the global, returned by the generic

// event-primitives bootstrap IIFE (Events::Init). Holds the real listener

// store, so native layers dispatch through it without going through

// overwritable globals. Cleaned up with the other Persistent members when

// Caches is destroyed, before isolate disposal.

std::unique_ptr<v8::Persistent<v8::Object>> GlobalEventTarget =

std::unique_ptr<v8::Persistent<v8::Object>>(nullptr);

// Phase 2 WHATWG error-events dispatch closures returned by the bootstrap

// IIFE (ErrorEvents::Init). They close over the internal listener store, so

// native dispatch keeps working even if app code overwrites

// globalThis.dispatchEvent. Cleaned up with the other Persistent members when

// Caches is destroyed, before isolate disposal.

std::unique_ptr<v8::Persistent<v8::Function>> DispatchErrorEventFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> DispatchUnhandledRejectionFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>> DispatchRejectionHandledFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

std::unique_ptr<v8::Persistent<v8::Function>>

DispatchReleasedNativeAccessFunc =

std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);

// Phase 3 per-isolate brand for interop.escapeException. An isolate-private

// symbol (v8::Private, not a plain Symbol) so user code cannot discover or

// forge it. Created lazily via ArgConverter::GetEscapeExceptionBrand and used

// to mark/extract escaped native exceptions across JS<->native boundaries.

std::unique_ptr<v8::Persistent<v8::Private>> EscapeExceptionBrand =

std::unique_ptr<v8::Persistent<v8::Private>>(nullptr);

using unique_void_ptr = std::unique_ptr<void, void (*)(void const*)>;

template <typename T>

auto unique_void(T* ptr) -> unique_void_ptr {

return unique_void_ptr(ptr, [](void const* data) {

T const* p = static_cast<T const*>(data);

delete p;

});

}

std::vector<unique_void_ptr> cacheBoundObjects_;

template <typename T>

void registerCacheBoundObject(T* ptr) {

this->cacheBoundObjects_.push_back(unique_void(ptr));

}

private:

// One slot index per state type, handed out process-wide on first use.

static size_t NextStateSlotIndex();

template <typename T>

static size_t StateSlotIndexFor() {

static const size_t index = NextStateSlotIndex();

return index;

}

// Type-erased so Caches need not know any subsystem's state type; the

// deleter restores the type at destruction.

using StateSlot = std::unique_ptr<void, void (*)(void*)>;

template <typename T>

T* GetOrCreateState() {

size_t index = StateSlotIndexFor<T>();

while (this->stateSlots_.size() <= index) {

this->stateSlots_.emplace_back(nullptr, [](void*) {});

}

StateSlot& slot = this->stateSlots_[index];

if (slot == nullptr) {

slot = StateSlot(new T(),

[](void* value) { delete static_cast<T*>(value); });

}

return static_cast<T*>(slot.get());

}

std::vector<StateSlot> stateSlots_;

v8::Isolate* isolate_;

std::shared_ptr<v8::Persistent<v8::Context>> context_;

int isolateId_;

const int gateId_;