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