env: napi_env,

recv: napi_value,

func: napi_value,

argc: usize,

argv: *const napi_value,

result: *mut napi_value,

env: napi_env,

data: *mut c_void,

length: usize,

finalize_cb: napi_finalize,

finalize_hint: *mut c_void,

result: *mut napi_value,

env: napi_env,

kind: i32,

length: usize,

arraybuffer: napi_value,

byte_offset: usize,

result: *mut napi_value,

env: napi_env,

value: napi_value,

kind: *mut i32,

length: *mut usize,

data: *mut *mut c_void,

arraybuffer: *mut napi_value,

byte_offset: *mut usize,

env: napi_env,

value: napi_value,

byte_length: *mut usize,

data: *mut *mut c_void,

arraybuffer: *mut napi_value,

byte_offset: *mut usize,

env: napi_env,

value: napi_value,

buf: *mut c_char,

bufsize: usize,

result: *mut usize,

if SHUT_DOWN.load(Ordering::Acquire) {

return;

}

let wake = with_queues(|queues| {

let queue = queues.entry(owner).or_default();

queue.jobs.push_back(job);

!std::mem::replace(&mut queue.wake_queued, true)

});

if wake {

wake_owner(owner);

}

let drain = || {

let _ = std::panic::catch_unwind(drain);

};

if crate::worker_threads::is_worker_isolate(owner) {

if !crate::worker_threads::post_to_worker(owner, drain) {

// The worker is gone, and its env with it.

with_queues(|queues| queues.remove(&owner));

}

return;

}

// A dispatcher work item runs between frames, never inside a XAML callout. Hosts without one

// (console apps, tests) drain from their pump loop instead.

if !crate::ui_dispatcher::enqueue_on_ui_thread(drain) {

with_queues(|queues| {

if let Some(queue) = queues.get_mut(&owner) {

queue.wake_queued = false;

}

});

}

let owner = current_owner();

if SHUT_DOWN.load(Ordering::Acquire) || owner == 0 {

return;

}

with_queues(|queues| {

if let Some(queue) = queues.get_mut(&owner) {

queue.wake_queued = false;

}

});

loop {

let job = with_queues(|queues| queues.get_mut(&owner).and_then(|queue| queue.jobs.pop_front()));

let Some(job) = job else { break };

match job {

Job::Tsfn(tsfn) => in_js_scope(|| unsafe { tsfn.dispatch() }),

Job::AsyncComplete(work) => in_js_scope(|| unsafe { AsyncWork::complete(work as *mut AsyncWork) }),

}

}

drain_finalizers();

// A new runtime on this thread loads addons again.

SHUT_DOWN.store(false, Ordering::Release);

ENVS.with(|e| e.borrow_mut().push(env));

let envs: Vec<napi_env> = ENVS.with(|e| e.borrow().clone());

for env in envs {

if unsafe { napi_v8_shim::ns_napi_has_pending_finalizers(env) } {

in_js_scope(|| unsafe { napi_v8_shim::ns_napi_drain_finalizers(env) });

}

}

let envs: Vec<napi_env> = ENVS.with(|e| std::mem::take(&mut *e.borrow_mut()));

if envs.is_empty() {

return;

}

// Deliver what is already queued while everything is still alive, then stop accepting work.

drain();

SHUT_DOWN.store(true, Ordering::Release);

with_queues(|queues| queues.clear());

for &env in envs.iter().rev() {

run_cleanup_hooks(env);

in_js_scope(|| unsafe { napi_v8_shim::ns_napi_env_teardown(env) });

}

let envs: Vec<napi_env> = ENVS.with(|e| std::mem::take(&mut *e.borrow_mut()));

drain();

with_queues(|queues| queues.remove(&current_owner()));

for &env in envs.iter().rev() {

run_cleanup_hooks(env);

in_js_scope(|| unsafe { napi_v8_shim::ns_napi_env_teardown(env) });

}

let isolate_ptr = DELEGATE_ISOLATE_PTR.with(|c| c.get());

if isolate_ptr.is_null() {

return;

}

let isolate: &mut v8::Isolate = unsafe { &mut *isolate_ptr };

v8::scope!(scope, isolate);

let Some(context) = scope.get_slot::<v8::Global<v8::Context>>().cloned() else { return };

let context = v8::Local::new(scope, &context);

let scope = &mut v8::ContextScope::new(scope, context);

v8::tc_scope!(tc, scope);

f();

if tc.has_caught() {

if let Some(exception) = tc.exception() {

let message = exception

.to_string(tc)

.map(|s| s.to_rust_string_lossy(tc))

.unwrap_or_else(|| "<exception>".into());

eprintln!("[NativeScript] uncaught exception in a native addon callback: {message}");

crate::store_last_js_error(message);

}

tc.reset();

}

if !crate::defer_microtask_drain() {

tc.perform_microtask_checkpoint();

}

let mut pending = false;

napi_is_exception_pending(env, &mut pending);

if !pending {

return;

}

let mut error = ptr::null_mut();

napi_get_and_clear_last_exception(env, &mut error);

let mut text = ptr::null_mut();

let mut message = String::from("<exception>");

if napi_coerce_to_string(env, error, &mut text) == NAPI_OK {

let mut len = 0usize;

napi_get_value_string_utf8(env, text, ptr::null_mut(), 0, &mut len);

let mut buf = vec![0u8; len + 1];

napi_get_value_string_utf8(env, text, buf.as_mut_ptr() as *mut c_char, len + 1, &mut len);

buf.truncate(len);

message = String::from_utf8_lossy(&buf).into_owned();

}

eprintln!("[NativeScript] uncaught exception in a native addon callback: {message}");

crate::store_last_js_error(message);

unsafe fn open(env: napi_env) -> HandleScope {

let mut scope = ptr::null_mut();

napi_open_handle_scope(env, &mut scope);

HandleScope(env, scope)

}

fn drop(&mut self) {

unsafe {

napi_close_handle_scope(self.0, self.1);

}

}

static POOL: OnceLock<Mutex<Sender<Task>>> = OnceLock::new();

POOL.get_or_init(|| {

let (tx, rx) = channel::<Task>();

let rx = Arc::new(Mutex::new(rx));

let workers = std::thread::available_parallelism().map_or(2, |n| n.get()).clamp(2, 4);

for i in 0..workers {

let rx = rx.clone();

let _ = std::thread::Builder::new()

.name(format!("napi-worker-{i}"))

.spawn(move || loop {

let task = match rx.lock() {

Ok(rx) => rx.recv(),

Err(_) => return,

};

match task {

Ok(task) => {

let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(task));

}

Err(_) => return,

}

});

}

Mutex::new(tx)

})

queue: VecDeque<*mut c_void>,

thread_count: usize,

closing: bool,

aborted: bool,

finalize_queued: bool,

finalized: bool,

env: napi_env,

owner: usize,

func: napi_ref,

context: *mut c_void,

call_js: napi_threadsafe_function_call_js,

finalize_cb: napi_finalize,

finalize_data: *mut c_void,

max_queue_size: usize,

state: Mutex<TsfnState>,

space: Condvar,

fn from_handle(handle: *mut c_void) -> Option<&'static Tsfn> {

(!handle.is_null()).then(|| unsafe { &*(handle as *const Tsfn) })

}

unsafe fn arc(handle: *mut c_void) -> Arc<Tsfn> {

Arc::increment_strong_count(handle as *const Tsfn);

Arc::from_raw(handle as *const Tsfn)

}

/// JS thread: deliver queued calls, then finalize if the function is done.

unsafe fn dispatch(self: &Arc<Self>) {

loop {

let (data, done) = {

let mut state = self.state.lock().unwrap();

if state.finalized {

return;

}

if state.aborted {

(None, true)

} else {

let data = state.queue.pop_front();

self.space.notify_one();

let done = data.is_none() && state.thread_count == 0;

(data, done)

}

};

match data {

Some(data) => self.call(data),

None => {

if done {

self.finalize();

}

return;

}

}

}

}

unsafe fn call(&self, data: *mut c_void) {

let _scope = HandleScope::open(self.env);

let mut func = ptr::null_mut();

if !self.func.is_null() {

napi_get_reference_value(self.env, self.func, &mut func);

}

match self.call_js {

Some(call_js) => call_js(self.env, func, self.context, data),

None if !func.is_null() => {

let mut recv = ptr::null_mut();

napi_get_undefined(self.env, &mut recv);

let mut result = ptr::null_mut();

napi_call_function(self.env, recv, func, 0, ptr::null(), &mut result);

}

None => {}

}

report_pending(self.env);

}

unsafe fn finalize(self: &Arc<Self>) {

let leftover = {

let mut state = self.state.lock().unwrap();

if state.finalized {

return;

}

state.finalized = true;

state.closing = true;

self.space.notify_all();

std::mem::take(&mut state.queue)

};

// Items never delivered (abort) still go to call_js, with a null env, so the addon can

// free them -- Node's contract.

if let Some(call_js) = self.call_js {

for data in leftover {

call_js(ptr::null_mut(), ptr::null_mut(), self.context, data);

}

}

let _scope = HandleScope::open(self.env);

if let Some(finalize) = self.finalize_cb {

finalize(self.env, self.finalize_data, self.context);

report_pending(self.env);

}

if !self.func.is_null() {

napi_delete_reference(self.env, self.func);

}

// The handle's own reference.

drop(Arc::from_raw(Arc::as_ptr(self)));

}

fn queue_finalize(self: &Arc<Self>, state: &mut TsfnState) {

if !state.finalize_queued {

state.finalize_queued = true;

push(self.owner, Job::Tsfn(self.clone()));

}

}

env: napi_env,

func: napi_value,

_async_resource: napi_value,

_async_resource_name: napi_value,

max_queue_size: usize,

initial_thread_count: usize,

thread_finalize_data: *mut c_void,

thread_finalize_cb: napi_finalize,

context: *mut c_void,

call_js_cb: napi_threadsafe_function_call_js,

result: *mut *mut c_void,

) -> napi_status {

if env.is_null() || result.is_null() || initial_thread_count == 0 || (func.is_null() && call_js_cb.is_none()) {

return NAPI_INVALID_ARG;

}

let mut reference = ptr::null_mut();

if !func.is_null() && napi_create_reference(env, func, 1, &mut reference) != NAPI_OK {

return NAPI_GENERIC_FAILURE;

}

let tsfn = Arc::new(Tsfn {

env,

owner: current_owner(),

func: reference,

context,

call_js: call_js_cb,

finalize_cb: thread_finalize_cb,

finalize_data: thread_finalize_data,

max_queue_size,

state: Mutex::new(TsfnState {

queue: VecDeque::new(),

thread_count: initial_thread_count,

closing: false,

aborted: false,

finalize_queued: false,

finalized: false,

}),

space: Condvar::new(),

});

*result = Arc::into_raw(tsfn) as *mut c_void;

NAPI_OK

let Some(tsfn) = Tsfn::from_handle(func) else { return NAPI_INVALID_ARG };

let mut state = tsfn.state.lock().unwrap();

loop {

if state.closing || state.aborted {

return NAPI_CLOSING;

}

if tsfn.max_queue_size == 0 || state.queue.len() < tsfn.max_queue_size {

break;

}

if is_blocking == 0 {

return NAPI_QUEUE_FULL;

}

state = tsfn.space.wait(state).unwrap();

}

state.queue.push_back(data);

drop(state);

push(tsfn.owner, Job::Tsfn(Tsfn::arc(func)));

NAPI_OK

let Some(tsfn) = Tsfn::from_handle(func) else { return NAPI_INVALID_ARG };

let mut state = tsfn.state.lock().unwrap();

if state.closing || state.aborted {

return NAPI_CLOSING;

}

state.thread_count += 1;

NAPI_OK

let Some(tsfn) = Tsfn::from_handle(func) else { return NAPI_INVALID_ARG };

let arc = Tsfn::arc(func);

let mut state = tsfn.state.lock().unwrap();

if state.thread_count == 0 {

return NAPI_INVALID_ARG;

}

state.thread_count -= 1;

if mode == 1 {

// napi_tsfn_abort

state.closing = true;

state.aborted = true;

tsfn.space.notify_all();

}

if state.thread_count == 0 || state.aborted {

state.closing = true;

arc.queue_finalize(&mut state);

}

NAPI_OK

let Some(tsfn) = Tsfn::from_handle(func) else { return NAPI_INVALID_ARG };

if result.is_null() {

return NAPI_INVALID_ARG;

}

*result = tsfn.context;

NAPI_OK

env: napi_env,

owner: usize,

execute: napi_async_execute_callback,

complete: napi_async_complete_callback,

data: *mut c_void,

state: AtomicU8,

/// JS thread. `complete` may free the work (`napi_delete_async_work`), as Node allows and

/// napi-rs does, so nothing reads `work` after calling it.

unsafe fn complete(work: *mut AsyncWork) {

let (env, complete, data) = {

let work = &*work;

let status = if work.state.swap(WORK_IDLE, Ordering::AcqRel) == WORK_CANCELLED {

NAPI_CANCELLED

} else {

NAPI_OK

};

(work.env, work.complete.map(|complete| (complete, status)), work.data)

};

if let Some((complete, status)) = complete {

let _scope = HandleScope::open(env);

complete(env, status, data);

report_pending(env);

}

}

env: napi_env,

_async_resource: napi_value,

_async_resource_name: napi_value,

execute: napi_async_execute_callback,

complete: napi_async_complete_callback,

data: *mut c_void,

result: *mut *mut c_void,

) -> napi_status {

if env.is_null() || execute.is_none() || result.is_null() {

return NAPI_INVALID_ARG;

}

*result = Box::into_raw(Box::new(AsyncWork {

env,

owner: current_owner(),

execute,

complete,

data,

state: AtomicU8::new(WORK_IDLE),

})) as *mut c_void;

NAPI_OK

if work.is_null() {

return NAPI_INVALID_ARG;

}

drop(Box::from_raw(work as *mut AsyncWork));

NAPI_OK

if work.is_null() {

return NAPI_INVALID_ARG;

}

let entry = &*(work as *const AsyncWork);

if entry

.state

.compare_exchange(WORK_IDLE, WORK_QUEUED, Ordering::AcqRel, Ordering::Acquire)

.is_err()

{

return NAPI_GENERIC_FAILURE;

}

let address = work as usize;

let owner = entry.owner;

let task: Task = Box::new(move || {

let work = unsafe { &*(address as *const AsyncWork) };

if work

.state

.compare_exchange(WORK_QUEUED, WORK_RUNNING, Ordering::AcqRel, Ordering::Acquire)

.is_ok()

{

if let Some(execute) = work.execute {

unsafe { execute(work.env, work.data) };

}

}

push(owner, Job::AsyncComplete(address));

});

match pool().lock() {

Ok(tx) if tx.send(task).is_ok() => NAPI_OK,

_ => NAPI_GENERIC_FAILURE,

}

if work.is_null() {

return NAPI_INVALID_ARG;

}

let work = &*(work as *const AsyncWork);

match work

.state

.compare_exchange(WORK_QUEUED, WORK_CANCELLED, Ordering::AcqRel, Ordering::Acquire)

{

Ok(_) => NAPI_OK,

Err(_) => NAPI_GENERIC_FAILURE,

}

hook: unsafe extern "C" fn(*mut c_void, *mut c_void),

arg: *mut c_void,

env: napi_env,

let (Some(fun), false) = (fun, env.is_null()) else { return NAPI_INVALID_ARG };

with_hooks(|hooks| hooks.entry(env as usize).or_default().push(Hook::Sync(fun, arg as usize)));

NAPI_OK

let (Some(fun), false) = (fun, env.is_null()) else { return NAPI_INVALID_ARG };

with_hooks(|hooks| {

if let Some(list) = hooks.get_mut(&(env as usize)) {