Changed

• Emscripten output now hoists every clean export (free functions, classes,
  enums, plus their finalization registries and string-enum tables) out of the
  $initBindgen init closure into its own top-level addToLibrary symbol and
  self-registers it into EXPORTED_FUNCTIONS. emscripten then emits the clean
  API (add, Counter, ...) as named ESM exports under -sMODULARIZE=instance
  and as Module.<name> properties (via each symbol's __postset) in factory
  mode, with no extra sidecar files. Namespaced exports are reached through
  their namespace root (e.g. app), assembled in the root symbol's __postset.
  User module/inline-js imports are now wired as addToLibrary shims (they were
  previously dropped, since emcc resolves imports only against env), and their
  ESM-imported bindings are __wbg_-prefixed to avoid colliding with emcc
  runtime names such as Module/HEAP8.
  #5210

Fixed

• The descriptor interpreter now follows emscripten invoke_* trampolines.
  emscripten's exception/longjmp lowering rewrites direct calls into indirect
  calls through the function table wrapped in imported invoke_*(fnptr, ..args)
  helpers, including the describe helpers a descriptor function must reach. The
  interpreter resolves fnptr against the reconstructed function table, forwards
  the trailing arguments, and evaluates the surrounding "did it throw?" control
  flow (if/else, loop, br_table), so descriptors are interpreted
  correctly on emscripten builds with unwinding/longjmp enabled.
  #5215

• Relaxed alignment requirement for 8-byte types.
  #5204

Added

• Added the --force-enable-abort-handler CLI flag, which emits the hard-abort
  detection and set_on_abort machinery on panic=abort builds. With
  panic=unwind this machinery is generated automatically; the flag does
  nothing there.
  #5191

Changed

• Made the internal __wbindgen_destroy_closure export private in the Rust API.
  #5196

Added

• Added the maxAge attribute to the CookieInit dictionary in web-sys,
  matching the current Cookie Store API specification.
  #5169

• The js-sys futures codegen opt-in can now also be enabled via the
  WASM_BINDGEN_USE_JS_SYS=1 environment variable, in addition to
  --cfg=wasm_bindgen_use_js_sys. This works on stable when --target
  is in use, where Cargo does not propagate the cfg to host proc-macros.
  #5164

Changed

• JsOption<T> now treats only undefined as empty, aligning it with
  TypeScript's strict T | undefined semantics and with Option<T>'s wire
  shape (None ↔ undefined). Previously is_empty, as_option,
  into_option, unwrap, expect, unwrap_or_default, and
  unwrap_or_else treated both null and undefined as absent; JS null
  is now a distinct present value. The impl<T> UpcastFrom<Null> for JsOption<T> is removed (Undefined still models absence), and the
  Debug/Display absent placeholder changed from "null" to
  "undefined". Code relying on null → None should return undefined
  from the JS side, or check explicitly with
  val.as_option().filter(|v| !v.is_null()).
  #5170

Fixed

• Removed invalid js_sys::Array<T> to js_sys::ArrayTuple<(...)> upcasts.
  ArrayTuple encodes a fixed tuple arity, while a plain JavaScript array does
  not prove that arity statically.

• Fixed incorrect variance in &mut reference upcasting. &mut T upcasts
  were covariant in the pointee, so a &mut T could be widened to a &mut
  of a supertype and used to write back a value the original type would not
  accept, leaving a reference whose static type no longer matches the value
  it points to. Mutable references are now invariant in their pointee:
  &mut T only upcasts to &mut Target when both Target: UpcastFrom<T>
  and T: UpcastFrom<Target> hold. This rejects the invalid widening but is
  a breaking change for callers that relied on widening &mut references.
  #5176

• Fixed WASI targets (wasm32-wasip1/wasm32-wasip2) emitting unresolved
  __wbindgen_placeholder__ imports, which broke component linking. The
  codegen and runtime gates now exclude target_os = "wasi" (restoring the
  pre-0.2.115 stub behavior), including the panic = "unwind" paths in
  wasm-bindgen-futures.
  #5175

• Fixed a panic ("Unhandled load width 8") in the descriptor interpreter when
  processing -Cinstrument-coverage-instrumented modules, unblocking
  cargo llvm-cov --target wasm32-unknown-unknown for crates whose describe
  helpers get instrumented.
  #5179

• Fixed main silently never running on wasm64 for bin crates.
  #5181

Notices

• Threading support now requires -Clink-arg=--export=__heap_base to be set
  in RUSTFLAGS for nightly toolchains from 2026-05-06 onward, after
  rust-lang/rust#156174
  removed the implicit __heap_base/__data_end exports on wasm*
  targets. Atomics CI, CLI reference tests, and the nodejs-threads,
  raytrace-parallel, and wasm-audio-worklet examples have been
  updated to pass --export=__heap_base explicitly. The flag is
  backward-compatible with older nightlies.

• -Cpanic=unwind on wasm targets now emits modern (exnref) exception
  handling by default after
  rust-lang/rust#156061,
  and requires Node.js 22.22.3+ (for WebAssembly.JSTag). Legacy EH wasm
  can still be produced on current nightlies by adding
  -Cllvm-args=-wasm-use-legacy-eh to RUSTFLAGS; Node.js 20 may be
  supported with legacy exception handling, with a tracking issue in
  #5151.

Added

• Implemented TryFromJsValue for Vec<T> where T: TryFromJsValue.
  A JS value converts when it is a real Array (per Array.isArray)
  and every element converts via T::try_from_js_value. This composes
  recursively (Vec<Vec<String>>, Vec<Option<T>>) and works for any
  T with a TryFromJsValue impl, including primitives, String,
  JsValue, and JsCast types. Array-likes (objects with length and
  numeric indices) are intentionally rejected to mirror the static ABI
  representation used by js_value_vector_from_abi.

• New extends_js_class and extends_js_namespace attributes on
  exported structs to allow defining the parent js_class name when
  it has been customized by js_name and the parent's own js_namespace
  as well in turn. New validation is added at code generation time that
  will now catch these cases instead of emitting invalid code. Example:

  #[wasm_bindgen(js_name = "Animal", js_namespace = zoo)]
  pub struct AnimalImpl { /* ... */ }
  
  #[wasm_bindgen(
      extends = AnimalImpl,
      extends_js_class = "Animal",
      extends_js_namespace = zoo,
  )]
  pub struct DogImpl { /* ... */ }

  #5154

Changed

• When an exported struct uses js_namespace, the corresponding value
  must now be repeated on every impl block. Previously the impl-side
  defaults silently worked resulting in inconsistent emission. Example:

  // Before:
  #[wasm_bindgen(js_namespace = "default")]
  pub struct Counter { /* ... */ }
  
  #[wasm_bindgen]              // worked, but fragile
  impl Counter { /* ... */ }
  
  // After:
  #[wasm_bindgen(js_namespace = "default")]
  pub struct Counter { /* ... */ }
  
  #[wasm_bindgen(js_namespace = "default")]   // now required
  impl Counter { /* ... */ }

  To ease this transition for js_namespace usage, diagnostic
  messages now include hints for missing namespaces for easier
  fixing.

  #5154

Fixed

• Fixed the descriptor interpreter panicking on Br and BrIf
  instructions emitted by recent nightly compilers when building with
  panic=unwind.
  #5158

• Emscripten output now works against vanilla upstream emscripten without
  requiring a fork. Dependency tracking, HEAP_DATA_VIEW setup,
  function-decl intrinsic inlining, catch-wrapper gating, and imported
  global handling have all been corrected; ESM imports
  (#[wasm_bindgen(module = "...")] and snippets) are emitted to a
  sidecar library_bindgen.extern-pre.js consumers pass to emcc via
  --extern-pre-js; namespaced exports (js_namespace = [...] on a
  struct/impl) now attach to Module.<segments> instead of emitting
  top-level export const (which emcc's library evaluator rejects);
  the generated .d.ts for namespaced exports is now valid TypeScript
  (mangled identifiers stay module-internal via declare class /
  declare enum / declare function plus export { BindgenModule };
  to mark the file as a module; no spurious unqualified Calc:
  property on BindgenModule for namespaced items; namespace shapes
  land as plain interface members (app: { math: { Calc: typeof app__math__Calc } };) instead of the previously-emitted export let app: { ... }; which was invalid TS1131 syntax inside an
  interface body).
  #5156

• Fixed a duplicate phantom class being emitted for an exported struct
  renamed via js_name (Rust ident != JS class name) and/or placed in a
  js_namespace, when the struct crosses the boundary as a JsValue
  (e.g. via .into()). The WrapInExportedClass / UnwrapExportedClass
  imports were keyed by the Rust ident rather than the qualified JS name
  that exported_classes is keyed by (a regression from #5154), so a
  fresh empty class entry was minted and emitted alongside the real one,
  with a free() referencing a nonexistent wasm export. Riding the
  same release's #5154 wire-format bump, the now-vestigial rust_name
  field is dropped from the schema and the namespace-qualified name is
  no longer cached on AuxStruct, AuxEnum, or ExportedClass
  (derived on demand from (name, js_namespace)), collapsing three
  fallback chains that only papered over the pre-#5154 keying.

  #5160

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

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

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

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

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

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