> ## Documentation Index
> Fetch the complete documentation index at: https://whatsapp-rust.jlucaso.com/llms.txt
> Use this file to discover all available pages before exploring further.

# June 10, 2026 — impl Into<Jid> API convention

> All mutating public methods now accept impl Into<Jid>. Pass &jid directly without cloning; existing owned-Jid call sites continue to compile unchanged.

## Change

**`From<&Jid> for Jid` is now implemented in `wacore-binary`.** All mutating public methods that previously took either `Jid` (by value) or `&Jid` (by reference) now take `impl Into<Jid>` uniformly.

This covers the full public surface: `send_message`, `forward_message`, `send_message_with_options`, `edit_message`, `edit_message_encrypted`, `revoke_message`, `keep_message`, `pin_message`, `unpin_message`, `send_reaction`, and all 53 feature methods across `Groups` (26), `Community` (6), `Newsletter` (2), `Presence` (1), `Polls`, `Events`, `Comments`, and `Reactions`.

### Before

```rust theme={null}
// Required .clone() to re-use the JID
let result = client.send_message(jid.clone(), msg).await?;
client.revoke_message(jid, &result.message_id, RevokeType::Sender).await?;

// Features took &Jid, core methods took Jid — two conventions on one surface
client.groups().leave(&group_jid).await?;
client.send_message(group_jid, msg).await?; // group_jid now moved
```

### After

```rust theme={null}
// Pass &jid whenever you want to keep it; owned Jid still moves for free
let result = client.send_message(&jid, msg).await?;
client.revoke_message(&jid, &result.message_id, RevokeType::Sender).await?;

// One convention everywhere
client.groups().leave(&group_jid).await?;
client.send_message(&group_jid, msg).await?;
```

### How it works

`From<&Jid> for Jid` clones the JID. For borrow-callers this is one allocation; for typical phone-number JIDs the `user` part is stored inline (up to 24 bytes via `CompactString`), making the clone heap-free.

Owned callers continue to move the value at zero cost. Both forms are pinned by the new `jid_into_convention` compile-time guard in the test suite.

**Monomorphization discipline:** Large async state machines (`send_message_with_options`, `edit_message`, `edit_message_encrypted`, `revoke_message`) keep a monomorphic `_inner` behind a thin generic shim that only does `.into()`, so each `Into<Jid>` instantiation cannot duplicate the full state machine.

## Breaking changes

Pre-1.0 signature change. All converted methods now declare `impl Into<Jid>` in their public signature.

* **Owned callers** (`jid` by value) — compile unchanged.
* **Borrow callers** (`&jid`) — compile unchanged via `From<&Jid>`.
* **Trait-object / fn-pointer uses** of these inherent methods (e.g. `let f: fn(&Client, Jid, ...) = Client::send_message`) — need a wrapping closure, since `impl Trait` parameters are not compatible with concrete fn-pointer types. This is an uncommon pattern for inherent async methods.

## Deliberate exceptions

Read-only methods keep `&Jid`. Converting them would force a clone on every borrow-caller for no benefit. \~59 query methods (`query_info`, `get_metadata`, etc.) are unchanged.

`&[Jid]` slices and `Option<&Jid>` parameters are also out of scope.