typewire 0.0.3

//! Derive-based cross-language type bridging for Rust.
//!
//! `typewire` provides the [`Typewire`] trait and a derive macro that generates
//! platform-specific conversion methods and compile-time schema records from
//! your Rust types. Define types once in Rust, get type-safe foreign-language
//! bindings and declarations automatically.
//!
//! Currently supported targets:
//! - **WebAssembly** (wasm32) — `to_js` / `from_js` / `patch_js` via
//!   `wasm-bindgen`, with TypeScript `.d.ts` generation
//! - **Kotlin** and **Swift** — planned
//!
//! # Quick start
//!
//! ```
//! use typewire::Typewire;
//!
//! #[derive(Typewire)]
//! #[typewire(rename_all = "camelCase")]
//! struct CreateUser {
//!   user_name: String,
//!   age: u32,
//!   email: Option<String>,
//! }
//!
//! // Option<T> fields implicitly default to None when absent
//! assert_eq!(<Option<String>>::or_default(), Some(None));
//!
//! // Non-optional types have no implicit default
//! assert!(String::or_default().is_none());
//! ```
//!
//! On `wasm32`, this generates conversions matching the serde wire shape
//! (`{ "userName": ..., "age": ..., "email": ... }`), plus a `patch_js`
//! that updates foreign objects in place by diffing only changed fields.
//!
//! # Pipeline
//!
//! ```text
//! #[derive(Typewire)]  →  encode (link section)  →  decode  →  declarations
//!      (derive)             (typewire-schema)        (CLI)      (codegen)
//! ```
//!
//! 1. [`#[derive(Typewire)]`](Typewire) analyzes types and emits platform-gated
//!    conversion methods + schema records in link sections (when the `schemas`
//!    feature is enabled)
//! 2. The `typewire` CLI extracts schema records from compiled binaries and
//!    generates typed declarations for the target language
//! 3. The generated declarations match the wire format of the Rust types
//!
//! # Built-in type implementations
//!
//! | Category | Types |
//! |----------|-------|
//! | Booleans | [`bool`] |
//! | Integers | [`i8`], [`i16`], [`i32`], [`u8`], [`u16`], [`u32`] (exact) |
//! | Big integers | [`i64`], [`u64`], [`i128`], [`u128`], [`isize`], [`usize`] |
//! | Floats | [`f32`], [`f64`] |
//! | Strings | [`String`], [`Cow<str>`](std::borrow::Cow), [`char`] |
//! | Unit | `()` |
//! | Options | [`Option<T>`] |
//! | Sequences | [`Vec<T>`], `[T; N]` |
//! | Maps | [`HashMap`](std::collections::HashMap), [`BTreeMap`](std::collections::BTreeMap) |
//! | Tuples | `(A, B, ...)` up to 12 elements |
//! | Smart pointers | [`Box<T>`], [`Arc<T>`](std::sync::Arc), [`Rc<T>`](std::rc::Rc) |
//!
//! With optional features: `uuid`, `chrono`, `url`, `bytes`, `indexmap`,
//! `serde_json`, `fractional_index`.
//!
//! # Features
//!
//! | Feature | What it enables |
//! |---------|----------------|
//! | `derive` *(default)* | Re-exports [`#[derive(Typewire)]`](Typewire) |
//! | `schemas` | Embeds schema records in link sections for codegen |
//! | `uuid` | [`Typewire`] impl for `uuid::Uuid` |
//! | `chrono` | [`Typewire`] impl for `chrono::DateTime` |
//! | `url` | [`Typewire`] impl for `url::Url` |
//! | `bytes` | [`Typewire`] impl for `bytes::Bytes` |
//! | `indexmap` | [`Typewire`] impls for `IndexMap` / `IndexSet` |
//! | `base64` | [`base64_encode`] / [`base64_decode`] helpers |
//! | `serde_json` | [`Typewire`] impl for `serde_json::Value` |
//! | `cli` | Binary target for schema extraction + declaration generation |

mod error;

/// Conversion errors produced during foreign-language value decoding.
///
/// See [`Error`] for variant documentation.
pub use error::Error;
/// Derive macro for the [`Typewire`] trait.
///
/// See the [`typewire_derive`] crate for the full attribute reference.
///
/// # Examples
///
/// Named struct with field renaming:
///
/// ```
/// use typewire::Typewire;
///
/// #[derive(Typewire)]
/// #[typewire(rename_all = "camelCase")]
/// struct User {
///   user_name: String,
///   email: Option<String>,
/// }
/// ```
///
/// Internally-tagged enum:
///
/// ```
/// use typewire::Typewire;
///
/// #[derive(Typewire)]
/// #[typewire(tag = "kind")]
/// enum Shape {
///   Circle { radius: f64 },
///   Rect { width: f64, height: f64 },
/// }
/// ```
///
/// Transparent newtype:
///
/// ```
/// use typewire::Typewire;
///
/// #[derive(Typewire)]
/// #[typewire(transparent)]
/// struct UserId(String);
/// ```
#[cfg(feature = "derive")]
pub use typewire_derive::Typewire;
/// Schema metadata crate, re-exported for use by generated code.
///
/// End users typically don't interact with this directly — it is used by
/// the derive macro and the `typewire` CLI. See [`typewire_schema`] for
/// the pipeline documentation.
pub use typewire_schema as schema;

/// Base64-encode bytes to a string using the standard alphabet.
///
/// Called by generated code for fields annotated with `#[typewire(base64)]`.
///
/// ```
/// # #[cfg(feature = "base64")] {
/// let encoded = typewire::base64_encode(b"hello");
/// assert_eq!(encoded, "aGVsbG8=");
/// # }
/// ```
#[cfg(feature = "base64")]
#[must_use]
pub fn base64_encode(bytes: &[u8]) -> String {
  use base64::Engine as _;
  base64::engine::general_purpose::STANDARD.encode(bytes)
}

/// Base64-decode a string to bytes using the standard alphabet.
///
/// Called by generated code for fields annotated with `#[typewire(base64)]`.
///
/// # Errors
///
/// Returns [`base64::DecodeError`] if the input is not valid base64.
///
/// ```
/// # #[cfg(feature = "base64")] {
/// let bytes = typewire::base64_decode("aGVsbG8=").unwrap();
/// assert_eq!(bytes, b"hello");
///
/// assert!(typewire::base64_decode("not valid!").is_err());
/// # }
/// ```
#[cfg(feature = "base64")]
pub fn base64_decode(s: &str) -> Result<Vec<u8>, base64::DecodeError> {
  use base64::Engine as _;
  base64::engine::general_purpose::STANDARD.decode(s)
}

/// Bidirectional conversion between Rust types and foreign-language values.
///
/// This is the core trait of the typewire framework. It provides:
///
/// - **`Ident` / `IDENT`** — a compile-time type identity used by the schema
///   pipeline to embed type metadata in link sections (always available)
/// - **`or_default()`** — implicit defaults for absent fields (always available)
/// - **Platform-specific methods** — conversion to/from foreign values, gated
///   by `#[cfg]` (e.g. `to_js`/`from_js`/`patch_js` on `wasm32`)
///
/// # Deriving
///
/// Use [`#[derive(Typewire)]`](typewire_derive) to generate all implementations
/// automatically. The derive respects serde-compatible attributes:
///
/// ```
/// use typewire::Typewire;
///
/// #[derive(Clone, PartialEq, Debug, Typewire)]
/// #[typewire(rename_all = "camelCase")]
/// struct Point {
///   x_coord: f64,
///   y_coord: f64,
/// }
///
/// // No implicit default for structs
/// assert!(Point::or_default().is_none());
/// ```
///
/// # Manual implementation
///
/// For types not covered by the derive, implement the trait directly.
/// The `Ident` type must be one of the [`coded`](schema::coded) ident
/// types (e.g. [`PrimitiveIdent`](schema::coded::PrimitiveIdent),
/// [`Ident<N>`](schema::coded::Ident)).
///
/// ```ignore
/// use typewire::{Typewire, schema};
///
/// struct MyId(u64);
///
/// impl Typewire for MyId {
///   type Ident = schema::coded::PrimitiveIdent;
///   const IDENT: Self::Ident =
///     schema::coded::PrimitiveIdent::new(schema::Scalar::u64);
///
///   fn or_default() -> Option<Self> { None }
///
///   // On wasm32, also implement to_js/from_js/patch_js.
/// }
/// ```
pub trait Typewire: Sized {
  /// Compile-time type identity, embedded in link sections for schema extraction.
  ///
  /// For derived types this is [`coded::Ident<N>`](schema::coded::Ident) (the type
  /// name). For primitives it is [`coded::PrimitiveIdent`](schema::coded::PrimitiveIdent).
  /// For compound types it is a nested ident like
  /// [`coded::OptionIdent`](schema::coded::OptionIdent) or
  /// [`coded::SeqIdent`](schema::coded::SeqIdent).
  type Ident: Copy + 'static;

  /// The identity constant for this type.
  const IDENT: Self::Ident;

  /// Returns the implicit default for this type when a field is absent.
  ///
  /// Most types return `None` (no default — the field is required).
  /// [`Option<T>`] returns `Some(None)`, making optional fields implicitly
  /// default to `None` without requiring `#[serde(default)]`.
  ///
  /// ```
  /// use typewire::Typewire;
  ///
  /// // Option<T> implicitly defaults to None
  /// assert_eq!(<Option<i32>>::or_default(), Some(None));
  ///
  /// // Most types require an explicit value
  /// assert!(i32::or_default().is_none());
  /// assert!(String::or_default().is_none());
  /// assert!(<Vec<u8>>::or_default().is_none());
  /// ```
  #[must_use]
  fn or_default() -> Option<Self> {
    None
  }

  /// Converts this Rust value to a foreign-language value.
  ///
  /// On `wasm32`: converts to a [`JsValue`](wasm_bindgen::JsValue).
  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue;

  /// Converts a foreign-language value into this Rust type.
  ///
  /// On `wasm32`: converts from a [`JsValue`](wasm_bindgen::JsValue).
  ///
  /// # Errors
  ///
  /// Returns an [`Error`] if the value cannot be converted (e.g. wrong
  /// type, out-of-range, or missing required fields).
  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error>;

  /// Lenient variant of [`from_js`](Typewire::from_js) for
  /// `#[typewire(lenient)]` fields.
  ///
  /// The default delegates to [`from_js`](Typewire::from_js). Collection
  /// types ([`Vec`], [`Option`], maps) override this to skip invalid
  /// elements or default to `None` instead of propagating errors, logging
  /// a warning for each skipped value.
  ///
  /// # Errors
  ///
  /// Returns an [`Error`] if the value cannot be converted and the type
  /// does not support lenient fallback.
  #[cfg(target_arch = "wasm32")]
  fn from_js_lenient(value: wasm_bindgen::JsValue, _field: &str) -> Result<Self, Error> {
    Self::from_js(value)
  }

  /// Patches an existing foreign-language value in place.
  ///
  /// Compares `self` (the new value) against `old` (the existing value).
  /// If they differ, calls `set` with the new representation. Structs
  /// recurse into fields, preserving object identity. Collections use
  /// LCS-based diffing to emit minimal splice operations.
  ///
  /// Every type must either derive or manually implement this method.
  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue));
}

/// Atomic patching: round-trips `old` through [`from_js`](Typewire::from_js),
/// compares with [`PartialEq`], and calls `set(new.to_js())` only if changed.
///
/// Used by `#[diffable(atomic)]` types and by the derive for primitives,
/// tuple structs, unit structs, and all-unit enums. Unlike structural
/// patching (which recurses into fields), this replaces the entire value.
#[cfg(target_arch = "wasm32")]
pub fn patch_js_atomic<T: Typewire + PartialEq>(
  new: &T,
  old: &wasm_bindgen::JsValue,
  set: impl FnOnce(wasm_bindgen::JsValue),
) {
  match T::from_js(old.clone()) {
    Ok(ref old_val) if new == old_val => {}
    _ => set(new.to_js()),
  }
}

// ---------------------------------------------------------------------------
// Link section statics for built-in types
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// Primitive implementations (only compiled on wasm32)
// ---------------------------------------------------------------------------

#[cfg(target_arch = "wasm32")]
mod wasm {
  use wasm_bindgen::JsValue;

  /// Returns `true` if the value is `null` or `undefined`.
  pub fn is_nullish(v: &JsValue) -> bool {
    v.is_null() || v.is_undefined()
  }

  /// Extract an `f64` from a JS number value.
  pub fn as_safe_f64(v: &JsValue) -> Option<f64> {
    v.as_f64()
  }

  /// Lossless `usize` → `u32` on wasm32 (where `usize` is 32-bit).
  #[expect(clippy::cast_possible_truncation, reason = "wasm32: usize == u32")]
  pub const fn as_u32(n: usize) -> u32 {
    n as u32
  }

  /// `isize` → `u32` on wasm32 (for non-negative index arithmetic).
  #[expect(
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss,
    reason = "wasm32: isize is i32, values are non-negative indices"
  )]
  pub const fn isize_as_u32(n: isize) -> u32 {
    n as u32
  }
}

#[cfg(target_arch = "wasm32")]
impl Typewire for wasm_bindgen::JsValue {
  type Ident = schema::coded::Ident<3>;
  const IDENT: Self::Ident = schema::coded::Ident::new(*b"any");

  fn to_js(&self) -> wasm_bindgen::JsValue {
    self.clone()
  }

  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    Ok(value)
  }

  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(Self)) {
    if old != self {
      set(self.clone());
    }
  }
}

impl Typewire for bool {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::bool);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::from_bool(*self)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    value.as_bool().ok_or(Error::UnexpectedType { expected: "boolean" })
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

macro_rules! impl_typewire_small_int {
  ($($ty:ident),*) => {$(
    impl Typewire for $ty {
      type Ident = schema::coded::PrimitiveIdent;
      const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(
        schema::Scalar::$ty,
      );

      #[cfg(target_arch = "wasm32")]
      fn to_js(&self) -> wasm_bindgen::JsValue {
        wasm_bindgen::JsValue::from_f64(f64::from(*self))
      }

      #[cfg(target_arch = "wasm32")]
      fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
        let n = wasm::as_safe_f64(&value)
          .ok_or(Error::UnexpectedType { expected: "number" })?;
        #[expect(
          clippy::cast_possible_truncation,
          reason = "checked by round-trip comparison below"
        )]
        let v = n as $ty;
        if f64::from(v).to_bits() == n.to_bits() {
          Ok(v)
        } else {
          Err(Error::OutOfRange)
        }
      }

      #[cfg(target_arch = "wasm32")]
      fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
        patch_js_atomic(self, old, set);
      }
    }
  )*};
}

impl_typewire_small_int!(i8, i16, i32);

macro_rules! impl_typewire_small_uint {
  ($($ty:ident),*) => {$(
    impl Typewire for $ty {
      type Ident = schema::coded::PrimitiveIdent;
      const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(
        schema::Scalar::$ty,
      );

      #[cfg(target_arch = "wasm32")]
      fn to_js(&self) -> wasm_bindgen::JsValue {
        wasm_bindgen::JsValue::from_f64(f64::from(*self))
      }

      #[cfg(target_arch = "wasm32")]
      fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
        let n = wasm::as_safe_f64(&value)
          .ok_or(Error::UnexpectedType { expected: "number" })?;
        #[expect(
          clippy::cast_possible_truncation,
          clippy::cast_sign_loss,
          reason = "checked by round-trip comparison below"
        )]
        let v = n as $ty;
        if f64::from(v).to_bits() == n.to_bits() {
          Ok(v)
        } else {
          Err(Error::OutOfRange)
        }
      }

      #[cfg(target_arch = "wasm32")]
      fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
        patch_js_atomic(self, old, set);
      }
    }
  )*};
}

impl_typewire_small_uint!(u8, u16, u32);

impl Typewire for f32 {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::f32);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::from_f64(f64::from(*self))
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    let n = wasm::as_safe_f64(&value).ok_or(Error::UnexpectedType { expected: "number" })?;
    #[expect(clippy::cast_possible_truncation, reason = "f64 → f32 narrowing is intentional")]
    Ok(n as Self)
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

impl Typewire for f64 {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::f64);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::from_f64(*self)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    wasm::as_safe_f64(&value).ok_or(Error::UnexpectedType { expected: "number" })
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

macro_rules! impl_typewire_lossy {
  (unsigned: $($uty:ident),*; signed: $($sty:ident),*) => {
    $(impl_typewire_lossy!(@impl $uty, cast_possible_truncation, cast_sign_loss);)*
    $(impl_typewire_lossy!(@impl $sty, cast_possible_truncation);)*
  };
  (@impl $ty:ident, $($lint:ident),+) => {
    impl Typewire for $ty {
      type Ident = schema::coded::PrimitiveIdent;
      const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(
        schema::Scalar::$ty,
      );

      #[cfg(target_arch = "wasm32")]
      fn to_js(&self) -> wasm_bindgen::JsValue {
        #[expect(
          clippy::cast_precision_loss,
          reason = "JS numbers are f64 — precision loss is inherent"
        )]
        let number = *self as f64;
        #[expect(
          $(clippy::$lint,)+
          reason = "round-trip check detects precision loss"
        )]
        let roundtrip = number as $ty;
        if roundtrip != *self {
          log::warn!("lossy conversion of {self} to JS number: {number}");
        }

        wasm_bindgen::JsValue::from(number)
      }

      #[cfg(target_arch = "wasm32")]
      fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
        use wasm_bindgen::JsCast as _;

        if let Some(number) = wasm::as_safe_f64(&value) {
          #[expect(
            $(clippy::$lint,)+
            reason = "lossy conversion is intentional — saturates for out-of-range values"
          )]
          return Ok(number as $ty);
        }

        let bigint = value
          .dyn_into::<js_sys::BigInt>()
          .map_err(|_| Error::UnexpectedType { expected: "bigint" })?;
        <$ty>::try_from(bigint).map_err(|_| Error::OutOfRange)
      }

      #[cfg(target_arch = "wasm32")]
      fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
        patch_js_atomic(self, old, set);
      }
    }
  };
}

impl_typewire_lossy!(unsigned: u64, u128; signed: i64, i128);

impl Typewire for usize {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::usize);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    // On wasm32, usize is u32 — fits in f64 without precision loss.
    #[expect(
      clippy::cast_precision_loss,
      reason = "on wasm32 usize is u32, which fits exactly in f64"
    )]
    let n = *self as f64;
    wasm_bindgen::JsValue::from_f64(n)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    let n = wasm::as_safe_f64(&value).ok_or(Error::UnexpectedType { expected: "number" })?;
    #[expect(
      clippy::cast_possible_truncation,
      clippy::cast_sign_loss,
      reason = "on wasm32, usize is u32 — fits exactly in f64"
    )]
    Ok(n as Self)
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

impl Typewire for isize {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::isize);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    // On wasm32, isize is i32 — fits in f64 without precision loss.
    #[expect(
      clippy::cast_precision_loss,
      reason = "on wasm32 isize is i32, which fits exactly in f64"
    )]
    let n = *self as f64;
    wasm_bindgen::JsValue::from_f64(n)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    let n = wasm::as_safe_f64(&value).ok_or(Error::UnexpectedType { expected: "number" })?;
    #[expect(
      clippy::cast_possible_truncation,
      reason = "on wasm32, isize is i32 — fits exactly in f64"
    )]
    Ok(n as Self)
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

impl Typewire for char {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::char);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::from_str(&self.to_string())
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    let s = value.as_string().ok_or(Error::UnexpectedType { expected: "string" })?;
    let mut chars = s.chars();
    let Some(c) = chars.next() else {
      return Err(Error::InvalidValue { message: "empty string".into() });
    };
    if chars.next().is_some() {
      return Err(Error::InvalidValue { message: "expected single character".into() });
    }
    Ok(c)
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

impl Typewire for String {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::str);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::from_str(self)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    value.as_string().ok_or(Error::UnexpectedType { expected: "string" })
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

impl Typewire for std::borrow::Cow<'_, str> {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::str);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::from_str(self)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    value
      .as_string()
      .map(std::borrow::Cow::Owned)
      .ok_or(Error::UnexpectedType { expected: "string" })
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

impl Typewire for () {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::Unit);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::NULL
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(_value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    Ok(())
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, _old: &wasm_bindgen::JsValue, _set: impl FnOnce(wasm_bindgen::JsValue)) {
    // Unit type is a singleton — nothing to diff.
  }
}

// ---------------------------------------------------------------------------
// Compound types
// ---------------------------------------------------------------------------

impl<T: Typewire> Typewire for Option<T> {
  type Ident = schema::coded::OptionIdent<T::Ident>;
  const IDENT: Self::Ident = schema::coded::OptionIdent::new(T::IDENT);

  fn or_default() -> Option<Self> {
    Some(None)
  }

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    self.as_ref().map_or(wasm_bindgen::JsValue::NULL, Typewire::to_js)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    if wasm::is_nullish(&value) { Ok(None) } else { T::from_js(value).map(Some) }
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js_lenient(value: wasm_bindgen::JsValue, field: &str) -> Result<Self, Error> {
    if wasm::is_nullish(&value) {
      Ok(None)
    } else {
      match T::from_js(value) {
        Ok(v) => Ok(Some(v)),
        Err(e) => {
          log::warn!("{field}: defaulting to None: {e}");
          Ok(None)
        }
      }
    }
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    match self {
      None => {
        if !wasm::is_nullish(old) {
          set(wasm_bindgen::JsValue::NULL);
        }
      }
      Some(v) => {
        if wasm::is_nullish(old) {
          set(v.to_js());
        } else {
          v.patch_js(old, set);
        }
      }
    }
  }
}

/// Converts an iterator of `&T` references to a JS array via
/// [`Typewire::to_js`].
///
/// Convenience wrapper around [`array`] for borrowed iterators.
#[cfg(target_arch = "wasm32")]
pub fn array_ref<'a, T: Typewire + 'a>(
  iter: impl IntoIterator<Item = &'a T>,
) -> wasm_bindgen::JsValue {
  array(iter.into_iter().map(Typewire::to_js))
}

/// Converts an iterator of owned `JsValue`s into a JS array.
///
/// Pre-allocates if the iterator reports an exact size.
#[cfg(target_arch = "wasm32")]
pub fn array<T: Typewire>(iter: impl IntoIterator<Item = T>) -> wasm_bindgen::JsValue {
  let iter = iter.into_iter();
  let (low, high) = iter.size_hint();
  let arr;
  if Some(low) == high {
    arr = js_sys::Array::new_with_length(wasm::as_u32(low));
    for (i, item) in iter.enumerate() {
      arr.set(wasm::as_u32(i), item.to_js());
    }
  } else {
    arr = js_sys::Array::new();
    for item in iter {
      arr.push(&item.to_js());
    }
  }
  arr.into()
}

impl<T: Typewire> Typewire for Vec<T> {
  type Ident = schema::coded::SeqIdent<T::Ident>;
  const IDENT: Self::Ident = schema::coded::SeqIdent::new(T::IDENT);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    array_ref(self.iter())
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;

    let arr: js_sys::Array =
      value.dyn_into().map_err(|_| Error::UnexpectedType { expected: "array" })?;
    let mut out = Self::with_capacity(arr.length() as usize);
    for i in 0..arr.length() {
      out.push(T::from_js(arr.get(i))?);
    }
    Ok(out)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js_lenient(value: wasm_bindgen::JsValue, field: &str) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;

    let Some(arr) = value.dyn_ref::<js_sys::Array>() else {
      log::warn!("{field}: expected array, skipping (got {:?})", value.js_typeof());
      return Ok(Self::new());
    };
    let mut out = Self::with_capacity(arr.length() as usize);
    for i in 0..arr.length() {
      match T::from_js(arr.get(i)) {
        Ok(v) => out.push(v),
        Err(e) => log::warn!("{field}[{i}]: skipping invalid element: {e}"),
      }
    }
    Ok(out)
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_slice(self.iter(), old, set);
  }
}

/// LCS-based slice patching with `T::patch_js` delegation.
///
/// Builds a patched `JsValue` array by calling `T::patch_js` on each element
/// positionally. Unchanged elements keep the same JS reference as the old array.
/// Then uses `similar`'s LCS algorithm on the `JsValue` references (`===`) to
/// compute minimal splice operations.
///
/// Does NOT require `T: PartialEq` — comparison uses JS reference identity.
#[cfg(target_arch = "wasm32")]
#[expect(clippy::missing_panics_doc, reason = "built-in diff hooks never fail")]
pub fn patch_js_slice<'a, T: Typewire + 'a>(
  new: impl ExactSizeIterator<Item = &'a T> + Clone,
  old: &wasm_bindgen::JsValue,
  set: impl FnOnce(wasm_bindgen::JsValue),
) {
  use similar::algorithms::{Capture, Compact, Replace as SimilarReplace};
  use wasm_bindgen::JsCast as _;

  let Some(arr) = old.dyn_ref::<js_sys::Array>() else {
    set(array_ref(new));
    return;
  };

  let old_len = arr.length() as usize;
  let new_len = new.len();

  // Fast path: same length
  if old_len == new_len {
    for (i, elem) in new.enumerate() {
      let idx = wasm::as_u32(i);
      elem.patch_js(&arr.get(idx), |val| arr.set(idx, val));
    }
    return;
  }

  // Collect old JS references
  let old_refs: Vec<wasm_bindgen::JsValue> =
    (0..old_len).map(|i| arr.get(wasm::as_u32(i))).collect();

  // Build patched refs: for each new element, try patch_js against the
  // positionally corresponding old element. If unchanged, the old ref is kept.
  // If changed or new, we get a fresh JsValue.
  let mut patched_refs: Vec<wasm_bindgen::JsValue> = Vec::with_capacity(new_len);
  for (i, elem) in new.enumerate() {
    if i < old_len {
      let mut result = old_refs[i].clone();
      elem.patch_js(&old_refs[i], |v| result = v);
      patched_refs.push(result);
    } else {
      patched_refs.push(elem.to_js());
    }
  }

  // LCS diff on JsValue references — === compares by reference identity,
  // so unchanged elements (same ref) are matched as Equal.
  let mut d = Compact::new(SimilarReplace::new(Capture::new()), &old_refs, &patched_refs);
  similar::algorithms::lcs::diff(&mut d, &old_refs, 0..old_len, &patched_refs, 0..new_len)
    .expect("built-in diff hooks do not fail");

  let ops = d.into_inner().into_inner().into_ops();

  let mut offset: isize = 0;

  #[expect(clippy::cast_possible_wrap, reason = "wasm32 array indices fit in isize")]
  for op in ops {
    match op {
      similar::DiffOp::Equal { old_index, new_index, len } => {
        // Elements matched by reference — patch in place (already done
        // during patched_refs construction, but we need to update the
        // actual array if the position shifted due to prior splices)
        for ix in 0..len {
          let target_idx = wasm::as_u32(new_index + ix);
          let actual_idx = wasm::isize_as_u32((old_index + ix) as isize + offset);
          if actual_idx == target_idx {
            // Same position — the value is already patched_refs[i]
            // which may have been updated by patch_js
            arr.set(actual_idx, patched_refs[new_index + ix].clone());
          } else {
            // Position shifted — move element
            arr.set(target_idx, patched_refs[new_index + ix].clone());
          }
        }
      }
      similar::DiffOp::Delete { old_len, old_index, .. } => {
        let at = wasm::isize_as_u32(old_index as isize + offset);
        arr.splice_many(at, wasm::as_u32(old_len), &[]);
        offset -= old_len as isize;
      }
      similar::DiffOp::Insert { new_index, new_len, .. } => {
        arr.splice_many(wasm::as_u32(new_index), 0, &patched_refs[new_index..new_index + new_len]);
        offset += new_len as isize;
      }
      similar::DiffOp::Replace { old_index, old_len, new_index, new_len, .. } => {
        let at = wasm::isize_as_u32(old_index as isize + offset);
        arr.splice_many(at, wasm::as_u32(old_len), &patched_refs[new_index..new_index + new_len]);
        offset -= old_len as isize;
        offset += new_len as isize;
      }
    }
  }
}

macro_rules! impl_typewire_deref {
  ($($wrapper:ty),+) => {$(
    impl<T: Typewire> Typewire for $wrapper {
      type Ident = T::Ident;
      const IDENT: Self::Ident = T::IDENT;

      #[cfg(target_arch = "wasm32")]
      fn to_js(&self) -> wasm_bindgen::JsValue {
        (**self).to_js()
      }

      #[cfg(target_arch = "wasm32")]
      fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
        T::from_js(value).map(Self::from)
      }

      #[cfg(target_arch = "wasm32")]
      fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
        (**self).patch_js(old, set);
      }
    }
  )+};
}

impl_typewire_deref!(Box<T>, std::sync::Arc<T>, std::rc::Rc<T>);

impl<T: Typewire, const N: usize> Typewire for [T; N] {
  type Ident = schema::coded::SeqIdent<T::Ident>;
  const IDENT: Self::Ident = schema::coded::SeqIdent::new(T::IDENT);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    let arr = js_sys::Array::new_with_length(wasm::as_u32(N));
    for (i, item) in self.iter().enumerate() {
      arr.set(wasm::as_u32(i), item.to_js());
    }
    arr.into()
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;

    let arr: js_sys::Array =
      value.dyn_into().map_err(|_| Error::UnexpectedType { expected: "array" })?;
    if arr.length() as usize != N {
      return Err(Error::InvalidValue {
        message: format!("expected array of length {N}, got {}", arr.length()),
      });
    }
    // SAFETY: `MaybeUninit<T>` does not require initialisation, so an array
    // of `MaybeUninit` values is valid even when uninitialised.
    let mut out: [std::mem::MaybeUninit<T>; N] =
      unsafe { std::mem::MaybeUninit::uninit().assume_init() };
    for (i, slot) in out.iter_mut().enumerate() {
      match T::from_js(arr.get(wasm::as_u32(i))) {
        Ok(v) => {
          slot.write(v);
        }
        Err(e) => {
          // Drop already-initialized elements before returning.
          for already in &mut out[..i] {
            // SAFETY: elements at indices `0..i` have been initialised by
            // previous loop iterations.
            unsafe { already.assume_init_drop() };
          }
          return Err(e);
        }
      }
    }
    // SAFETY: all elements have been initialized.
    Ok(unsafe { std::mem::transmute_copy::<_, [T; N]>(&out) })
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    use wasm_bindgen::JsCast as _;
    let Some(arr) = old.dyn_ref::<js_sys::Array>() else {
      set(self.to_js());
      return;
    };
    for (i, elem) in self.iter().enumerate() {
      let idx = wasm::as_u32(i);
      elem.patch_js(&arr.get(idx), |v| arr.set(idx, v));
    }
  }
}

// --- Maps → JS objects ---

/// Patches a JS object in place by iterating new key-value entries, recursing
/// into each value's `patch_js`, and deleting keys that are no longer present.
///
/// Used by `HashMap`, `BTreeMap`, and `serde_json::Value::Object`.
#[cfg(target_arch = "wasm32")]
pub fn patch_js_map<'a, V: Typewire + 'a>(
  entries: impl IntoIterator<Item = (wasm_bindgen::JsValue, &'a V)>,
  contains_key: impl Fn(&wasm_bindgen::JsValue) -> bool,
  to_js: impl FnOnce() -> wasm_bindgen::JsValue,
  old: &wasm_bindgen::JsValue,
  set: impl FnOnce(wasm_bindgen::JsValue),
) {
  use wasm_bindgen::JsCast as _;

  let Some(old_obj) = old.dyn_ref::<js_sys::Object>() else {
    set(to_js());
    return;
  };
  // Arrays are objects in JS — don't patch an array as a keyed object
  if js_sys::Array::is_array(old) {
    set(to_js());
    return;
  }

  // Snapshot old keys before patching — avoids iterating newly-added keys
  // during the delete pass below.
  let old_keys = js_sys::Object::keys(old_obj);

  // Patch existing and new keys
  for (k_js, v) in entries {
    let old_v = js_sys::Reflect::get(old, &k_js).unwrap_or(wasm_bindgen::JsValue::UNDEFINED);
    v.patch_js(&old_v, |new_v| {
      let _ = js_sys::Reflect::set(old, &k_js, &new_v);
    });
  }

  // Delete keys present in old but not in new
  for i in 0..old_keys.length() {
    let key = old_keys.get(i);
    if !contains_key(&key) {
      let _ = js_sys::Reflect::delete_property(old_obj, &key);
    }
  }
}

impl<K: Typewire + Eq + core::hash::Hash, V: Typewire, S: ::std::hash::BuildHasher + Default>
  Typewire for std::collections::HashMap<K, V, S>
{
  type Ident = schema::coded::MapIdent<K::Ident, V::Ident>;
  const IDENT: Self::Ident = schema::coded::MapIdent::new(K::IDENT, V::IDENT);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    let obj = js_sys::Object::new();
    for (k, v) in self {
      // Reflect::set on a plain Object is infallible — safe to discard the result.
      // This applies to all `let _ = Reflect::set(...)` calls throughout this crate.
      let _ = js_sys::Reflect::set(&obj, &k.to_js(), &v.to_js());
    }
    obj.into()
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;
    let entries = js_sys::Object::entries(
      value.dyn_ref::<js_sys::Object>().ok_or(Error::UnexpectedType { expected: "object" })?,
    );
    let mut map = Self::default();
    map.reserve(entries.length() as usize);
    for i in 0..entries.length() {
      let pair: js_sys::Array =
        entries.get(i).dyn_into().map_err(|_| Error::UnexpectedType { expected: "array" })?;
      let key = K::from_js(pair.get(0))?;
      let val = V::from_js(pair.get(1))?;
      map.insert(key, val);
    }
    Ok(map)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js_lenient(value: wasm_bindgen::JsValue, field: &str) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;
    let Some(obj) = value.dyn_ref::<js_sys::Object>() else {
      log::warn!("{field}: expected object, skipping");
      return Ok(Self::default());
    };
    let entries = js_sys::Object::entries(obj);
    let mut map = Self::default();
    map.reserve(entries.length() as usize);
    for i in 0..entries.length() {
      let pair: js_sys::Array = entries.get(i).into();
      match (K::from_js(pair.get(0)), V::from_js(pair.get(1))) {
        (Ok(k), Ok(v)) => {
          map.insert(k, v);
        }
        (Err(e), _) | (_, Err(e)) => {
          log::warn!("{field}: skipping entry {i}: {e}");
        }
      }
    }
    Ok(map)
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_map(
      self.iter().map(|(k, v)| (k.to_js(), v)),
      |js_key| K::from_js(js_key.clone()).ok().is_some_and(|k| self.contains_key(&k)),
      || self.to_js(),
      old,
      set,
    );
  }
}

impl<K: Typewire + Ord, V: Typewire> Typewire for std::collections::BTreeMap<K, V> {
  type Ident = schema::coded::MapIdent<K::Ident, V::Ident>;
  const IDENT: Self::Ident = schema::coded::MapIdent::new(K::IDENT, V::IDENT);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    let obj = js_sys::Object::new();
    for (k, v) in self {
      let _ = js_sys::Reflect::set(&obj, &k.to_js(), &v.to_js());
    }
    obj.into()
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;
    let entries = js_sys::Object::entries(
      value.dyn_ref::<js_sys::Object>().ok_or(Error::UnexpectedType { expected: "object" })?,
    );
    let mut map = Self::new();
    for i in 0..entries.length() {
      let pair: js_sys::Array =
        entries.get(i).dyn_into().map_err(|_| Error::UnexpectedType { expected: "array" })?;
      let key = K::from_js(pair.get(0))?;
      let val = V::from_js(pair.get(1))?;
      map.insert(key, val);
    }
    Ok(map)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js_lenient(value: wasm_bindgen::JsValue, field: &str) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;
    let Some(obj) = value.dyn_ref::<js_sys::Object>() else {
      log::warn!("{field}: expected object, skipping");
      return Ok(Self::default());
    };
    let entries = js_sys::Object::entries(obj);
    let mut map = Self::new();
    for i in 0..entries.length() {
      let pair: js_sys::Array = if let Ok(a) = entries.get(i).dyn_into() {
        a
      } else {
        log::warn!("{field}: skipping entry {i}: not an array");
        continue;
      };
      match (K::from_js(pair.get(0)), V::from_js(pair.get(1))) {
        (Ok(k), Ok(v)) => {
          map.insert(k, v);
        }
        (Err(e), _) | (_, Err(e)) => {
          log::warn!("{field}: skipping entry {i}: {e}");
        }
      }
    }
    Ok(map)
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_map(
      self.iter().map(|(k, v)| (k.to_js(), v)),
      |js_key| K::from_js(js_key.clone()).ok().is_some_and(|k| self.contains_key(&k)),
      || self.to_js(),
      old,
      set,
    );
  }
}

// --- Tuples ---

macro_rules! impl_typewire_tuple {
  ($n:literal, $types:ident; $($idx:tt : $T:ident),+) => {
    impl<$($T: Typewire),+> Typewire for ($($T,)+) {
      type Ident = schema::coded::TupleIdent<
        schema::coded::$types<$($T::Ident),+>>;
      const IDENT: Self::Ident = schema::coded::TupleIdent::new(
        $n, schema::coded::$types($($T::IDENT),+));

      #[cfg(target_arch = "wasm32")]
      fn to_js(&self) -> wasm_bindgen::JsValue {
        let arr = js_sys::Array::new();
        $(arr.push(&self.$idx.to_js());)+
        arr.into()
      }

      #[cfg(target_arch = "wasm32")]
      fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
        let arr: js_sys::Array = value
          .try_into()
          .map_err(|_| Error::UnexpectedType { expected: "array" })?;
        Ok(($($T::from_js(arr.get($idx))?,)+))
      }

      #[cfg(target_arch = "wasm32")]
      fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
        use wasm_bindgen::JsCast as _;
        let Some(arr) = old.dyn_ref::<js_sys::Array>() else {
          set(self.to_js());
          return;
        };
        $(self.$idx.patch_js(&arr.get($idx), |v| arr.set($idx, v));)+
      }
    }
  };
}

impl_typewire_tuple!(1, Types1; 0: A);
impl_typewire_tuple!(2, Types2; 0: A, 1: B);
impl_typewire_tuple!(3, Types3; 0: A, 1: B, 2: C);
impl_typewire_tuple!(4, Types4; 0: A, 1: B, 2: C, 3: D);
impl_typewire_tuple!(5, Types5; 0: A, 1: B, 2: C, 3: D, 4: E);
impl_typewire_tuple!(6, Types6; 0: A, 1: B, 2: C, 3: D, 4: E, 5: F);
impl_typewire_tuple!(7, Types7; 0: A, 1: B, 2: C, 3: D, 4: E, 5: F, 6: G);
impl_typewire_tuple!(8, Types8; 0: A, 1: B, 2: C, 3: D, 4: E, 5: F, 6: G, 7: H);
impl_typewire_tuple!(9, Types9; 0: A, 1: B, 2: C, 3: D, 4: E, 5: F, 6: G, 7: H, 8: I);
impl_typewire_tuple!(10, Types10; 0: A, 1: B, 2: C, 3: D, 4: E, 5: F, 6: G, 7: H, 8: I, 9: J);
impl_typewire_tuple!(11, Types11; 0: A, 1: B, 2: C, 3: D, 4: E, 5: F, 6: G, 7: H, 8: I, 9: J, 10: K);
impl_typewire_tuple!(12, Types12; 0: A, 1: B, 2: C, 3: D, 4: E, 5: F, 6: G, 7: H, 8: I, 9: J, 10: K, 11: L);

// ---------------------------------------------------------------------------
// Feature-gated implementations
// ---------------------------------------------------------------------------

#[cfg(feature = "uuid")]
impl Typewire for uuid::Uuid {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::Uuid);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::from_str(&self.to_string())
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    let s = value.as_string().ok_or(Error::UnexpectedType { expected: "string" })?;
    Self::try_parse(&s).map_err(|e| Error::InvalidValue { message: e.to_string() })
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

#[cfg(feature = "fractional_index")]
impl Typewire for fractional_index::FractionalIndex {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::FractionalIndex);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::from_str(&self.to_string())
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    let s = value.as_string().ok_or(Error::UnexpectedType { expected: "string" })?;
    Self::from_string(&s).map_err(|e| Error::InvalidValue { message: e.to_string() })
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

#[cfg(feature = "chrono")]
impl<Tz: chrono::TimeZone> Typewire for chrono::DateTime<Tz>
where
  Tz::Offset: core::fmt::Display,
  Self: From<chrono::DateTime<chrono::FixedOffset>>,
{
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::DateTime);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::from_str(&self.to_rfc3339())
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    let s = value.as_string().ok_or(Error::UnexpectedType { expected: "string" })?;
    chrono::DateTime::parse_from_rfc3339(&s)
      .map(Into::into)
      .map_err(|e| Error::InvalidValue { message: e.to_string() })
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

#[cfg(feature = "url")]
impl Typewire for url::Url {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::Url);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    wasm_bindgen::JsValue::from_str(self.as_str())
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    let s = value.as_string().ok_or(Error::UnexpectedType { expected: "string" })?;
    Self::parse(&s).map_err(|e| Error::InvalidValue { message: e.to_string() })
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

#[cfg(feature = "serde_json")]
impl Typewire for serde_json::Value {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::SerdeJsonValue);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    match self {
      Self::Null => wasm_bindgen::JsValue::NULL,
      Self::Bool(b) => wasm_bindgen::JsValue::from_bool(*b),
      // serde_json::Number always represents a finite JSON number, so as_f64()
      // only returns None for values outside f64 range (extremely rare). Fall
      // back to 0.0 and log rather than silently producing NaN.
      Self::Number(n) => {
        let v = n.as_f64().unwrap_or_else(|| {
          log::warn!("serde_json::Number {n} is not representable as f64, using 0.0");
          0.0
        });
        wasm_bindgen::JsValue::from_f64(v)
      }
      Self::String(s) => wasm_bindgen::JsValue::from_str(s),
      Self::Array(arr) => array_ref(arr.iter()),
      Self::Object(map) => {
        let obj = js_sys::Object::new();
        for (k, v) in map {
          let _ = js_sys::Reflect::set(&obj, &wasm_bindgen::JsValue::from_str(k), &v.to_js());
        }
        obj.into()
      }
    }
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;

    if value.is_null() || value.is_undefined() {
      Ok(Self::Null)
    } else if let Some(b) = value.as_bool() {
      Ok(Self::Bool(b))
    } else if let Some(n) = value.as_f64() {
      // JS only has f64 — recover integer representation for whole numbers
      // so that round-tripping preserves serde_json's i64/u64 distinction.
      if n.fract() == 0.0 {
        #[expect(
          clippy::cast_possible_truncation,
          reason = "intentional: detecting if f64 fits in i64"
        )]
        let i = n as i64;
        #[expect(
          clippy::float_cmp,
          clippy::cast_precision_loss,
          reason = "exact round-trip check: i64 → f64 → i64 preserves value"
        )]
        if i as f64 == n {
          return Ok(Self::Number(i.into()));
        }
        #[expect(
          clippy::cast_possible_truncation,
          clippy::cast_sign_loss,
          reason = "intentional: detecting if f64 fits in u64"
        )]
        let u = n as u64;
        #[expect(
          clippy::float_cmp,
          clippy::cast_precision_loss,
          reason = "exact round-trip check: u64 → f64 → u64 preserves value"
        )]
        if u as f64 == n {
          return Ok(Self::Number(u.into()));
        }
      }
      serde_json::Number::from_f64(n).map(serde_json::Value::Number).ok_or_else(|| {
        Error::InvalidValue { message: "invalid JSON number (NaN or Infinity)".into() }
      })
    } else if let Some(s) = value.as_string() {
      Ok(Self::String(s))
    } else if js_sys::Array::is_array(&value) {
      let arr = js_sys::Array::from(&value);
      let mut vec = Vec::with_capacity(arr.length() as usize);
      for i in 0..arr.length() {
        vec.push(Self::from_js(arr.get(i))?);
      }
      Ok(Self::Array(vec))
    } else if let Some(obj) = value.dyn_ref::<js_sys::Object>() {
      let entries = js_sys::Object::entries(obj);
      let mut map = serde_json::Map::with_capacity(entries.length() as usize);
      for i in 0..entries.length() {
        let pair = js_sys::Array::from(&entries.get(i));
        let key = pair.get(0).as_string().ok_or(Error::UnexpectedType { expected: "string" })?;
        let val = Self::from_js(pair.get(1))?;
        map.insert(key, val);
      }
      Ok(Self::Object(map))
    } else {
      Err(Error::UnexpectedType { expected: "JSON value" })
    }
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    // Type-erase `set` to break monomorphization recursion. serde_json::Value
    // is recursive (Array/Object contain Value), and each `impl FnOnce` closure
    // is a unique type. Without erasure the compiler generates an infinite chain
    // of distinct instantiations.
    let mut set = Some(set);
    patch_js_json_value(self, old, &mut |v| {
      (set.take().expect("patch_js set callback invoked more than once"))(v);
    });
  }
}

/// Inner helper for `serde_json::Value::patch_js`. Takes a `&mut dyn FnMut`
/// callback so all recursive calls through `patch_js_slice`/`patch_js_map`
/// share the same concrete monomorphization without a heap allocation.
#[cfg(all(feature = "serde_json", target_arch = "wasm32"))]
fn patch_js_json_value(
  value: &serde_json::Value,
  old: &wasm_bindgen::JsValue,
  set: &mut dyn FnMut(wasm_bindgen::JsValue),
) {
  match value {
    serde_json::Value::Null => {
      if !old.is_null() && !old.is_undefined() {
        set(wasm_bindgen::JsValue::NULL);
      }
    }
    serde_json::Value::Bool(b) => {
      if old.as_bool() != Some(*b) {
        set(wasm_bindgen::JsValue::from_bool(*b));
      }
    }
    serde_json::Value::Number(n) => {
      let f = n.as_f64().unwrap_or(f64::NAN);
      if old.as_f64() != Some(f) {
        set(wasm_bindgen::JsValue::from_f64(f));
      }
    }
    serde_json::Value::String(s) => {
      if old.as_string().as_deref() != Some(s.as_str()) {
        set(wasm_bindgen::JsValue::from_str(s));
      }
    }
    serde_json::Value::Array(arr) => {
      patch_js_slice(arr.iter(), old, set);
    }
    serde_json::Value::Object(map) => {
      patch_js_map(
        map.iter().map(|(k, v)| (wasm_bindgen::JsValue::from_str(k), v)),
        |js_key| js_key.as_string().is_some_and(|k| map.contains_key(&k)),
        || value.to_js(),
        old,
        set,
      );
    }
  }
}

#[cfg(feature = "bytes")]
impl Typewire for bytes::Bytes {
  type Ident = schema::coded::PrimitiveIdent;
  const IDENT: Self::Ident = schema::coded::PrimitiveIdent::new(schema::Scalar::Bytes);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    js_sys::Uint8ClampedArray::new_from_slice(self).into()
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;
    value.dyn_ref::<js_sys::Uint8ClampedArray>().map_or_else(
      || {
        value.dyn_ref::<js_sys::Uint8Array>().map_or(
          Err(Error::UnexpectedType { expected: "Uint8ClampedArray or Uint8Array" }),
          |arr| Ok(Self::from(arr.to_vec())),
        )
      },
      |arr| Ok(Self::from(arr.to_vec())),
    )
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_atomic(self, old, set);
  }
}

#[cfg(feature = "indexmap")]
impl<T: Typewire + Eq + core::hash::Hash> Typewire for indexmap::IndexSet<T> {
  type Ident = schema::coded::SeqIdent<T::Ident>;
  const IDENT: Self::Ident = schema::coded::SeqIdent::new(T::IDENT);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    array_ref(self.iter())
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;

    let arr: js_sys::Array =
      value.dyn_into().map_err(|_| Error::UnexpectedType { expected: "array" })?;
    let mut set = Self::with_capacity(arr.length() as usize);
    for i in 0..arr.length() {
      set.insert(T::from_js(arr.get(i))?);
    }
    Ok(set)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js_lenient(value: wasm_bindgen::JsValue, field: &str) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;
    let Some(arr) = value.dyn_ref::<js_sys::Array>() else {
      log::warn!("{field}: expected array, skipping");
      return Ok(Self::default());
    };
    let mut set = Self::with_capacity(arr.length() as usize);
    for i in 0..arr.length() {
      match T::from_js(arr.get(i)) {
        Ok(v) => {
          set.insert(v);
        }
        Err(e) => log::warn!("{field}[{i}]: skipping invalid element: {e}"),
      }
    }
    Ok(set)
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_slice(self.as_slice().iter(), old, set);
  }
}

#[cfg(feature = "indexmap")]
impl<K: Typewire + Eq + core::hash::Hash, V: Typewire> Typewire for indexmap::IndexMap<K, V> {
  type Ident = schema::coded::MapIdent<K::Ident, V::Ident>;
  const IDENT: Self::Ident = schema::coded::MapIdent::new(K::IDENT, V::IDENT);

  #[cfg(target_arch = "wasm32")]
  fn to_js(&self) -> wasm_bindgen::JsValue {
    let obj = js_sys::Object::new();
    for (k, v) in self {
      let _ = js_sys::Reflect::set(&obj, &k.to_js(), &v.to_js());
    }
    obj.into()
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js(value: wasm_bindgen::JsValue) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;
    let entries = js_sys::Object::entries(
      value.dyn_ref::<js_sys::Object>().ok_or(Error::UnexpectedType { expected: "object" })?,
    );
    let mut map = Self::with_capacity(entries.length() as usize);
    for i in 0..entries.length() {
      let pair: js_sys::Array =
        entries.get(i).dyn_into().map_err(|_| Error::UnexpectedType { expected: "array" })?;
      let key = K::from_js(pair.get(0))?;
      let val = V::from_js(pair.get(1))?;
      map.insert(key, val);
    }
    Ok(map)
  }

  #[cfg(target_arch = "wasm32")]
  fn from_js_lenient(value: wasm_bindgen::JsValue, field: &str) -> Result<Self, Error> {
    use wasm_bindgen::JsCast as _;
    let Some(obj) = value.dyn_ref::<js_sys::Object>() else {
      log::warn!("{field}: expected object, skipping");
      return Ok(Self::default());
    };
    let entries = js_sys::Object::entries(obj);
    let mut map = Self::with_capacity(entries.length() as usize);
    for i in 0..entries.length() {
      let pair: js_sys::Array = entries.get(i).into();
      match (K::from_js(pair.get(0)), V::from_js(pair.get(1))) {
        (Ok(k), Ok(v)) => {
          map.insert(k, v);
        }
        (Err(e), _) | (_, Err(e)) => {
          log::warn!("{field}: skipping entry {i}: {e}");
        }
      }
    }
    Ok(map)
  }

  #[cfg(target_arch = "wasm32")]
  fn patch_js(&self, old: &wasm_bindgen::JsValue, set: impl FnOnce(wasm_bindgen::JsValue)) {
    patch_js_map(
      self.iter().map(|(k, v)| (k.to_js(), v)),
      |js_key| K::from_js(js_key.clone()).ok().is_some_and(|k| self.contains_key(&k)),
      || self.to_js(),
      old,
      set,
    );
  }
}