Skip to main content

redjs_webgpu/
lib.rs

1//! Native WebGPU over the same wgpu revision as the host renderer.
2//!
3//! Opt-in while canvas presentation is being integrated. JSC objects own logical
4//! clients, not the physical device: embedders may supply an existing context.
5//! WGSL always goes through wgpu validation; no shader passthrough is exposed.
6//!
7//! [`register`] once, before the contexts that should have WebGPU are installed.
8pub mod backend;
9mod buffer;
10mod bundle;
11pub mod canvas;
12mod compute;
13mod query;
14mod readback;
15#[cfg(test)]
16mod tests;
17mod texture;
18
19use backend::{Adapter, Client};
20use core::ffi::c_void;
21use redjs::webapi::util::*;
22use redjs::{capi, glue};
23use std::collections::{HashMap, VecDeque};
24use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
25use std::sync::{Arc, Mutex, OnceLock};
26
27/// Makes every redjs context installed after this call carry `navigator.gpu`.
28pub fn register() {
29    redjs::webapi::gpu_ext::register(&Extension);
30}
31
32struct Extension;
33impl redjs::webapi::gpu_ext::GpuExtension for Extension {
34    unsafe fn install(&self, g: *mut c_void) {
35        install(g);
36    }
37    fn forget(&self, gone: redjs::context::Gone) {
38        forget(gone);
39    }
40    unsafe fn pump(&self, g: *mut c_void) {
41        canvas::pump(g);
42    }
43    unsafe fn create_context(&self, g: *mut c_void, owner: u64, w: u32, h: u32) -> u64 {
44        canvas::create(g, owner, w, h, None)
45    }
46    unsafe fn resize(&self, g: *mut c_void, ctx: u64, w: u32, h: u32) {
47        let _ = canvas::resize(g, ctx, w, h);
48    }
49    unsafe fn is_context(&self, g: *mut c_void, v: u64) -> bool {
50        canvas::is_context(g, v)
51    }
52    unsafe fn pixels(&self, g: *mut c_void, v: u64) -> redjs::webapi::gpu_ext::Pixels {
53        canvas::pixels(g, v)
54    }
55    unsafe fn premul_pixels(&self, g: *mut c_void, v: u64) -> redjs::webapi::gpu_ext::Pixels {
56        canvas::premul_pixels(g, v)
57    }
58    unsafe fn convert_to_blob(&self, g: *mut c_void, ctx: u64, options: u64) -> u64 {
59        canvas::convert_to_blob(g, ctx, options)
60    }
61    unsafe fn transfer_to_image_bitmap(&self, g: *mut c_void, ctx: u64) -> u64 {
62        canvas::transfer(g, ctx)
63    }
64}
65
66#[derive(Clone, Copy, PartialEq, Eq, Hash)]
67enum Kind {
68    Gpu,
69    Canvas,
70    Adapter,
71    Device,
72    Queue,
73    Features,
74    Limits,
75    AdapterInfo,
76    LostInfo,
77    Buffer,
78    Shader,
79    BindGroupLayout,
80    PipelineLayout,
81    BindGroup,
82    ComputePipeline,
83    Encoder,
84    ComputePass,
85    CommandBuffer,
86    Texture,
87    TextureView,
88    Sampler,
89    RenderPipeline,
90    RenderPass,
91    QuerySet,
92    BundleEncoder,
93    Bundle,
94    LanguageFeatures,
95}
96#[derive(Clone)]
97enum Resource {
98    Gpu,
99    Canvas(Arc<canvas::Surface>),
100    Adapter(Arc<Adapter>),
101    Device,
102    Queue,
103    Features(Arc<[&'static str]>),
104    Buffer(Arc<buffer::Buffer>),
105    Shader(compute::Shader),
106    BindGroupLayout(wgpu::BindGroupLayout),
107    PipelineLayout(wgpu::PipelineLayout),
108    BindGroup(compute::BindGroup),
109    ComputePipeline(wgpu::ComputePipeline),
110    Encoder(Arc<Mutex<compute::Encoder>>),
111    ComputePass(Arc<Mutex<compute::ComputePass>>),
112    CommandBuffer(Arc<Mutex<compute::CommandBuffer>>),
113    Texture(Arc<texture::Texture>),
114    TextureView(texture::TextureView),
115    Sampler(wgpu::Sampler),
116    RenderPipeline(wgpu::RenderPipeline),
117    RenderPass(Arc<Mutex<texture::RenderPass>>),
118    QuerySet(Arc<query::QuerySet>),
119    BundleEncoder(Arc<Mutex<bundle::Encoder>>),
120    Bundle(Arc<bundle::Bundle>),
121}
122#[derive(Clone)]
123struct Handle {
124    pub kind: Kind,
125    pub client: Option<Arc<Client>>,
126    pub resource: Resource,
127}
128struct Classes {
129    array_values: u64,
130    s_features: usize,
131    s_limits: usize,
132    s_info: usize,
133    weak_ctor: u64,
134    weak_deref: u64,
135    error_protos: HashMap<&'static str, u64>,
136    hosts: HashMap<Kind, usize>,
137    types: HashMap<Kind, Class>,
138    array_from: u64,
139    s_gpu_canvas: usize,
140    s_gpu_device: usize,
141    s_gpu_texture: usize,
142    s_ranges: usize,
143    s_lost: usize,
144    s_resolve_lost: usize,
145    s_label: usize,
146    s_handlers: usize,
147    s_language: usize,
148    s_reason: usize,
149    pipeline_error_proto: u64,
150}
151unsafe impl Send for Classes {}
152struct Pending {
153    resolve: u64,
154    reject: u64,
155    roots: Vec<u64>,
156}
157struct ClientRef {
158    weak: u64,
159    client: std::sync::Weak<Client>,
160    buffers: Vec<u64>,
161    lost: bool,
162}
163struct Scope {
164    filter: String,
165    error: Option<backend::GpuError>,
166}
167#[derive(Default)]
168struct State {
169    classes: Option<Classes>,
170    pending: HashMap<u64, Pending>,
171    ready: VecDeque<Box<dyn FnOnce(*mut c_void) + Send>>,
172    clients: HashMap<u64, ClientRef>,
173    scopes: HashMap<u64, Vec<Scope>>,
174}
175fn states() -> &'static Mutex<HashMap<usize, State>> {
176    static S: OnceLock<Mutex<HashMap<usize, State>>> = OnceLock::new();
177    S.get_or_init(Default::default)
178}
179
180/// A temporary GC root. Descriptor getters may allocate, force GC, or reenter.
181struct Val {
182    pub g: *mut c_void,
183    pub v: u64,
184}
185impl Val {
186    pub unsafe fn new(g: *mut c_void, v: u64) -> Self {
187        if is_cell(v) {
188            redjs::ffi::redjs_protect(g, v);
189        }
190        Self { g, v }
191    }
192}
193impl Drop for Val {
194    fn drop(&mut self) {
195        if is_cell(self.v) {
196            unsafe {
197                redjs::ffi::redjs_unprotect(self.g, self.v);
198            }
199        }
200    }
201}
202// Internal arrays are GC edges. Create own data properties rather than invoking
203// an application-defined Array.prototype[index] setter.
204unsafe fn set_i(g: *mut c_void, obj: u64, index: u32, value: u64) {
205    assert_eq!(
206        glue::rjs_define_index(g, obj, index, value),
207        0,
208        "WebGPU internal array property creation failed"
209    );
210}
211unsafe fn field(g: *mut c_void, obj: u64, key: &str) -> Result<Val, ()> {
212    if obj == UNDEF || obj == NULL {
213        return Ok(Val::new(g, UNDEF));
214    }
215    Ok(Val::new(g, try_get(g, obj, key)?))
216}
217unsafe fn text(g: *mut c_void, v: u64, default: &str) -> Result<String, ()> {
218    if v == UNDEF {
219        return Ok(default.into());
220    }
221    let s = to_js_string(g, v)?;
222    Ok(read_string(g, s).unwrap_or_default())
223}
224unsafe fn num(g: *mut c_void, v: u64, default: u64) -> Result<u64, ()> {
225    if v == UNDEF {
226        Ok(default)
227    } else {
228        enforce_range_u64(g, v, "WebGPU integer")
229    }
230}
231unsafe fn uint(g: *mut c_void, v: u64, default: u32) -> Result<u32, ()> {
232    let n = num(g, v, default as u64)?;
233    if n > u32::MAX as u64 {
234        throw_type_error(g, "WebGPU integer exceeds unsigned long");
235        return Err(());
236    }
237    Ok(n as u32)
238}
239unsafe fn boolean(g: *mut c_void, v: u64) -> bool {
240    glue::rjs_to_boolean(g, v) != 0
241}
242unsafe fn seq(g: *mut c_void, v: u64) -> Result<Vec<Val>, ()> {
243    if v == UNDEF {
244        return Ok(Vec::new());
245    }
246    let f = states().lock().unwrap()[&(g as usize)]
247        .classes
248        .as_ref()
249        .unwrap()
250        .array_from;
251    let arr = match call(g, f, UNDEF, &[v]) {
252        Ok(a) => Val::new(g, a),
253        Err(e) => {
254            glue::rjs_throw(g, e);
255            return Err(());
256        }
257    };
258    let n = uint(g, field(g, arr.v, "length")?.v, 0)?;
259    if n > 65536 {
260        throw_type_error(g, "WebGPU descriptor sequence is too large");
261        return Err(());
262    }
263    (0..n).map(|i| field(g, arr.v, &i.to_string())).collect()
264}
265unsafe fn try_handle(g: *mut c_void, v: u64, kind: Kind) -> Option<Handle> {
266    let cls = states()
267        .lock()
268        .unwrap()
269        .get(&(g as usize))
270        .and_then(|s| s.classes.as_ref())
271        .and_then(|c| c.hosts.get(&kind).copied())
272        .map(|c| c as capi::JSClassRef)?;
273    host_data::<Handle>(g, cls, v)
274        .filter(|h| h.kind == kind)
275        .map(|h| h.clone())
276}
277unsafe fn handle(g: *mut c_void, v: u64, kind: Kind) -> Result<Handle, ()> {
278    if let Some(h) = try_handle(g, v, kind) {
279        return Ok(h);
280    }
281    throw_type_error(g, "WebGPU object has the wrong interface or receiver");
282    Err(())
283}
284unsafe fn with_classes<T>(g: *mut c_void, f: impl FnOnce(&Classes) -> T) -> T {
285    f(states().lock().unwrap()[&(g as usize)]
286        .classes
287        .as_ref()
288        .unwrap())
289}
290unsafe fn this(g: *mut c_void, cf: *mut c_void, kind: Kind) -> Result<Handle, ()> {
291    handle(g, cf_this(cf), kind)
292}
293unsafe fn client(g: *mut c_void, h: &Handle) -> Result<Arc<Client>, ()> {
294    let c = h.client.as_ref().unwrap().clone();
295    if let Err(e) = c.check() {
296        redjs::webapi::domexception::throw(g, "InvalidStateError", &e);
297        return Err(());
298    }
299    Ok(c)
300}
301unsafe fn owned(g: *mut c_void, v: u64, kind: Kind, c: &Arc<Client>) -> Result<Handle, ()> {
302    let h = handle(g, v, kind)?;
303    if h.client.as_ref().map(|x| x.id) != Some(c.id) {
304        throw_type_error(g, "WebGPU resource belongs to a different device");
305        return Err(());
306    }
307    Ok(h)
308}
309unsafe fn wrap(g: *mut c_void, kind: Kind, c: Option<Arc<Client>>, r: Resource) -> u64 {
310    let (cls, proto) = {
311        let s = states().lock().unwrap();
312        let cs = s[&(g as usize)].classes.as_ref().unwrap();
313        (cs.hosts[&kind] as capi::JSClassRef, cs.types[&kind].proto)
314    };
315    host_create(
316        g,
317        cls,
318        proto,
319        Handle {
320            kind,
321            client: c,
322            resource: r,
323        },
324    )
325}
326unsafe fn wrap_labeled(
327    g: *mut c_void,
328    kind: Kind,
329    c: Option<Arc<Client>>,
330    r: Resource,
331    label: &str,
332) -> u64 {
333    let o = Val::new(g, wrap(g, kind, c, r));
334    set_label(g, o.v, label);
335    o.v
336}
337unsafe fn set_label(g: *mut c_void, obj: u64, label: &str) {
338    if label.is_empty() {
339        return;
340    }
341    let slot = with_classes(g, |c| c.s_label);
342    let s = Val::new(g, js_string(g, label));
343    glue::rjs_define(g, obj, slot as *mut c_void, s.v, 2);
344}
345unsafe fn object_base(g: *mut c_void, v: u64) -> Result<(), ()> {
346    let hosts: Vec<_> = with_classes(g, |c| c.hosts.values().copied().collect());
347    if hosts
348        .into_iter()
349        .any(|h| host_data::<Handle>(g, h as capi::JSClassRef, v).is_some())
350    {
351        return Ok(());
352    }
353    invalid(g, "WebGPU object has the wrong interface or receiver")
354}
355#[redjs::host_fn]
356unsafe fn label_get(g: *mut c_void, cf: *mut c_void) -> u64 {
357    run(g, || {
358        object_base(g, cf_this(cf))?;
359        let slot = with_classes(g, |c| c.s_label);
360        let v = get_a(g, cf_this(cf), slot as *mut c_void);
361        Ok(if v == UNDEF { js_string(g, "") } else { v })
362    })
363}
364#[redjs::host_fn]
365unsafe fn label_set(g: *mut c_void, cf: *mut c_void) -> u64 {
366    run(g, || {
367        object_base(g, cf_this(cf))?;
368        let s = Val::new(g, to_js_string(g, cf_arg(cf, 0))?);
369        let slot = with_classes(g, |c| c.s_label);
370        glue::rjs_define(g, cf_this(cf), slot as *mut c_void, s.v, 2);
371        Ok(UNDEF)
372    })
373}
374unsafe fn rejected_from_exception(g: *mut c_void) -> u64 {
375    let mut e = UNDEF;
376    if glue::rjs_exception_pending(g, &mut e) == 0 {
377        return UNDEF;
378    }
379    let e = Val::new(g, e);
380    redjs::webapi::domexception::rejected_with(g, e.v)
381}
382unsafe fn invalid(g: *mut c_void, msg: &str) -> Result<(), ()> {
383    throw_type_error(g, msg);
384    Err(())
385}
386// Canvas texture destruction closes JS write access while its drawing buffer
387// remains readable by the presenter. Recorded commands must honor that logical
388// lifetime even though the underlying native texture is still alive.
389fn resource_alive(r: &Resource) -> bool {
390    match r {
391        Resource::Buffer(b) => !b.destroyed.load(Ordering::Acquire),
392        Resource::Texture(t) => !t.destroyed.load(Ordering::Acquire),
393        Resource::TextureView(v) => !v._owner.destroyed.load(Ordering::Acquire),
394        Resource::BindGroup(b) => b._resources.iter().all(resource_alive),
395        Resource::QuerySet(q) => !q.destroyed.load(Ordering::Acquire),
396        Resource::Bundle(b) => b.resources.iter().all(resource_alive),
397        _ => true,
398    }
399}
400unsafe fn validation(g: *mut c_void, c: &Arc<Client>, msg: &str) {
401    route_errors(
402        g,
403        c.id,
404        vec![backend::GpuError {
405            kind: "validation",
406            message: msg.into(),
407        }],
408    );
409}
410unsafe fn checked<T>(g: *mut c_void, c: &Arc<Client>, f: impl FnOnce() -> T) -> T {
411    let out = c.checked(f);
412    route_errors(g, c.id, c.take_errors());
413    out
414}
415unsafe fn error_object(g: *mut c_void, e: backend::GpuError) -> u64 {
416    let name = match e.kind {
417        "out-of-memory" => "GPUOutOfMemoryError",
418        "internal" => "GPUInternalError",
419        _ => "GPUValidationError",
420    };
421    let proto = states().lock().unwrap()[&(g as usize)]
422        .classes
423        .as_ref()
424        .unwrap()
425        .error_protos[name];
426    let o = Val::new(g, new_object(g, proto));
427    define(g, o.v, "message", js_string(g, &e.message), 1 | 2);
428    o.v
429}
430unsafe fn route_errors(g: *mut c_void, id: u64, errors: Vec<backend::GpuError>) {
431    for e in errors {
432        let uncaptured = {
433            let mut ss = states().lock().unwrap();
434            let scopes = ss
435                .get_mut(&(g as usize))
436                .unwrap()
437                .scopes
438                .entry(id)
439                .or_default();
440            if let Some(scope) = scopes.iter_mut().rev().find(|x| x.filter == e.kind) {
441                if scope.error.is_none() {
442                    scope.error = Some(e);
443                }
444                None
445            } else {
446                Some(e)
447            }
448        };
449        if let Some(e) = uncaptured {
450            states()
451                .lock()
452                .unwrap()
453                .get_mut(&(g as usize))
454                .unwrap()
455                .ready
456                .push_back(Box::new(move |g| unsafe {
457                    if let Some(target) = device_target(g, id) {
458                        let error = Val::new(g, error_object(g, e));
459                        let event = Val::new(
460                            g,
461                            redjs::webapi::events::new_trusted_event(g, "uncapturederror"),
462                        );
463                        define(g, event.v, "error", error.v, 1 | 2);
464                        let proto = states().lock().unwrap()[&(g as usize)]
465                            .classes
466                            .as_ref()
467                            .unwrap()
468                            .error_protos["GPUUncapturedErrorEvent"];
469                        capi::JSObjectSetPrototype(
470                            g,
471                            event.v as usize as capi::JSObjectRef,
472                            proto as usize as capi::JSValueRef,
473                        );
474                        redjs::webapi::events::dispatch(g, target.v, event.v);
475                    }
476                }));
477        }
478    }
479}
480#[redjs::host_fn]
481unsafe fn gpu_error_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
482    run(g, || {
483        let message = text(g, cf_arg(cf, 0), "")?;
484        let o = Val::new(g, ordinary_create(g, cf_new_target(cf), UNDEF));
485        define(g, o.v, "message", js_string(g, &message), 1 | 2);
486        Ok(o.v)
487    })
488}
489#[redjs::host_fn]
490unsafe fn error_event_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
491    run(g, || {
492        let init = Val::new(g, cf_arg(cf, 1));
493        let error = field(g, init.v, "error")?;
494        if !is_cell(error.v) {
495            invalid(g, "GPUUncapturedErrorEvent requires an error")?;
496        }
497        let o = Val::new(
498            g,
499            ordinary_create(
500                g,
501                cf_new_target(cf),
502                redjs::webapi::util::state(g).event.proto,
503            ),
504        );
505        redjs::webapi::events::init_event(g, o.v, cf_arg(cf, 0), init.v, false);
506        define(g, o.v, "error", error.v, 1 | 2);
507        Ok(o.v)
508    })
509}
510
511/// Promise completions own only protected values while their context is alive.
512/// Workers carry Rust resources, never JS heap pointers; recycled addresses are
513/// fenced by ContextId before enqueueing on the context pump.
514unsafe fn async_op<T, F, C>(g: *mut c_void, roots: Vec<u64>, work: F, convert: C) -> u64
515where
516    T: Send + 'static,
517    F: std::future::Future<Output = Result<T, String>> + Send + 'static,
518    C: FnOnce(*mut c_void, T) -> u64 + Send + 'static,
519{
520    async_settle(g, roots, work, move |g, value| Ok(convert(g, value)))
521}
522unsafe fn async_settle<T, F, C>(g: *mut c_void, roots: Vec<u64>, work: F, convert: C) -> u64
523where
524    T: Send + 'static,
525    F: std::future::Future<Output = Result<T, String>> + Send + 'static,
526    C: FnOnce(*mut c_void, T) -> Result<u64, u64> + Send + 'static,
527{
528    static NEXT: AtomicU64 = AtomicU64::new(1);
529    let (mut resolve, mut reject, mut p) = (UNDEF, UNDEF, UNDEF);
530    if redjs::ffi::redjs_promise_create(g, &mut resolve, &mut reject, &mut p) != 0 {
531        return UNDEF;
532    }
533    for &v in roots.iter().chain([&resolve, &reject]) {
534        if is_cell(v) {
535            redjs::ffi::redjs_protect(g, v);
536        }
537    }
538    let n = NEXT.fetch_add(1, Ordering::Relaxed);
539    let id = redjs::context::id_of(g);
540    let address = g as usize;
541    states()
542        .lock()
543        .unwrap()
544        .get_mut(&address)
545        .unwrap()
546        .pending
547        .insert(
548            n,
549            Pending {
550                resolve,
551                reject,
552                roots,
553            },
554        );
555    let worker = std::thread::Builder::new()
556        .name("redjs-webgpu".into())
557        .spawn(move || {
558            let result =
559                std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| pollster::block_on(work)))
560                    .unwrap_or_else(|_| Err("Native WebGPU asynchronous operation failed".into()));
561            let mut ss = states().lock().unwrap();
562            if redjs::context::id_of(address as *mut c_void) != id {
563                return;
564            }
565            let Some(st) = ss.get_mut(&address) else {
566                return;
567            };
568            st.ready.push_back(Box::new(move |g| unsafe {
569                let pending = states()
570                    .lock()
571                    .unwrap()
572                    .get_mut(&(g as usize))
573                    .and_then(|s| s.pending.remove(&n));
574                let Some(pending) = pending else {
575                    return;
576                };
577                match result {
578                    Ok(value) => {
579                        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
580                            convert(g, value)
581                        })) {
582                            Ok(Ok(value)) => {
583                                let value = Val::new(g, value);
584                                let _ = call(g, pending.resolve, UNDEF, &[value.v]);
585                            }
586                            Ok(Err(reason)) => {
587                                let reason = Val::new(g, reason);
588                                let _ = call(g, pending.reject, UNDEF, &[reason.v]);
589                            }
590                            Err(_) => {
591                                let err = Val::new(
592                                    g,
593                                    redjs::webapi::domexception::create(
594                                        g,
595                                        "OperationError",
596                                        "Native WebGPU completion failed",
597                                    ),
598                                );
599                                let _ = call(g, pending.reject, UNDEF, &[err.v]);
600                            }
601                        }
602                    }
603                    Err(message) => {
604                        let err = Val::new(
605                            g,
606                            redjs::webapi::domexception::create(g, "OperationError", &message),
607                        );
608                        let _ = call(g, pending.reject, UNDEF, &[err.v]);
609                    }
610                }
611                for v in pending
612                    .roots
613                    .into_iter()
614                    .chain([pending.resolve, pending.reject])
615                {
616                    if is_cell(v) {
617                        redjs::ffi::redjs_unprotect(g, v);
618                    }
619                }
620            }));
621            drop(ss);
622            if let Some(id) = id {
623                redjs::web::wake(id);
624            }
625        });
626    if let Err(error) = worker {
627        let pending = states()
628            .lock()
629            .unwrap()
630            .get_mut(&address)
631            .unwrap()
632            .pending
633            .remove(&n)
634            .unwrap();
635        let e = Val::new(
636            g,
637            redjs::webapi::domexception::create(g, "OperationError", &error.to_string()),
638        );
639        let _ = call(g, pending.reject, UNDEF, &[e.v]);
640        for v in pending
641            .roots
642            .into_iter()
643            .chain([pending.resolve, pending.reject])
644        {
645            if is_cell(v) {
646                redjs::ffi::redjs_unprotect(g, v);
647            }
648        }
649    }
650    p
651}
652unsafe fn inflight(g: *mut c_void) -> bool {
653    states()
654        .lock()
655        .unwrap()
656        .get(&(g as usize))
657        .is_some_and(|s| !s.pending.is_empty())
658}
659unsafe fn ready(g: *mut c_void) -> bool {
660    states()
661        .lock()
662        .unwrap()
663        .get(&(g as usize))
664        .is_some_and(|s| {
665            !s.ready.is_empty()
666                || s.clients.values().any(|r| {
667                    r.client
668                        .upgrade()
669                        .is_some_and(|c| c.has_errors() || (!r.lost && c.context.loss().is_some()))
670                })
671        })
672}
673unsafe fn drain(g: *mut c_void) -> usize {
674    let tasks = states()
675        .lock()
676        .unwrap()
677        .get_mut(&(g as usize))
678        .map(|s| std::mem::take(&mut s.ready))
679        .unwrap_or_default();
680    let mut n = tasks.len();
681    for task in tasks {
682        task(g);
683        redjs::web::checkpoint(g);
684    }
685    let clients: Vec<_> = states()
686        .lock()
687        .unwrap()
688        .get(&(g as usize))
689        .map(|s| {
690            s.clients
691                .values()
692                .filter_map(|r| r.client.upgrade())
693                .collect()
694        })
695        .unwrap_or_default();
696    for c in clients {
697        route_errors(g, c.id, c.take_errors());
698    }
699    let ids: Vec<_> = states()
700        .lock()
701        .unwrap()
702        .get(&(g as usize))
703        .map(|s| {
704            s.clients
705                .iter()
706                .filter_map(|(&id, r)| {
707                    (!r.lost)
708                        .then(|| r.client.upgrade())
709                        .flatten()
710                        .and_then(|c| c.context.loss().map(|l| (id, l)))
711                })
712                .collect()
713        })
714        .unwrap_or_default();
715    for (id, loss) in ids {
716        release_buffers(g, id);
717        canvas::device_destroyed(id);
718        if let Some(target) = device_target(g, id) {
719            resolve_loss(g, target.v, loss.reason, &loss.message);
720        } else if let Some(r) = states()
721            .lock()
722            .unwrap()
723            .get_mut(&(g as usize))
724            .and_then(|s| s.clients.get_mut(&id))
725        {
726            r.lost = true;
727        }
728        n += 1;
729    }
730    n
731}
732
733#[redjs::host_fn]
734unsafe fn request_adapter(g: *mut c_void, cf: *mut c_void) -> u64 {
735    run(g, || {
736        this(g, cf, Kind::Gpu)?;
737        let o = Val::new(g, cf_arg(cf, 0));
738        let power = text(g, field(g, o.v, "powerPreference")?.v, "")?;
739        let power_preference = match power.as_str() {
740            "" => wgpu::PowerPreference::None,
741            "low-power" => wgpu::PowerPreference::LowPower,
742            "high-performance" => wgpu::PowerPreference::HighPerformance,
743            _ => {
744                invalid(g, "Invalid GPUPowerPreference")?;
745                unreachable!()
746            }
747        };
748        let fallback = boolean(g, field(g, o.v, "forceFallbackAdapter")?.v);
749        Ok(async_op(
750            g,
751            vec![],
752            async move {
753                backend::request_adapter(backend::AdapterOptions {
754                    power_preference,
755                    force_fallback_adapter: fallback,
756                })
757                .await
758            },
759            |g, a| match a {
760                Some(a) => wrap(g, Kind::Adapter, None, Resource::Adapter(Arc::new(a))),
761                None => NULL,
762            },
763        ))
764    })
765}
766#[redjs::host_fn]
767unsafe fn preferred_format(g: *mut c_void, cf: *mut c_void) -> u64 {
768    run(g, || {
769        this(g, cf, Kind::Gpu)?;
770        Ok(js_string(g, "bgra8unorm"))
771    })
772}
773unsafe fn features_object(g: *mut c_void, features: wgpu::Features) -> u64 {
774    let names = feature_names()
775        .into_iter()
776        .filter(|(_, flag)| features.contains(*flag))
777        .map(|(name, _)| name)
778        .collect();
779    wrap(g, Kind::Features, None, Resource::Features(names))
780}
781unsafe fn feature_flags(g: *mut c_void, cf: *mut c_void) -> Result<Arc<[&'static str]>, ()> {
782    let h = match try_handle(g, cf_this(cf), Kind::LanguageFeatures) {
783        Some(h) => h,
784        None => this(g, cf, Kind::Features)?,
785    };
786    let Resource::Features(f) = h.resource else {
787        unreachable!()
788    };
789    Ok(f)
790}
791#[redjs::host_fn]
792unsafe fn feature_size(g: *mut c_void, cf: *mut c_void) -> u64 {
793    run(g, || Ok(enc_f64(feature_flags(g, cf)?.len() as f64)))
794}
795#[redjs::host_fn]
796unsafe fn feature_has(g: *mut c_void, cf: *mut c_void) -> u64 {
797    run(g, || {
798        let f = feature_flags(g, cf)?;
799        let name = text(g, cf_arg(cf, 0), "")?;
800        Ok(enc_bool(f.iter().any(|n| *n == name)))
801    })
802}
803unsafe fn feature_iterator(g: *mut c_void, cf: *mut c_void, entries: bool) -> Result<u64, ()> {
804    let f = feature_flags(g, cf)?;
805    let a = Val::new(g, new_array(g));
806    for (i, name) in f.iter().copied().enumerate() {
807        let value = Val::new(g, js_string(g, name));
808        if entries {
809            let pair = Val::new(g, new_array(g));
810            set_i(g, pair.v, 0, value.v);
811            set_i(g, pair.v, 1, value.v);
812            set_i(g, a.v, i as u32, pair.v);
813        } else {
814            set_i(g, a.v, i as u32, value.v);
815        }
816    }
817    let values = states().lock().unwrap()[&(g as usize)]
818        .classes
819        .as_ref()
820        .unwrap()
821        .array_values;
822    call(g, values, a.v, &[]).map_err(|e| {
823        glue::rjs_throw(g, e);
824    })
825}
826#[redjs::host_fn]
827unsafe fn feature_values(g: *mut c_void, cf: *mut c_void) -> u64 {
828    run(g, || feature_iterator(g, cf, false))
829}
830#[redjs::host_fn]
831unsafe fn feature_entries(g: *mut c_void, cf: *mut c_void) -> u64 {
832    run(g, || feature_iterator(g, cf, true))
833}
834#[redjs::host_fn]
835unsafe fn feature_each(g: *mut c_void, cf: *mut c_void) -> u64 {
836    run(g, || {
837        let f = feature_flags(g, cf)?;
838        let cb = cf_arg(cf, 0);
839        if glue::rjs_kind(g, cb) != 9 {
840            invalid(g, "GPUSupportedFeatures.forEach requires a callback")?;
841        }
842        for name in f.iter() {
843            let s = Val::new(g, js_string(g, name));
844            call(g, cb, cf_arg(cf, 1), &[s.v, s.v, cf_this(cf)]).map_err(|e| {
845                glue::rjs_throw(g, e);
846            })?;
847        }
848        Ok(UNDEF)
849    })
850}
851unsafe fn cached(g: *mut c_void, obj: u64, slot: usize, build: impl FnOnce() -> u64) -> u64 {
852    let old = get_a(g, obj, slot as *mut c_void);
853    if old != UNDEF {
854        return old;
855    }
856    let v = Val::new(g, build());
857    glue::rjs_define(g, obj, slot as *mut c_void, v.v, 1 | 2);
858    v.v
859}
860unsafe fn plain(g: *mut c_void, kind: Kind) -> u64 {
861    let proto = states().lock().unwrap()[&(g as usize)]
862        .classes
863        .as_ref()
864        .unwrap()
865        .types[&kind]
866        .proto;
867    new_object(g, proto)
868}
869// Capability advertising follows implemented APIs. Compressed texture, f16 and
870// subgroup surfaces need per-client shader virtualization on a shared device.
871fn feature_names() -> [(&'static str, wgpu::Features); 2] {
872    [
873        ("core-features-and-limits", wgpu::Features::empty()),
874        ("timestamp-query", wgpu::Features::TIMESTAMP_QUERY),
875    ]
876}
877#[redjs::host_fn]
878unsafe fn adapter_features(g: *mut c_void, cf: *mut c_void) -> u64 {
879    run(g, || {
880        let h = this(g, cf, Kind::Adapter)?;
881        let Resource::Adapter(a) = h.resource else {
882            unreachable!()
883        };
884        let slot = with_classes(g, |c| c.s_features);
885        Ok(cached(g, cf_this(cf), slot, || {
886            features_object(g, a.features())
887        }))
888    })
889}
890#[redjs::host_fn]
891unsafe fn wgsl_language_features(g: *mut c_void, cf: *mut c_void) -> u64 {
892    run(g, || {
893        this(g, cf, Kind::Gpu)?;
894        let slot = with_classes(g, |c| c.s_language);
895        Ok(cached(g, cf_this(cf), slot, || {
896            let names = wgpu::naga::front::wgsl::ImplementedLanguageExtension::all()
897                .iter()
898                .map(|e| e.to_ident())
899                .collect();
900            wrap(g, Kind::LanguageFeatures, None, Resource::Features(names))
901        }))
902    })
903}
904#[redjs::host_fn]
905unsafe fn device_features(g: *mut c_void, cf: *mut c_void) -> u64 {
906    run(g, || {
907        let h = this(g, cf, Kind::Device)?;
908        let slot = states().lock().unwrap()[&(g as usize)]
909            .classes
910            .as_ref()
911            .unwrap()
912            .s_features;
913        Ok(cached(g, cf_this(cf), slot, || {
914            features_object(g, h.client.unwrap().features)
915        }))
916    })
917}
918macro_rules! limits_fields {($m:ident)=>{$m!{maxTextureDimension1D=>max_texture_dimension_1d,maxTextureDimension2D=>max_texture_dimension_2d,maxTextureDimension3D=>max_texture_dimension_3d,maxTextureArrayLayers=>max_texture_array_layers,maxBindGroups=>max_bind_groups,maxBindingsPerBindGroup=>max_bindings_per_bind_group,maxDynamicUniformBuffersPerPipelineLayout=>max_dynamic_uniform_buffers_per_pipeline_layout,maxDynamicStorageBuffersPerPipelineLayout=>max_dynamic_storage_buffers_per_pipeline_layout,maxSampledTexturesPerShaderStage=>max_sampled_textures_per_shader_stage,maxSamplersPerShaderStage=>max_samplers_per_shader_stage,maxStorageBuffersPerShaderStage=>max_storage_buffers_per_shader_stage,maxStorageTexturesPerShaderStage=>max_storage_textures_per_shader_stage,maxUniformBuffersPerShaderStage=>max_uniform_buffers_per_shader_stage,maxUniformBufferBindingSize=>max_uniform_buffer_binding_size,maxStorageBufferBindingSize=>max_storage_buffer_binding_size,minUniformBufferOffsetAlignment=>min_uniform_buffer_offset_alignment,minStorageBufferOffsetAlignment=>min_storage_buffer_offset_alignment,maxVertexBuffers=>max_vertex_buffers,maxBufferSize=>max_buffer_size,maxVertexAttributes=>max_vertex_attributes,maxVertexBufferArrayStride=>max_vertex_buffer_array_stride,maxInterStageShaderVariables=>max_inter_stage_shader_variables,maxColorAttachments=>max_color_attachments,maxColorAttachmentBytesPerSample=>max_color_attachment_bytes_per_sample,maxComputeWorkgroupStorageSize=>max_compute_workgroup_storage_size,maxComputeInvocationsPerWorkgroup=>max_compute_invocations_per_workgroup,maxComputeWorkgroupSizeX=>max_compute_workgroup_size_x,maxComputeWorkgroupSizeY=>max_compute_workgroup_size_y,maxComputeWorkgroupSizeZ=>max_compute_workgroup_size_z,maxComputeWorkgroupsPerDimension=>max_compute_workgroups_per_dimension,maxBindGroupsPlusVertexBuffers=>max_bind_groups_plus_vertex_buffers,maxImmediateSize=>max_immediate_size}};}
919// With core-features-and-limits the per-stage storage limits are the
920// vertex/fragment ones; wgpu has no separate fields for them.
921fn stage_limit_aliases(l: &wgpu::Limits) -> [(&'static str, u32); 4] {
922    [
923        (
924            "maxStorageBuffersInVertexStage",
925            l.max_storage_buffers_per_shader_stage,
926        ),
927        (
928            "maxStorageBuffersInFragmentStage",
929            l.max_storage_buffers_per_shader_stage,
930        ),
931        (
932            "maxStorageTexturesInVertexStage",
933            l.max_storage_textures_per_shader_stage,
934        ),
935        (
936            "maxStorageTexturesInFragmentStage",
937            l.max_storage_textures_per_shader_stage,
938        ),
939    ]
940}
941unsafe fn limits_object(g: *mut c_void, l: &wgpu::Limits) -> u64 {
942    let o = Val::new(g, plain(g, Kind::Limits));
943    macro_rules! write {($($js:ident=>$rust:ident),*)=>{$(define(g,o.v,stringify!($js),enc_f64(l.$rust as f64),1|2);)*};}
944    limits_fields!(write);
945    for (name, value) in stage_limit_aliases(l) {
946        define(g, o.v, name, enc_f64(value as f64), 1 | 2);
947    }
948    o.v
949}
950#[redjs::host_fn]
951unsafe fn adapter_limits(g: *mut c_void, cf: *mut c_void) -> u64 {
952    run(g, || {
953        let h = this(g, cf, Kind::Adapter)?;
954        let Resource::Adapter(a) = h.resource else {
955            unreachable!()
956        };
957        let slot = states().lock().unwrap()[&(g as usize)]
958            .classes
959            .as_ref()
960            .unwrap()
961            .s_limits;
962        Ok(cached(g, cf_this(cf), slot, || {
963            limits_object(g, &a.limits())
964        }))
965    })
966}
967#[redjs::host_fn]
968unsafe fn device_limits(g: *mut c_void, cf: *mut c_void) -> u64 {
969    run(g, || {
970        let h = this(g, cf, Kind::Device)?;
971        let slot = states().lock().unwrap()[&(g as usize)]
972            .classes
973            .as_ref()
974            .unwrap()
975            .s_limits;
976        Ok(cached(g, cf_this(cf), slot, || {
977            limits_object(g, &h.client.unwrap().limits)
978        }))
979    })
980}
981#[redjs::host_fn]
982unsafe fn adapter_info(g: *mut c_void, cf: *mut c_void) -> u64 {
983    run(g, || {
984        let h = this(g, cf, Kind::Adapter)?;
985        let Resource::Adapter(a) = h.resource else {
986            unreachable!()
987        };
988        let slot = states().lock().unwrap()[&(g as usize)]
989            .classes
990            .as_ref()
991            .unwrap()
992            .s_info;
993        Ok(cached(g, cf_this(cf), slot, || {
994            info_object(g, a.raw.get_info())
995        }))
996    })
997}
998#[redjs::host_fn]
999unsafe fn device_adapter_info(g: *mut c_void, cf: *mut c_void) -> u64 {
1000    run(g, || {
1001        let h = this(g, cf, Kind::Device)?;
1002        let adapter = h.client.unwrap().context.adapter.clone();
1003        let slot = with_classes(g, |c| c.s_info);
1004        Ok(cached(g, cf_this(cf), slot, || {
1005            info_object(g, adapter.get_info())
1006        }))
1007    })
1008}
1009unsafe fn info_object(g: *mut c_void, i: wgpu::AdapterInfo) -> u64 {
1010    let o = Val::new(g, plain(g, Kind::AdapterInfo));
1011    for (k, v) in [
1012        ("vendor", format!("{:x}", i.vendor)),
1013        ("architecture", String::new()),
1014        ("device", format!("{:x}", i.device)),
1015        ("description", i.name),
1016    ] {
1017        define(g, o.v, k, js_string(g, &v), 1 | 2);
1018    }
1019    // The spec's values while "subgroups" is not an exposed feature.
1020    for (k, v) in [("subgroupMinSize", 4), ("subgroupMaxSize", 128)] {
1021        define(g, o.v, k, enc_f64(v as f64), 1 | 2);
1022    }
1023    define(
1024        g,
1025        o.v,
1026        "isFallbackAdapter",
1027        enc_bool(i.device_type == wgpu::DeviceType::Cpu),
1028        1 | 2,
1029    );
1030    o.v
1031}
1032#[redjs::host_fn]
1033unsafe fn request_device(g: *mut c_void, cf: *mut c_void) -> u64 {
1034    run(g, || {
1035        let h = this(g, cf, Kind::Adapter)?;
1036        let Resource::Adapter(a) = h.resource else {
1037            unreachable!()
1038        };
1039        let d = Val::new(g, cf_arg(cf, 0));
1040        let label = text(g, field(g, d.v, "label")?.v, "")?;
1041        let mut features = wgpu::Features::empty();
1042        let available = a.features();
1043        for v in seq(g, field(g, d.v, "requiredFeatures")?.v)? {
1044            let name = text(g, v.v, "")?;
1045            let Some((_, flag)) = feature_names()
1046                .into_iter()
1047                .find(|(n, flag)| *n == name && available.contains(*flag))
1048            else {
1049                return Ok(redjs::webapi::domexception::rejected(
1050                    g,
1051                    "NotSupportedError",
1052                    &format!("Unsupported WebGPU feature: {name}"),
1053                ));
1054            };
1055            features |= flag;
1056        }
1057        let l = field(g, d.v, "requiredLimits")?;
1058        let adapter_limits = a.limits();
1059        let mut limits = wgpu::Limits {
1060            max_immediate_size: 64.min(adapter_limits.max_immediate_size),
1061            ..Default::default()
1062        };
1063        macro_rules! read {($($js:ident=>$rust:ident),*)=>{$(let v=field(g,l.v,stringify!($js))?;if v.v!=UNDEF {limits.$rust=num(g,v.v,0)?.try_into().map_err(|_|{throw_type_error(g,"WebGPU limit out of range");})?;})*};}
1064        limits_fields!(read);
1065        for (name, available) in stage_limit_aliases(&adapter_limits) {
1066            let v = field(g, l.v, name)?;
1067            if v.v != UNDEF && num(g, v.v, 0)? > available as u64 {
1068                return Ok(redjs::webapi::domexception::rejected(
1069                    g,
1070                    "OperationError",
1071                    &format!("Unsupported requiredLimits: {name}"),
1072                ));
1073            }
1074        }
1075        let queue = field(g, d.v, "defaultQueue")?;
1076        let queue_label = text(g, field(g, queue.v, "label")?.v, "")?;
1077        let client_limits = limits.clone();
1078        Ok(async_op(
1079            g,
1080            vec![],
1081            async move { a.request_device(features, limits).await },
1082            move |g, context| {
1083                let device = Val::new(
1084                    g,
1085                    make_device(
1086                        g,
1087                        Client::new_with_capabilities(context, features, client_limits),
1088                    ),
1089                );
1090                set_label(g, device.v, &label);
1091                set_label(g, get(g, device.v, "queue"), &queue_label);
1092                device.v
1093            },
1094        ))
1095    })
1096}
1097unsafe fn make_device(g: *mut c_void, c: Arc<Client>) -> u64 {
1098    prune_clients(g);
1099    let o = Val::new(g, wrap(g, Kind::Device, Some(c.clone()), Resource::Device));
1100    let queue = Val::new(g, wrap(g, Kind::Queue, Some(c.clone()), Resource::Queue));
1101    define(g, o.v, "queue", queue.v, 1 | 2);
1102    let (mut res, mut rej, mut p) = (UNDEF, UNDEF, UNDEF);
1103    redjs::ffi::redjs_promise_create(g, &mut res, &mut rej, &mut p);
1104    let pr = Val::new(g, p);
1105    let rr = Val::new(g, res);
1106    let (sl, sr) = {
1107        let s = states().lock().unwrap();
1108        let c = s[&(g as usize)].classes.as_ref().unwrap();
1109        (c.s_lost, c.s_resolve_lost)
1110    };
1111    glue::rjs_define(g, o.v, sl as *mut c_void, pr.v, 1 | 2);
1112    glue::rjs_define(g, pr.v, sl as *mut c_void, o.v, 1 | 2);
1113    glue::rjs_define(g, o.v, sr as *mut c_void, rr.v, 1 | 2);
1114    let weak = weak_ref(g, o.v);
1115    states()
1116        .lock()
1117        .unwrap()
1118        .get_mut(&(g as usize))
1119        .unwrap()
1120        .clients
1121        .insert(
1122            c.id,
1123            ClientRef {
1124                weak,
1125                client: Arc::downgrade(&c),
1126                buffers: Vec::new(),
1127                lost: false,
1128            },
1129        );
1130    o.v
1131}
1132#[redjs::host_fn]
1133unsafe fn lost(g: *mut c_void, cf: *mut c_void) -> u64 {
1134    run(g, || {
1135        this(g, cf, Kind::Device)?;
1136        let sl = states().lock().unwrap()[&(g as usize)]
1137            .classes
1138            .as_ref()
1139            .unwrap()
1140            .s_lost;
1141        Ok(get_a(g, cf_this(cf), sl as *mut c_void))
1142    })
1143}
1144unsafe fn prune_clients(g: *mut c_void) {
1145    let dead = {
1146        let mut s = states().lock().unwrap();
1147        let s = s.get_mut(&(g as usize)).unwrap();
1148        let ids: Vec<_> = s
1149            .clients
1150            .iter()
1151            .filter_map(|(&id, r)| (r.client.strong_count() == 0).then_some(id))
1152            .collect();
1153        ids.into_iter()
1154            .map(|id| {
1155                s.scopes.remove(&id);
1156                s.clients.remove(&id).unwrap()
1157            })
1158            .collect::<Vec<_>>()
1159    };
1160    for r in dead {
1161        for v in r.buffers.into_iter().chain([r.weak]) {
1162            redjs::ffi::redjs_unprotect(g, v);
1163        }
1164    }
1165}
1166unsafe fn weak_ref(g: *mut c_void, obj: u64) -> u64 {
1167    let ctor = states().lock().unwrap()[&(g as usize)]
1168        .classes
1169        .as_ref()
1170        .unwrap()
1171        .weak_ctor;
1172    let mut out = UNDEF;
1173    if glue::rjs_construct(g, ctor, &obj, 1, &mut out) != 0 {
1174        panic!("Intrinsic WeakRef construction failed");
1175    }
1176    redjs::ffi::redjs_protect(g, out);
1177    out
1178}
1179unsafe fn deref(g: *mut c_void, weak: u64) -> Val {
1180    let f = states().lock().unwrap()[&(g as usize)]
1181        .classes
1182        .as_ref()
1183        .unwrap()
1184        .weak_deref;
1185    Val::new(g, call(g, f, weak, &[]).unwrap_or(UNDEF))
1186}
1187unsafe fn device_target(g: *mut c_void, id: u64) -> Option<Val> {
1188    let weak = states()
1189        .lock()
1190        .unwrap()
1191        .get(&(g as usize))?
1192        .clients
1193        .get(&id)?
1194        .weak;
1195    let v = deref(g, weak);
1196    is_cell(v.v).then_some(v)
1197}
1198unsafe fn track_buffer_object(g: *mut c_void, c: &Arc<Client>, obj: u64) {
1199    let weak = weak_ref(g, obj);
1200    let old = {
1201        let mut s = states().lock().unwrap();
1202        let r = s
1203            .get_mut(&(g as usize))
1204            .unwrap()
1205            .clients
1206            .get_mut(&c.id)
1207            .unwrap();
1208        r.buffers.push(weak);
1209        if r.buffers.len() % 64 == 0 {
1210            std::mem::take(&mut r.buffers)
1211        } else {
1212            Vec::new()
1213        }
1214    };
1215    let mut live = Vec::new();
1216    for w in old {
1217        if is_cell(deref(g, w).v) {
1218            live.push(w)
1219        } else {
1220            redjs::ffi::redjs_unprotect(g, w);
1221        }
1222    }
1223    if !live.is_empty() {
1224        states()
1225            .lock()
1226            .unwrap()
1227            .get_mut(&(g as usize))
1228            .unwrap()
1229            .clients
1230            .get_mut(&c.id)
1231            .unwrap()
1232            .buffers
1233            .extend(live);
1234    }
1235}
1236unsafe fn release_buffers(g: *mut c_void, id: u64) {
1237    let buffers = states()
1238        .lock()
1239        .unwrap()
1240        .get_mut(&(g as usize))
1241        .and_then(|s| s.clients.get_mut(&id))
1242        .map(|r| std::mem::take(&mut r.buffers))
1243        .unwrap_or_default();
1244    for w in buffers {
1245        let o = deref(g, w);
1246        if is_cell(o.v) {
1247            buffer::release_on_device_destroy(g, o.v);
1248        }
1249        redjs::ffi::redjs_unprotect(g, w);
1250    }
1251}
1252unsafe fn resolve_loss(g: *mut c_void, target: u64, reason: &str, message: &str) {
1253    let sr = states().lock().unwrap()[&(g as usize)]
1254        .classes
1255        .as_ref()
1256        .unwrap()
1257        .s_resolve_lost;
1258    let res = Val::new(g, get_a(g, target, sr as *mut c_void));
1259    let info = Val::new(g, plain(g, Kind::LostInfo));
1260    define(g, info.v, "reason", js_string(g, reason), 1 | 2);
1261    define(g, info.v, "message", js_string(g, message), 1 | 2);
1262    let _ = call(g, res.v, UNDEF, &[info.v]);
1263    if let Ok(h) = handle(g, target, Kind::Device) {
1264        let id = h.client.unwrap().id;
1265        if let Some(r) = states()
1266            .lock()
1267            .unwrap()
1268            .get_mut(&(g as usize))
1269            .and_then(|s| s.clients.get_mut(&id))
1270        {
1271            r.lost = true;
1272        }
1273    }
1274}
1275#[redjs::host_fn]
1276unsafe fn destroy(g: *mut c_void, cf: *mut c_void) -> u64 {
1277    run(g, || {
1278        let h = this(g, cf, Kind::Device)?;
1279        let c = h.client.unwrap();
1280        release_buffers(g, c.id);
1281        c.destroy();
1282        canvas::device_destroyed(c.id);
1283        resolve_loss(
1284            g,
1285            cf_this(cf),
1286            "destroyed",
1287            "Logical WebGPU device was destroyed",
1288        );
1289        Ok(UNDEF)
1290    })
1291}
1292#[redjs::host_fn]
1293unsafe fn uncaptured_handler_get(g: *mut c_void, cf: *mut c_void) -> u64 {
1294    run(g, || {
1295        this(g, cf, Kind::Device)?;
1296        let slot = with_classes(g, |c| c.s_handlers);
1297        let v = get_a(g, cf_this(cf), slot as *mut c_void);
1298        Ok(if v == UNDEF { NULL } else { v })
1299    })
1300}
1301#[redjs::host_fn]
1302unsafe fn uncaptured_handler_set(g: *mut c_void, cf: *mut c_void) -> u64 {
1303    run(g, || {
1304        this(g, cf, Kind::Device)?;
1305        let v = cf_arg(cf, 0);
1306        let v = if redjs::webapi::events::is_callable(g, v) {
1307            v
1308        } else {
1309            NULL
1310        };
1311        let slot = with_classes(g, |c| c.s_handlers);
1312        glue::rjs_define(g, cf_this(cf), slot as *mut c_void, v, 2);
1313        Ok(UNDEF)
1314    })
1315}
1316unsafe fn pipeline_error(g: *mut c_void, reason: &str, message: &str) -> u64 {
1317    let (proto, slot) = with_classes(g, |c| (c.pipeline_error_proto, c.s_reason));
1318    let e = Val::new(
1319        g,
1320        redjs::webapi::domexception::create(g, "GPUPipelineError", message),
1321    );
1322    capi::JSObjectSetPrototype(
1323        g,
1324        e.v as usize as capi::JSObjectRef,
1325        proto as usize as capi::JSValueRef,
1326    );
1327    let r = Val::new(g, js_string(g, reason));
1328    glue::rjs_define(g, e.v, slot as *mut c_void, r.v, 1 | 2);
1329    e.v
1330}
1331#[redjs::host_fn]
1332unsafe fn pipeline_error_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
1333    run(g, || {
1334        let message = text(g, cf_arg(cf, 0), "")?;
1335        let options = Val::new(g, cf_arg(cf, 1));
1336        if !is_cell(options.v) {
1337            invalid(g, "GPUPipelineError requires a GPUPipelineErrorInit")?;
1338        }
1339        let reason = field(g, options.v, "reason")?;
1340        if reason.v == UNDEF {
1341            invalid(g, "GPUPipelineErrorInit.reason is required")?;
1342        }
1343        let reason = text(g, reason.v, "")?;
1344        if reason != "validation" && reason != "internal" {
1345            invalid(g, "Invalid GPUPipelineErrorReason")?;
1346        }
1347        let e = Val::new(g, pipeline_error(g, &reason, &message));
1348        let target = cf_new_target(cf);
1349        if is_cell(target) {
1350            let proto = get(g, target, "prototype");
1351            if is_cell(proto) {
1352                capi::JSObjectSetPrototype(
1353                    g,
1354                    e.v as usize as capi::JSObjectRef,
1355                    proto as usize as capi::JSValueRef,
1356                );
1357            }
1358        }
1359        Ok(e.v)
1360    })
1361}
1362#[redjs::host_fn]
1363unsafe fn pipeline_error_reason(g: *mut c_void, cf: *mut c_void) -> u64 {
1364    run(g, || {
1365        let slot = with_classes(g, |c| c.s_reason);
1366        let this = cf_this(cf);
1367        let v = if is_cell(this) {
1368            get_a(g, this, slot as *mut c_void)
1369        } else {
1370            UNDEF
1371        };
1372        if v == UNDEF {
1373            invalid(
1374                g,
1375                "GPUPipelineError.reason called on an incompatible receiver",
1376            )?;
1377        }
1378        Ok(v)
1379    })
1380}
1381#[redjs::host_fn]
1382unsafe fn push_scope(g: *mut c_void, cf: *mut c_void) -> u64 {
1383    run(g, || {
1384        let h = this(g, cf, Kind::Device)?;
1385        let c = h.client.as_ref().unwrap();
1386        route_errors(g, c.id, c.take_errors());
1387        let filter = text(g, cf_arg(cf, 0), "")?;
1388        if !["validation", "out-of-memory", "internal"].contains(&filter.as_str()) {
1389            invalid(g, "Invalid GPUErrorFilter")?;
1390        }
1391        states()
1392            .lock()
1393            .unwrap()
1394            .get_mut(&(g as usize))
1395            .unwrap()
1396            .scopes
1397            .entry(h.client.unwrap().id)
1398            .or_default()
1399            .push(Scope {
1400                filter,
1401                error: None,
1402            });
1403        Ok(UNDEF)
1404    })
1405}
1406#[redjs::host_fn]
1407unsafe fn pop_scope(g: *mut c_void, cf: *mut c_void) -> u64 {
1408    run(g, || {
1409        let h = this(g, cf, Kind::Device)?;
1410        let scope = states()
1411            .lock()
1412            .unwrap()
1413            .get_mut(&(g as usize))
1414            .unwrap()
1415            .scopes
1416            .entry(h.client.unwrap().id)
1417            .or_default()
1418            .pop();
1419        let Some(scope) = scope else {
1420            return Ok(redjs::webapi::domexception::rejected(
1421                g,
1422                "OperationError",
1423                "No WebGPU error scope to pop",
1424            ));
1425        };
1426        let value = Val::new(g, scope.error.map_or(NULL, |e| error_object(g, e)));
1427        Ok(resolved_promise(g, value.v))
1428    })
1429}
1430/// No Rust unwind is allowed to cross a JSC host callback. Normal validation
1431/// errors are captured by wgpu scopes; internal bugs still return a JS error.
1432unsafe fn run(g: *mut c_void, f: impl FnOnce() -> Result<u64, ()>) -> u64 {
1433    match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) {
1434        Ok(Ok(v)) => v,
1435        Ok(Err(())) => UNDEF,
1436        Err(payload) => {
1437            let reason = payload
1438                .downcast_ref::<String>()
1439                .map(String::as_str)
1440                .or_else(|| payload.downcast_ref::<&str>().copied())
1441                .unwrap_or("an internal error");
1442            let reason = reason.split_whitespace().collect::<Vec<_>>().join(" ");
1443            redjs::webapi::domexception::throw(
1444                g,
1445                "OperationError",
1446                &format!("Native WebGPU operation failed: {reason}"),
1447            )
1448        }
1449    }
1450}
1451
1452unsafe extern "C" fn finalize_handle(obj: capi::JSObjectRef) {
1453    let p = capi::JSObjectGetPrivate(obj);
1454    if !p.is_null() {
1455        let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
1456            drop(Box::from_raw(p as *mut Handle))
1457        }));
1458    }
1459}
1460unsafe fn make_gpu_host_class(name: &str) -> capi::JSClassRef {
1461    let name = std::ffi::CString::new(name).unwrap();
1462    let mut d = capi::JSClassDefinition::empty();
1463    d.class_name = name.as_ptr();
1464    d.finalize = Some(finalize_handle);
1465    capi::JSClassCreate(&d)
1466}
1467
1468pub(crate) unsafe fn install(g: *mut c_void) {
1469    states()
1470        .lock()
1471        .unwrap()
1472        .insert(g as usize, State::default());
1473    let global = glue::rjs_global(g);
1474    let array = Val::new(g, get(g, global, "Array"));
1475    let from = Val::new(g, get(g, array.v, "from"));
1476    redjs::ffi::redjs_protect(g, from.v);
1477    let weak_ctor = Val::new(g, get(g, global, "WeakRef"));
1478    let weak_proto = field(g, weak_ctor.v, "prototype").unwrap();
1479    let weak_deref = field(g, weak_proto.v, "deref").unwrap();
1480    for v in [weak_ctor.v, weak_deref.v] {
1481        redjs::ffi::redjs_protect(g, v);
1482    }
1483    let ap = field(g, array.v, "prototype").unwrap();
1484    let array_values = field(g, ap.v, "values").unwrap();
1485    redjs::ffi::redjs_protect(g, array_values.v);
1486    let classes = Classes {
1487        array_values: array_values.v,
1488        s_features: atom_priv(g, "webgpu.features") as usize,
1489        s_limits: atom_priv(g, "webgpu.limits") as usize,
1490        s_info: atom_priv(g, "webgpu.info") as usize,
1491        weak_ctor: weak_ctor.v,
1492        weak_deref: weak_deref.v,
1493        error_protos: HashMap::new(),
1494        hosts: HashMap::new(),
1495        types: HashMap::new(),
1496        array_from: from.v,
1497        s_gpu_canvas: atom_priv(g, "webgpu.canvas") as usize,
1498        s_gpu_device: atom_priv(g, "webgpu.canvasDevice") as usize,
1499        s_gpu_texture: atom_priv(g, "webgpu.canvasTexture") as usize,
1500        s_ranges: atom_priv(g, "webgpu.ranges") as usize,
1501        s_lost: atom_priv(g, "webgpu.lost") as usize,
1502        s_resolve_lost: atom_priv(g, "webgpu.resolveLost") as usize,
1503        s_label: atom_priv(g, "webgpu.label") as usize,
1504        s_handlers: atom_priv(g, "webgpu.onuncapturederror") as usize,
1505        s_language: atom_priv(g, "webgpu.wgslLanguageFeatures") as usize,
1506        s_reason: atom_priv(g, "webgpu.pipelineErrorReason") as usize,
1507        pipeline_error_proto: 0,
1508    };
1509    states()
1510        .lock()
1511        .unwrap()
1512        .get_mut(&(g as usize))
1513        .unwrap()
1514        .classes = Some(classes);
1515    class(
1516        g,
1517        Kind::Gpu,
1518        "GPU",
1519        &[
1520            ("requestAdapter", 0, request_adapter),
1521            ("getPreferredCanvasFormat", 0, preferred_format),
1522        ],
1523        &[("wgslLanguageFeatures", wgsl_language_features)],
1524    );
1525    class(
1526        g,
1527        Kind::Adapter,
1528        "GPUAdapter",
1529        &[("requestDevice", 0, request_device)],
1530        &[
1531            ("features", adapter_features),
1532            ("limits", adapter_limits),
1533            ("info", adapter_info),
1534        ],
1535    );
1536    class(
1537        g,
1538        Kind::Device,
1539        "GPUDevice",
1540        &[
1541            ("destroy", 0, destroy),
1542            ("pushErrorScope", 1, push_scope),
1543            ("popErrorScope", 0, pop_scope),
1544        ],
1545        &[
1546            ("features", device_features),
1547            ("limits", device_limits),
1548            ("lost", lost),
1549            ("adapterInfo", device_adapter_info),
1550        ],
1551    );
1552    let device_proto = with_classes(g, |c| c.types[&Kind::Device].proto);
1553    let a = atom(g, "onuncapturederror");
1554    glue::rjs_define_accessor(
1555        g,
1556        device_proto,
1557        a,
1558        make_fn(g, "get onuncapturederror", 0, uncaptured_handler_get),
1559        make_fn(g, "set onuncapturederror", 1, uncaptured_handler_set),
1560        2,
1561    );
1562    glue::rjs_atom_free(g, a);
1563    class(g, Kind::Queue, "GPUQueue", &[], &[]);
1564    for (kind, name) in [
1565        (Kind::Features, "GPUSupportedFeatures"),
1566        (Kind::LanguageFeatures, "WGSLLanguageFeatures"),
1567    ] {
1568        class(
1569            g,
1570            kind,
1571            name,
1572            &[
1573                ("has", 1, feature_has),
1574                ("keys", 0, feature_values),
1575                ("values", 0, feature_values),
1576                ("entries", 0, feature_entries),
1577                ("forEach", 1, feature_each),
1578            ],
1579            &[("size", feature_size)],
1580        );
1581        let proto = with_classes(g, |c| c.types[&kind].proto);
1582        let iter = glue::rjs_atom_iterator(g);
1583        glue::rjs_define(g, proto, iter, make_fn(g, "values", 0, feature_values), 2);
1584        glue::rjs_atom_free(g, iter);
1585    }
1586    class(g, Kind::Limits, "GPUSupportedLimits", &[], &[]);
1587    class(g, Kind::AdapterInfo, "GPUAdapterInfo", &[], &[]);
1588    class(g, Kind::LostInfo, "GPUDeviceLostInfo", &[], &[]);
1589    let base = define_class(
1590        g,
1591        &ClassSpec {
1592            name: "GPUError",
1593            arity: 0,
1594            construct: None,
1595            parent_proto: 0,
1596            methods: &[],
1597            getters: &[],
1598            accessors: &[],
1599        },
1600    );
1601    for name in [
1602        "GPUValidationError",
1603        "GPUOutOfMemoryError",
1604        "GPUInternalError",
1605    ] {
1606        let c = define_class(
1607            g,
1608            &ClassSpec {
1609                name,
1610                arity: 1,
1611                construct: Some(gpu_error_construct),
1612                parent_proto: base.proto,
1613                methods: &[],
1614                getters: &[],
1615                accessors: &[],
1616            },
1617        );
1618        states()
1619            .lock()
1620            .unwrap()
1621            .get_mut(&(g as usize))
1622            .unwrap()
1623            .classes
1624            .as_mut()
1625            .unwrap()
1626            .error_protos
1627            .insert(name, c.proto);
1628    }
1629    let event_class = define_class(
1630        g,
1631        &ClassSpec {
1632            name: "GPUUncapturedErrorEvent",
1633            arity: 2,
1634            construct: Some(error_event_construct),
1635            parent_proto: redjs::webapi::util::state(g).event.proto,
1636            methods: &[],
1637            getters: &[],
1638            accessors: &[],
1639        },
1640    );
1641    states()
1642        .lock()
1643        .unwrap()
1644        .get_mut(&(g as usize))
1645        .unwrap()
1646        .classes
1647        .as_mut()
1648        .unwrap()
1649        .error_protos
1650        .insert("GPUUncapturedErrorEvent", event_class.proto);
1651    let dom_exception = Val::new(g, get(g, global, "DOMException"));
1652    let dom_proto = field(g, dom_exception.v, "prototype").unwrap();
1653    let pipeline_error_class = define_class(
1654        g,
1655        &ClassSpec {
1656            name: "GPUPipelineError",
1657            arity: 2,
1658            construct: Some(pipeline_error_construct),
1659            parent_proto: dom_proto.v,
1660            methods: &[],
1661            getters: &[("reason", pipeline_error_reason)],
1662            accessors: &[],
1663        },
1664    );
1665    states()
1666        .lock()
1667        .unwrap()
1668        .get_mut(&(g as usize))
1669        .unwrap()
1670        .classes
1671        .as_mut()
1672        .unwrap()
1673        .pipeline_error_proto = pipeline_error_class.proto;
1674    buffer::install(g);
1675    compute::install(g);
1676    texture::install(g);
1677    query::install(g);
1678    bundle::install(g);
1679    canvas::install(g);
1680    let nav = Val::new(g, get(g, global, "navigator"));
1681    let gpu = wrap(g, Kind::Gpu, None, Resource::Gpu);
1682    define(g, nav.v, "gpu", gpu, 1 | 2);
1683    redjs::web::register_pump_source(redjs::web::PumpSource {
1684        inflight,
1685        ready,
1686        drain,
1687    });
1688}
1689unsafe fn class(
1690    g: *mut c_void,
1691    kind: Kind,
1692    name: &str,
1693    methods: &[(&str, u32, HostFn)],
1694    getters: &[(&str, HostFn)],
1695) {
1696    let host = make_gpu_host_class(name) as usize;
1697    let parent = if kind == Kind::Device {
1698        redjs::webapi::util::state(g).event_target.proto
1699    } else {
1700        0
1701    };
1702    let object_base = !matches!(
1703        kind,
1704        Kind::Gpu
1705            | Kind::Canvas
1706            | Kind::Adapter
1707            | Kind::Features
1708            | Kind::LanguageFeatures
1709            | Kind::Limits
1710            | Kind::AdapterInfo
1711            | Kind::LostInfo
1712    );
1713    let label: &[(&str, HostFn, HostFn)] = &[("label", label_get, label_set)];
1714    let c = define_class(
1715        g,
1716        &ClassSpec {
1717            name,
1718            arity: 0,
1719            construct: None,
1720            parent_proto: parent,
1721            methods,
1722            getters,
1723            accessors: if object_base { label } else { &[] },
1724        },
1725    );
1726    states()
1727        .lock()
1728        .unwrap()
1729        .get_mut(&(g as usize))
1730        .unwrap()
1731        .classes
1732        .as_mut()
1733        .unwrap()
1734        .hosts
1735        .insert(kind, host);
1736    states()
1737        .lock()
1738        .unwrap()
1739        .get_mut(&(g as usize))
1740        .unwrap()
1741        .classes
1742        .as_mut()
1743        .unwrap()
1744        .types
1745        .insert(kind, c);
1746}
1747unsafe fn method(g: *mut c_void, kind: Kind, name: &str, arity: u32, f: HostFn) {
1748    let proto = states().lock().unwrap()[&(g as usize)]
1749        .classes
1750        .as_ref()
1751        .unwrap()
1752        .types[&kind]
1753        .proto;
1754    define(g, proto, name, make_fn(g, name, arity, f), 2);
1755}
1756unsafe fn constants(g: *mut c_void, name: &str, values: &[(&str, u32)]) {
1757    let o = Val::new(g, new_object(g, UNDEF));
1758    for &(n, v) in values {
1759        define(g, o.v, n, enc_f64(v as f64), 1 | 2 | 4);
1760    }
1761    define(g, glue::rjs_global(g), name, o.v, 1 | 2);
1762}
1763pub(crate) fn forget(gone: redjs::context::Gone) {
1764    canvas::forget(gone);
1765    let s = states().lock().unwrap().remove(&gone.key);
1766    if let Some(s) = s {
1767        for r in s.clients.values() {
1768            if let Some(c) = r.client.upgrade() {
1769                c.destroy();
1770            }
1771        }
1772        if let Some(c) = s.classes {
1773            unsafe {
1774                for host in c.hosts.into_values() {
1775                    capi::JSClassRelease(host as capi::JSClassRef);
1776                }
1777            }
1778        }
1779    }
1780}