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

napi_finalize cb = nullptr;

void* data = nullptr;

void* hint = nullptr;

public:

// Creates the env for `context` and hands ownership to the caller, which

// must eventually pass it to Destroy while the isolate is alive and locked.

static NapiEnv* Create(v8::Local<v8::Context> context);

static void Destroy(NapiEnv* env);

// Null when the isolate has no runtime, or before Runtime::Init reaches the

// env, or after teardown.

static NapiEnv* ForIsolate(v8::Isolate* isolate);

bool can_call_into_js() const override { return !tearingDown_; }

void CallFinalizer(napi_finalize cb, void* data, void* hint) override;

void EnqueueFinalizer(v8impl::RefTracker* finalizer) override;

void DeleteMe() override;

v8::Local<v8::Private> PrivateKey(NapiPrivateKeySlot slot);

// The runloop of the thread that owns this env — identity checks only

// (is-this-the-env's-thread); work is posted through GetEventLoop().

CFRunLoopRef RuntimeLoop() const { return runtimeLoop_; }

// The runtime's event loop, or null once ~Runtime released it. Between

// Shutdown and that release it is still returned, and posts to it are

// dropped (Post* returns false). Posted internal-lane entries run on the

// env's thread under the loop's Locker/scopes and end with a microtask

// checkpoint.

std::shared_ptr<EventLoop> GetEventLoop() const { return eventLoop_.lock(); }

// Exports of an addon already initialized in this env, or an empty handle.

v8::MaybeLocal<v8::Object> CachedModuleExports(const std::string& name);

void CacheModuleExports(const std::string& name,

v8::Local<v8::Object> exports);

// External-buffer finalizer registry, env thread only. Registered entries

// are claimed+run either by a posted backing-store deleter or by the

// teardown sweep in DeleteMe, whichever gets there first.

void RegisterExternalFinalizer(

const std::shared_ptr<NapiExternalFinalizer>& finalizer);

void RunExternalFinalizer(

const std::shared_ptr<NapiExternalFinalizer>& finalizer);

private:

explicit NapiEnv(v8::Local<v8::Context> context);

~NapiEnv() override;

void DrainFinalizers();

CFRunLoopRef runtimeLoop_ = nullptr;

std::weak_ptr<EventLoop> eventLoop_;

bool tearingDown_ = false;

v8::Eternal<v8::Private> privateKeys_[2];

std::unordered_map<std::string, v8::Global<v8::Object>> moduleExports_;

std::unordered_set<std::shared_ptr<NapiExternalFinalizer>>

externalFinalizers_;