Update rust-wasm-bindgen monorepo to v0.2.121

[github-actions]

ℹ️ Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package	Update	Change	Pending
wasm-bindgen-cli (source)	patch	0.2.92 → 0.2.121	0.2.122

---

Release Notes

wasm-bindgen/wasm-bindgen (wasm-bindgen-cli)

v0.2.121

Compare Source

Added

• Added the slice_to_array attribute for imported JS functions,
  which makes a &[T] (or Option<&[T]>) argument arrive on the JS
  side as a plain Array rather than a typed array — without
  changing the Rust-side &[T] signature. Useful when binding JS
  APIs that take T[] rather than TypedArray<T>. For primitive
  element kinds the wire is the same zero-copy borrow used by plain
  &[T], with the JS-side shim wrapping the view in Array.from(...)
  to materialise the Array — no extra allocation. For String,
  JsValue, and JS-imported element types the Rust side builds a
  fresh [u32] index buffer that JS reads and frees, with per-element
  &T -> JsValue (refcount bump for handle-shaped types). No T: Clone bound is required. The attribute can be set per-fn
  (#[wasm_bindgen(slice_to_array)] fn ...) or per-block on an
  extern "C" { ... } declaration to apply to every imported function
  in that block. &[ExportedRustStruct] remains unsupported (use
  owned Vec<T> for that). Has no effect on exported functions;
  default &[T] (typed-array view / memory borrow) and owned
  Vec<T> semantics are unchanged for callers that didn't opt in.
  See the
  slice_to_array guide page.
  #​5145

• Added js_sys::AggregateError bindings (constructor, errors getter, and
  new_with_message / new_with_options overloads). AggregateError represents
  multiple unrelated errors wrapped in a single error, e.g. as thrown by
  Promise.any when all input promises reject, along with js_sys::ErrorOptions,
  accepted by built-in error constructors. ErrorOptions::new(cause)
  constructs an instance pre-populated with cause, and get_cause /
  set_cause provide typed access to the property. All standard error
  constructors that previously took only a message (EvalError,
  RangeError, ReferenceError, SyntaxError, TypeError, URIError,
  WebAssembly.CompileError, WebAssembly.LinkError,
  WebAssembly.RuntimeError) now expose a new_with_options(message, &ErrorOptions) overload, and Error gains
  new_with_error_options(message, &ErrorOptions) alongside the existing
  untyped new_with_options. AggregateError::new_with_options also takes
  &ErrorOptions.
  #​5139

• Added inheritance for Rust-exported types: an exported struct may
  declare #[wasm_bindgen(extends = Parent)] to inherit from another
  exported #[wasm_bindgen] struct. The macro injects a hidden
  parent: wasm_bindgen::Parent<Parent> field (a refcounted cell around
  the parent value) and emits class Child extends Parent in the
  generated JS / .d.ts. The child gets an AsRef<Parent<Parent>> impl
  for the direct parent, and threads per-class pointer slots through
  the wasm ABI so that instanceof Parent is true and parent methods
  dispatch soundly via the JS prototype chain. From inside child
  methods, parent data is reached via self.parent.borrow() /
  self.parent.borrow_mut(). See the new
  extends guide page.
  #​5120

• Added js_sys::FinalizationRegistry bindings (constructor, register,
  register_with_token, and unregister). The cleanup callback parameter
  is typed as &Function<fn(JsValue) -> Undefined>, so closures created via
  Closure::new can be passed using Function::from_closure (for owned
  closures retained by JS) or Function::closure_ref (for borrowed scoped
  closures). Pairs with the existing js_sys::WeakRef bindings.
  #​5140

• Added support for well-known symbols in js_name, getter, and
  setter via the explicit bracket-string form
  "[Symbol.<name>]". This works for imported and exported methods,
  fields, getters, and setters. For example,
  #[wasm_bindgen(js_name = "[Symbol.iterator]")] on an exported method
  generates [Symbol.iterator]() { ... } on the generated JS class, and
  the same syntax works for getter / setter and for imported items.
  #​4230

• Added level 2 bindings for ViewTransition to web-sys.
  #​5138

• Add support for dynamic unions: a #[wasm_bindgen] enum that mixes string-literal
  variants with single-field tuple variants is now exported as an untagged TypeScript
  union and dispatched dynamically at the JS↔Rust boundary. The new enum-level
  #[wasm_bindgen(fallback)] attribute makes the last tuple variant an
  unconditional catch-all, supporting unions whose trailing variant has no
  runtime check (e.g., interface-only imports). String enums and dynamic
  unions now emit export type (was bare type) so the alias is a named
  export, and both honour the private flag to suppress the keyword.
  #​4734
  #​2153
  #​2088

Fixed

• From<Promise<T>> for JsFuture<T> and IntoFuture for Promise<T> now
  accept any T: FromWasmAbi (rather than T: JsGeneric), letting
  imported async fns return dynamic-union enums.

• TryFromJsValue for C-style enums no longer accepts non-numeric values
  via JS unary + coercion. Previously calling dyn_into::<MyEnum>() on
  a string would silently coerce it via +"foo" (yielding NaN, then
  NaN as u32 = 0) and could match a discriminant by accident; the
  conversion now returns None for any value that is not a JS number.
  #​4734

• Fix compilation failure with no_std + release
  #​5134

• Raw identifiers (r#name) on enums, enum variants, extern types, statics,
  and impl blocks no longer leak the r# prefix into generated JS / TS
  output and shim names. The Rust-side identifier and the JS-side name are
  now tracked separately for enum variants, and all known identifier
  fallback paths apply Ident::unraw() so e.g.
  pub enum r#Enum { r#A } generates Enum.A instead of producing
  syntactically invalid JS.
  #​4323

• Using the -C panic=unwind option when building for the bundler target
  would produce invalid JS.
  #​5142

Changed

• js_sys::DataView now implements the js_sys::TypedArray trait. A
  FIXME notes that the trait should be renamed to ArrayBufferView in
  the next major release to better reflect the WebIDL spec name covering
  both DataView and the typed-array types.
  #​5135

---

v0.2.120

Compare Source

Added

• Added support for the wasm64-unknown-unknown target (memory64 / wasm64).
  usize / isize and raw pointers are now lowered through an f64 JS
  number ABI on wasm64 (matching the existing convention used for Option<u32>
  etc. on wasm32), with the CLI inspecting the module's memory type to pick
  the right codegen path. Includes a dedicated wasm64 CI job and test
  suite covering the new ABI paths.
  #​5004

• Promise ergonomics: Promise::all_tuple and Promise::all_settled_tuple
  for heterogeneous concurrent awaits (arity 1..=8, destructure via
  .into_tuple()), and a new wasm_bindgen::IntoJsGeneric trait underpinning
  typed-Array inference (with codegen-emitted identity impls and a
  #[wasm_bindgen(no_into_js_generic)] opt-out for types like JsClosure).
  Also re-exports JsGeneric from the prelude. Typed collection on
  js_sys::Array<T> is exposed as the inherent constructor
  Array::<T>::from_iter_typed (and companion extend_typed), inferring T
  from the iterator item via IntoJsGeneric. The stable FromIterator /
  Extend impls on Array (= Array<JsValue>) bound by AsRef<JsValue>
  are preserved, so existing .collect::<Array>() call sites keep compiling
  unchanged. Fixes #​5042.
  #​5121,
  #​5125

• Added wasm_bindgen::instance() to return the current
  WebAssembly.Instance. The generated JS glue retains the
  instantiated WebAssembly.Instance.
  #​5118

• Added a --cfg=wasm_bindgen_use_js_sys opt-in that makes async macro codegen
  use js_sys::futures instead of wasm_bindgen_futures, dropping the need
  for wasm-bindgen-futures when the crate already depends on js-sys. A cfg
  is used rather than a Cargo feature so the choice stays scoped to the crate
  that opts in.
  #​5112
  #​5127

Changed

• Simplified generated web-sys bindings by omitting redundant
  #[wasm_bindgen] attributes when they match wasm-bindgen defaults, including
  structural method annotations and matching js_name entries. The
  #[wasm_bindgen] attribute parser now also accepts string-literal forms for
  extends, static_method_of, and vendor_prefix (alongside the existing
  bare-path/ident syntax), and the generator emits these arguments along with
  js_name as string literals so rustfmt can format the generated
  #[wasm_bindgen(...)] attributes uniformly.
  #​5122

Fixed

• Fixed namespaced export identifiers in generated JS/TS to use qualified names
  consistently, resolving order-dependent codegen issues across platforms. Also
  fixed Vec<T> types in TS signatures to resolve through the identifier map.
  #​5106

• Fixed wasm-bindgen-test-runner treating ChromeDriver stderr warnings as
  startup failures on macOS, causing a restart loop until timeout. The runner
  no longer uses stderr output to determine if a driver has failed; instead a
  per-attempt timeout detects stuck drivers and retries on a new port.
  #​5111

v0.2.118

Compare Source

Added

• Added Error::stack_trace_limit() and Error::set_stack_trace_limit() bindings
  to js-sys for the non-standard V8 Error.stackTraceLimit property.
  #​5082

• Added support for multiple #[wasm_bindgen(start)] functions, which are
  chained together at initialization, as well as a new
  #[wasm_bindgen(start, private)] to register a start function without
  exporting it as a public export.
  #​5081

• Reinitialization is no longer automatically applied when using panic=unwind
  and --experimental-reset-state-function, instead it is triggered by any
  use of the handler::schedule_reinit() function under panic=unwind,
  which is supported from within the on_abort handler for reinit workflows.
  Renamed handler::reinit() to handler::schedule_reinit() and removed
  the set_on_reinit() handler. The __instance_terminated address
  is now always a simple boolean (0 = live, 1 = terminated).
  #​5083

• handler::schedule_reinit() now works under panic=abort builds. Previously
  it was a no-op; it now sets the JS-side reinit flag and the next export call
  transparently creates a fresh WebAssembly.Instance.
  #​5099

Changed

• MSRV bump from 1.71 to 1.76 for the CLI, and 1.82 to 1.86 for the API
  #​5102

Fixed

• ES module import statements are now hoisted to the top of generated JS
  files, placed right after the @ts-self-types directive. This ensures
  valid ES module output since import declarations must precede other
  statements.
  #​5103

• Fixed two CLI issues affecting WASM modules built by rustc 1.94+. First,
  a panic (failed to find N in function table) caused by lld emitting element
  segment offsets as global.get $__table_base or extended const expressions
  instead of plain i32.const N for large function tables; the fix adds a
  const-expression evaluator in get_function_table_entry and guards against
  integer underflow in multi-segment tables. Second, the descriptor interpreter
  now routes all global reads/writes through a single globals HashMap seeded
  from the module's own globals, and mirrors the module's actual linear memory
  rather than a fixed 32KB buffer, so the stack pointer's real value is valid
  without any override. This fixes panics like failed to find 32752 in function table caused by GOT.func.internal.* globals being misidentified as the
  stack pointer.
  #​5076
  #​5080
  #​5093
  #​5095

v0.2.117

Compare Source

Fixed

• Fixed a regression introduced in #​5026 where stable web-sys methods that
  accept a union type containing a [WbgGeneric] interface (e.g.
  ImageBitmapSource, which includes VideoFrame) incorrectly applied typed
  generics to all union expansions rather than only those whose argument type
  is itself [WbgGeneric]. In practice this caused Window::create_image_bitmap_with_*
  and the corresponding WorkerGlobalScope overloads to return
  Promise<ImageBitmap> instead of Promise<JsValue> for the stable
  (non-VideoFrame) call sites, breaking JsFuture::from(promise).await?.
  #​5064
  #​5073

• Fixed handling logic for environment variable WASM_BINDGEN_TEST_ADDRESS in
  the test runner, when running tests in headless mode.
  #​5087

v0.2.116

Compare Source

Added

• Added js_sys::Float16Array bindings, DataView float16 accessors using
  f32, and raw [u16] helper APIs for interoperability with binary16
  representations such as half::f16.
  #​5033

Changed

• Updated to Walrus 0.26.1 for deterministic type section ordering.
  #​5069

• The #[wasm_bindgen] macro now emits &mut (impl FnMut(...) + MaybeUnwindSafe)
  / &(impl Fn(...) + MaybeUnwindSafe) for raw &mut dyn FnMut / &dyn Fn
  import arguments instead of a hidden generic parameter and where-clause. The
  generated signature is cleaner and the MaybeUnwindSafe bound is visible
  directly in the argument position. The ABI and wire format are unchanged.
  When building with panic=unwind, closures that capture non-UnwindSafe
  values (e.g. &mut T, Cell<T>) must wrap them in AssertUnwindSafe before
  capture; on all other targets MaybeUnwindSafe is a no-op blanket impl.
  #​5056

v0.2.115

Compare Source

Added

• console.debug/log/info/warn/error output from user-spawned Worker and
  SharedWorker instances is now forwarded to the CLI test runner during
  headless browser tests, just like output from the main thread. Works for
  blob URL workers, module workers, URL-based workers (importScripts), nested
  workers, and shared workers (including logs emitted before the first port
  connection). Non-cloneable arguments are serialized via String() rather
  than crashing the worker. The --nocapture flag is respected.
  #​5037

• js_sys::Promise<T> now implements IntoFuture, enabling direct .await on
  any JS promise without a wrapper type. The wasm-bindgen-futures implementation
  has been moved into js-sys behind an optional futures feature, which is
  activated automatically when wasm-bindgen-futures is a dependency. All
  existing wasm_bindgen_futures::* import paths continue to work unchanged via
  re-exports. js_sys::futures is also available directly for users who want
  promise.await without depending on wasm-bindgen-futures.
  #​5049

• Added --target emscripten support, generating a library_bindgen.js file
  for consumption by Emscripten at link time. Includes support for futures,
  JS closures, and TypeScript output. A new Emscripten-specific test runner is
  also included, along with CI integration.
  #​4443

• Added VideoFrame, VideoColorSpace, and related WebCodecs dictionaries/enums to web-sys.
  #​5008

• Added wasm_bindgen::handler module with set_on_abort and set_on_reinit
  hooks for panic=unwind builds. set_on_abort registers a callback invoked
  after the instance is terminated (hard abort, OOM, stack overflow).
  set_on_reinit registers a callback invoked after reinit() resets the
  WebAssembly instance via --experimental-reset-state-function. Handlers are
  stored as Wasm indirect-function-table indices so dispatch is safe even when
  linear memory is corrupt.

Changed

• Replaced per-closure generic destructors with a single __wbindgen_destroy_closure
  export.
  #​5019

• Refactored the headless browser test runner logging pipeline for dramatically improved
  performance (>400x faster on Chrome, >10x on Firefox, ~5x on Safari). Switched to
  incremental DOM scraping with textContent.slice(offset), append-only output semantics,
  unified log capture across all log levels on failure, and browser-specific invisible-div
  optimizations (display:none for Chrome/Firefox, visibility:hidden for Safari).
  #​4960

• TTY-gated status/clear output in the test runner shell to avoid \r control-character
  artifacts in non-interactive (CI) environments.
  #​4960

• Added bench_console_log_10mb benchmark alongside the existing 1MB benchmark for the
  headless test runner. The main branch cannot complete this benchmark at any volume.
  #​4960

• Updated to Walrus 0.26
  #​5057

Fixed

• Fixed argument order when calling multi-parameter functions in the
  wasm-bindgen interpreter by reversing the args collected from the stack.
  #​5047

• Added support for per-operation [WbgGeneric] in WebIDL, restoring typed
  generic return types (e.g. Promise<ImageBitmap>) for createImageBitmap on
  Window and WorkerGlobalScope that were lost after the VideoFrame
  stabilization.
  #​5026

• Fixed missing #[cfg(feature = "...")] gates on deprecated dictionary builder
  methods and getters for union-typed fields (e.g. {Open,Save,Directory}FilePickerOptions::start_in()),
  and fixed per-setter doc requirements to list each setter's own required features.
  #​5039

• Fixed JsOption::new() to use undefined instead of null, to be compatible with Option::None and JS default parameters.
  #​5023

• Fixed unsound unsafe transmutes in JsOption<T>::wrap, as_option, and into_option
  by replacing transmute_copy with unchecked_into(). Also tightened the JsGeneric
  trait bound and JsOption<T> impl block to require T: JsGeneric (which implies JsCast),
  preventing use with arbitrary non-JS types.
  #​5030

• Fixed headless test runner emitting \r carriage-return sequences in non-TTY environments,
  which polluted captured logs in CI and complicated output-matching tests.
  #​4960

• Fixed headless test runner printing incomplete and out-of-order log output on test failures
  by merging all five log levels into a single unified output div.
  #​4960

• Fixed large test outputs (10MB+) causing oversized WebDriver responses that were either
  extremely slow or crashed completely, by switching to incremental streaming output collection.
  #​4960

• Fixed a duplciate wasm export in node ESM atomics, when compiled in debug mode
  #​5028

• Fixed a type inference regression (E0283: type annotations needed) introduced
  in v0.2.109 where the stable FromIterator and Extend impls on js_sys::Array
  were changed from A: AsRef<JsValue> to A: AsRef<T>. Because #[wasm_bindgen]
  generates multiple AsRef impls per type, the compiler could not uniquely resolve
  T, breaking code like Array::from_iter([my_wasm_value]) without explicit
  annotations. The stable impls are restored to A: AsRef<JsValue> (returning
  Array<JsValue>); the generic A: AsRef<T> forms remain available under
  js_sys_unstable_apis.
  #​5052

• Fixed skip_typescript not being respected when using reexport, causing
  TypeScript definitions to be incorrectly emitted for re-exported items marked
  with #[wasm_bindgen(skip_typescript)].
  #​5051

Removed

v0.2.114

Compare Source

Added

• Added [WbgGeneric] WebIDL extended attribute for opting stable dictionary and interface
  definitions into typed generics (the same signatures unstable APIs use), avoiding legacy
  &JsValue fallbacks. Applied to all new VideoFrame-related types.
  #​5008

• Added unchecked_optional_param_type attribute for marking exported function parameters as
  optional in TypeScript (?:) and JSDoc ([paramName]) output. Mutually exclusive with
  unchecked_param_type. Required parameters after optional parameters are rejected at compile time.
  #​5002

• Added termination detection for panic=unwind builds. When a non-JS exception (e.g. a Rust
  panic) escapes from Wasm, the instance is marked as terminated and subsequent calls from JS
  into Wasm will throw a Module terminated error instead of re-entering corrupted state.
  #​5005

• When --reset-state is combined with panic=unwind builds, the Wasm instance is
  automatically reset after a fatal termination, allowing subsequent calls to succeed
  instead of throwing a Module terminated error.
  #​5013

Changed

• Replaced runtime 0x80000000 vtable bit-flag for closure unwind safety with a
  compile-time const UNWIND_SAFE: bool generic on the invoke shim, OwnedClosure,
  and BorrowedClosure. Removes OwnedClosureUnwind and deduplicates internal
  closure helpers. The public API is unchanged.
  #​5003

• Removed unused IntoWasmClosureRef*::WithLifetime types,
  WasmClosure::to_wasm_slice, and a lifetime from
  IntoWasmClosureRef*; moved Static associated type into WasmClosure.
  #​5003

Fixed

• Fixed exported structs/enums/functions with the same js_name but different
  js_namespace values producing symbol collisions at compile time, by deriving
  internal wasm symbols from a qualified name that includes the namespace.
  #​4977

• Fixed soundness hole in ScopedClosure's UpcastFrom that allowed to extend the lifetime after the original ScopedClosure was dropped.
  #​5006

v0.2.113

Compare Source

Changed

• Reduced usage of unsafe code: replaced transmute/transmute_copy with safe
  alternatives for Boolean/Null/Undefined constants and ArrayTuple conversions,
  unified duplicated AsRef/From impls for generic imported types, and removed the
  __wbindgen_object_is_undefined intrinsic in favor of a safe Rust-side equivalent.
  #​4993

• Renamed __wbindgen_object_is_null_or_undefined intrinsic to
  __wbindgen_is_null_or_undefined and removed the __wbindgen_object_is_undefined
  intrinsic, replacing it with a safe Rust-side check. The is_null_or_undefined check
  now uses safe &JsValue ABI instead of raw u32.
  #​4994

Fixed

• Fixed incorrect method naming for stable web-sys methods that reference unstable
  types (e.g. texImage2D taking a VideoFrame parameter). These methods were
  being named in a separate unstable expansion namespace, producing overly-short
  names like tex_image_2d instead of the correct
  tex_image_2d_with_u32_and_u32_and_video_frame. The fix separates the signature
  classification to distinguish "from unstable IDL" (authoritative overrides) from
  "stable method using an unstable type", ensuring the latter is named as part of
  the stable expansion.
  #​4991

v0.2.112

Compare Source

Removed

• Removed ImmediateClosure type introduced in 0.2.109. Stack-borrowed &dyn Fn / &mut dyn FnMut
  closures are now treated as unwind safe by default (panics are caught and converted to JS exceptions
  with proper unwinding). A unified ScopedClosure::immediate approach may be revisited in a future
  release.
  #​4986

v0.2.111

Compare Source

Fixed

• Restored backwards compatibility for breaking changes introduced in 0.2.110:
  re-added deprecated Promise::then2 binding, reverted Promise::all_settled
  stable signature to take &JsValue instead of owned Object, and added
  default type parameters (= JsValue) to ArrayIntoIter, ArrayIter, and
  Iter structs.
  #​4979

v0.2.110

Compare Source

Changed

• Refactor new closure methods - ensures that all closure constructor functions have the variants Closure::foo(), Closure::foo_aborting() and
  Closure::foo_assert_unwind_safe() this then fully allows switching from the UnwindSafe bound now being applies on foo() to use one of the
  alternatives, given these limitations of AssertUnwindSafe. The same applies to ImmediateClosure. In addition, mutable reentrancy guards are
  added for ImmediateClosure, and it is updated to be pass-by-value as well.
  #​4975

Fixed

• Fixed a regression where Array.of1,... variants using generic Array<T> broke inference.
  Reverted to use non-generic JsValue arguments. In addition extends generic class hoisting to
  for constructors to also include static_method_of methods returning the own type, to allow
  Array::of generic to now be on the Array<T> impl block.
  #​4974

v0.2.109

Compare Source

Added

• Added support for erasable generic type parameters on imported JavaScript types,
  using sound type erasure in JS bindgen boundary. Includes updated js-sys bindings
  with generic implementations for many standard JS types and functions including
  Array<T>, Promise<T>, Map<K, V>, Iterator<T>, and more.
  #​4876

• Added ScopedClosure<'a, T> as a unified closure type with lifetime parameter. ScopedClosure::borrow(&f) (for immutable Fn) and ScopedClosure::borrow_mut(&mut f) (for mutable FnMut) create borrowed closures that can capture non-'static references, ideal for immediate/synchronous JS callbacks. Closure<T> is now a type alias for ScopedClosure<'static, T>, maintaining backwards compatibility. Also added IntoWasmAbi implementation for Closure<T> enabling pass-by-value ownership transfer to JavaScript.

• Added ImmediateClosure<'a, T> as a lightweight, unwind-safe replacement for
  &dyn FnMut in immediate/synchronous callbacks. Unlike ScopedClosure, it has
  no JS call on creation, no JS call on drop, and no GC overhead—the same ABI as
  &dyn FnMut but with panic safety. Use ImmediateClosure::new(&f) for
  immutable Fn closures (easier to satisfy unwind safety) or ImmediateClosure::new_mut(&mut f) for
  mutable FnMut closures. Closure parameter types are automatically inferred from context.
  Also implements From<&ImmediateClosure<T>> for ScopedClosure<T> for API migration.
  #​4950

• Implement #[wasm_bindgen(catch)] exception handling directly in Wasm using
  WebAssembly.JSTag when Wasm exception handling is available. This generates
  smaller and faster code by avoiding JavaScript handleError wrapper functions.
  #​4942

• Add Node.js worker_threads support for atomics builds. When targeting Node.js with atomics enabled, wasm-bindgen now generates initSync({ module, memory, thread_stack_size }) and __wbg_get_imports(memory) functions that allow worker threads to initialize with a shared WebAssembly.Memory and pre-compiled module. Auto-initialization occurs only on the main thread for backwards compatibility.

• Added a panic message when a getter has more than one argument.
  #​4936

• Added support for WebIDL namespace attributes in wasm-bindgen-webidl. This enables
  APIs like the CSS Custom Highlight API which adds the highlights attribute to the CSS namespace.
  #​4930

• Added stable ShowPopoverOptions dictionary and show_popover_with_options() method to
  HtmlElement, and unstable TogglePopoverOptions dictionary per the WHATWG HTML spec.
  #​4968

• Added unstable Geolocation API types per the latest W3C spec: GeolocationCoordinates,
  GeolocationPosition, and GeolocationPositionError. The Geolocation interface now
  has both stable methods (using the old Position/PositionError types with [Throws])
  and unstable methods (using the new types without [Throws]}, matching actual browser behavior).
  #​2578

• Added matrixTransform() method to DOMPointReadOnly in web-sys.
  #​4962

• Added the web and node targets to the --experimental-reset-state-function flag.
  #​4909

• Added oncancel event handler to GlobalEventHandlers (available on HtmlElement,
  Document, Window, etc.).
  #​4542

• Added CommandEvent and CommandEventInit from the Invoker Commands API.
  #​4552

• Added AbstractRange, StaticRange, and StaticRangeInit interfaces.
  #​4221

• Updated WebCodecs API to Working Draft 2026-01-29 and MediaRecorder API to 2025-04-17.
  Added rotation and flip to VideoDecoderConfig.
  #​4411

• Added support for unstable WebIDL to override stable attribute types, allowing
  corrected type signatures behind web_sys_unstable_apis. Applied to MouseEvent
  coordinate attributes (clientX, clientY, screenX, screenY, offsetX,
  offsetY, pageX, pageY) which now return f64 instead of i32 when
  unstable APIs are enabled, per the CSSOM View spec draft.
  #​4935

• Added support for unstable WebIDL to override stable method return types. This
  enables User Timing Level 3 APIs where Performance.mark() and Performance.measure()
  return PerformanceMark and PerformanceMeasure respectively (instead of undefined)
  when web_sys_unstable_apis is enabled. Also added PerformanceMarkOptions,
  PerformanceMeasureOptions, and the detail attribute on marks/measures.
  #​3734

• Added non-standard mode option for FileSystemFileHandle.createSyncAccessHandle().
  Also improved WebIDL generator to track stability at the signature level, allowing
  stable methods to have unstable overloads.
  #​4928

• Updated WebGPU bindings to the February 2026 spec. Dictionary fields with union
  types now generate multiple type-safe setters (e.g. set_resource_gpu_sampler(),
  set_resource_gpu_texture_view()) alongside a deprecated fallback setter. Sequence
  arguments in unstable APIs now use typed slices (&[T]) instead of &JsValue.
  Fixed inner string enum types to use JsString in generic positions, added BigInt
  to builtin identifiers, and fixed dictionary field feature gates to not over-constrain
  getters with setter type requirements.
  #​4955

• Improved dictionary union type expansion: stable fallback setters are no longer
  deprecated, and unstable builder methods now use the first typed variant instead
  of &JsValue. Dictionaries with required union fields now generate expanded
  constructors for each variant (e.g. new(), new_with_gpu_texture_view()),
  with duplicate-signature variants elided.
  #​4966

Changed

• Increased externref stack size from 128 to 1024 slots to prevent "table index is out of bounds"
  errors in applications with deep call stacks or many concurrent async operations.
  #​4951

• Closure::new(), Closure::once(), and related methods now require UnwindSafe bounds on closures when building with panic=unwind. New _aborting variants (new_aborting(), once_aborting(), etc.) are provided for closures that don't need panic catching and want to avoid the UnwindSafe requirement.
  #​4893

• global does not use the unsafe-eval new Function trick anymore allowing to have CSP strict compliant packages with wasm-bindgen.
  #​4910

• eval and Function constructors are now gated behind the unsafe-eval feature.
  #​4914

Fixed

• Fixed incorrect JS export names when LLVM merges identical functions at opt-level >= 2.
  #​4946

• Fixed incorrect Closure adapter deduplication when wasm-ld's Identical Code Folding merges
  invoke functions for different closure types into the same export.
  #​4953

• Fixed ReferenceError when using Rust struct names that conflict with JS builtins (e.g., Array).
  The constructor now correctly uses the aliased FinalizationRegistry identifier.
  #​4932

• Fixed Element::scroll_top(), Element::scroll_left(), and HtmlElement::scroll_top()
  to return f64 instead of i32 per the CSSOM View spec, behind web_sys_unstable_apis.
  The stable API is unchanged for backwards compatibility.
  #​4525

• Added spec-compliant i32 parameter types for CanvasRenderingContext2d::get_image_data()
  and put_image_data() (and OffscreenCanvasRenderingContext2d equivalents) behind
  web_sys_unstable_apis. Per the HTML spec, getImageData and putImageData use long
  (i32) for coordinates, not double (f64). The stable API is unchanged for backwards
  compatibility.
  #​1920

• Fixed incorrect #[cfg(web_sys_unstable_apis)] gating on stable method signatures that
  share a WebIDL operation with unstable overloads. For example, Clipboard.read() (0 args)
  was incorrectly gated as unstable because the unstable read(options) overload existed.
  The WebIDL code generator now uses an authoritative expansion model where stable and unstable
  signature sets are built independently and compared: identical signatures merge (no gate),
  stable-only signatures get not(unstable), and unstable-only signatures get unstable.
  Also adds typed generics (Promise<T>, Array<T>, Function<fn(...)>, etc.) to all
  unstable API methods, and adds missing PhotoCapabilities, PhotoSettings,
  MediaSettingsRange, Point2D, RedEyeReduction, FillLightMode, and MeteringMode
  types from the W3C Image Capture spec.
  #​4964

• Fixed unfulfilled_lint_expectations warnings when using #[expect(...)] attributes
  on functions annotated with #[wasm_bindgen]. The #[expect] attributes are now
  converted to #[allow] in generated code to prevent spurious warnings.
  #​4409

v0.2.108

Compare Source

Fixed

• Fixed regression where panic=unwind builds for non-Wasm targets would trigger UnwindSafe assertions.
  #​4903

v0.2.107

Compare Source

Added

• Support catching panics, and raising JS Exceptions for them, when building
  with panic=unwind on nightly, with the std feature.
  #​4790

• Added support for passing &[JsValue] slices from Rust to JavaScript functions.
  #​4872

• Added private attribute on exported types to allow generating
  exports and structs as implicit internal exported types for function
  arguments and returns, without exporting them on the public interface.
  #​4788

• Added iter_custom and iter_custom_future for bench to do custom measurements.
  #​4841

• Added Window Management API.
  #​4843

Changed

• Changed WASM import namespace from wbg to ./{name}_bg.js for web and no-modules targets,
  aligning with bundler and experimental-nodejs-module to enable cross-target WASM sharing.
  #​4850

• Replace WASM_BINDGEN_UNSTABLE_TEST_PROFRAW_OUT and WASM_BINDGEN_UNSTABLE_TEST_PROFRAW_PREFIX with parsing LLVM_PROFILE_FILE analogous to Rust test coverage.
  #​4367

• Typescript custom sections sorted alphabetically across codegen-units.
  #​4738

• Optimized demangling performance by removing redundant string formatting
  #​4867

• Changed WASM import namespace from __wbindgen_placeholder__ to ./{name}_bg.js for node targets, aligning with bundler and experimental-nodejs-module to enable cross-target WASM sharing.
  #​4869

• Changed WASM import namespace from __wbindgen_placeholder__ to ./{name}_bg.js for deno and module targets, aligning with node, bundler and experimental-nodejs-module to enable cross-target WASM sharing.
  #​4871

• Consolidate JavaScript glue generation
  Move target-specific JS emission into a single finalize phase, reducing
  branching and making the generated output more consistent across targets.

  • Centralize JS output assembly in a single finalize phase (exports/imports/wasm loading).
  • Make --target experimental-nodejs-module emit one JS entrypoint (no separate _bg.js).
  • Ensure Node (CJS/ESM) and bundler entrypoints only expose public exports (no internal import shims).
  • Add /* @&#8203;ts-self-types="./<name>.d.ts" */ to JS entrypoints for JSR/Deno resolution.
  • Refresh reference test fixtures.
    #​4879

• Forward worker errors to test output in the test runner.
  #​4855

Fixed

• Fix: Include doc comments in TypeScript definitions for classes
  #​4858

• Interpreter: support try_table blocks
  #​4862

• Interpreter: Stop interpretting descriptor after __wbindgen_describe_cast
  #​4862

v0.2.106

Compare Source

Added

• New MSRV policy, and bump of the MSRV fo 1.71.
  #​4801

• Added CSS Custom Highlight API to web-sys.
  #​4792

• Added typed this support in the first argument in free function exports via
  a new #[wasm_bindgen(this)] attribute.
  #​4757

• Added reexport attribute for imports to support re-exporting imported types,
  with optional renaming.
  #​4759

• Added js_namespace attribute on exported types, mirroring the import
  semantics to enable arbitrarily nested exported interface objects.
  #​4744

• Added 'container' attribute to ScrollIntoViewOptions
  #​4806

• Updated and refactored output generation to use alphabetical ordering
  of declarations.
  #​4813

• Added benchmark support to wasm-bindgen-test.
  #​4812
  #​4823

Fixed

• Fixed node test harness getting stuck after tests completed.
  #​4776

• Quote names containing colons in generated .d.ts.
  #​4488

• Fixes TryFromJsValue for structs JsValue stack corruption on failure.
  #​4786

• Fixed wasm-bindgen-test-runner outputting empty line when using the --list option. In particular, cargo-nextest now works correctly.
  #​4803

• It now works to build with -Cpanic=unwind.
  #​4796
  #​4783
  #​4782

• Fixed duplicate symbols caused by enabling v0 mangling.
  #​4822

• Fixed a multithreaded wasm32+atomics race where Atomics.waitAsync promise callbacks could call run without waking first, causing sporadic panics.
  #​4821

Removed

v0.2.105

Compare Source

Added

• Added Math::PI binding to js_sys, exposing the ECMAScript Math.PI constant.
  #​4748

• Added ability to use --keep-lld-exports in wasm-bindgen-test-runner by setting the WASM_BINDGEN_KEEP_LLD_EXPORTS environment variable.
  #​4736

• Added CookieStore API.
  #​4706

• Added run_cli_with_args library functions to all wasm_bindgen_cli entrypoints.
  #​4710

• Added get_raw and set_raw for WebAssembly.Table.
  #​4701

• Added new_with_value and grow_with_value for WebAssembly.Table.
  #​4698

• Added better support for async stack traces when building in debug mode.
  #​4711

• Extended support for TryFromJsValue trait implementations.
  #​4714

• New JsValue.is_null_or_undefined() method and intrinsic.
  #​4751

• Support for Option<JsValue> in function arguments and return.
  #​4752

• Support for WASM_BINDGEN_KEEP_TEST_BUILD=1 environment variable
  to retain build files when using the test runner.
  #​4758

Fixed

• Fixed multithreading JS output for targets bundler, deno and module.
  #​4685

• Fixed TextDe/Encoder detection for audio worklet use-cases.
  #​4703

• Fixed post-processing failures in case Std has debug assertions enabled.
  #​4705

• Fixed JS memory leak in wasm_bindgen::Closure.
  #​4709

• Fixed warning when using #[wasm_bindgen(wasm_bindgen=xxx)] on struct.
  #​4715

Removed

• Internal crate wasm-bindgen-backend will no longer be published.
  #​4696

v0.2.104

Compare Source

Added

• Added bindings for WeakRef.
  #​4659

• Support Symbol.dispose methods by default, when it is supported in the environment.
  #​4666

• Added aarch64-unknown-linux-musl release artifacts.
  #​4668

Changed

• Unconditionally use the global TextEncoder/TextDecoder for string encoding/decoding. The Node.js output now requires a minimum of Node.js v11.
  #​4670

• Deprecate the msrv crate feature. MSRV detection is now always on.
  #​4675

Fixed

• Fixed wasm-bindgen-cli's encode_into argument not working.
  #​4663

• Fixed a bug in --experimental-reset-state-function support for heap reset.
  #​4665

• Fixed compilation failures on Rust v1.82 and v1.83.
  #​4675

---

v0.2.103

Compare Source

Fixed

• Fixed incorrect function mapping during post-processing.
  #​4656

---

v0.2.102

Compare Source

Added

• Added DocumentOrShadowRoot.adoptedStyleSheets.
  #​4625

• Added support for arguments with spaces using shell-style quoting in webdriver *_ARGS
  environment variables to wasm-bindgen-test.
  #​4433

• Added ability to determine WebDriver JSON config location via
  WASM_BINDGEN_TEST_WEBDRIVER_JSON environment variable to
  wasm-bindgen-test.
  #​4434

• Generate DWARF for tests by default. See the guide on debug information for more details.
  #​4635

• New --target=module target for outputting source phase imports.
  #​4638

Changed

• Hidden deprecated options from the wasm-bindgen --help docs.
  #​4646

Fixed

• Fixed wrong method names for GestureEvent bindings.
  #​4615

• Fix crash caused by allocations during TypedArray interactions.
  #​4622

---

v0.2.101

Compare Source

Added

• Added format and colorSpace support to VideoFrameCopyToOptions
  #​4543

• Added support for the [onbeforeinput](https://developer.mozilla.org/en-US/docs/W

✂ Note

PR body was truncated to here.

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • At any time (no schedule defined)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR has been generated by Mend Renovate.

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.