diff --git a/ROADMAP.md b/ROADMAP.md index 7796e65..3796440 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -17,13 +17,14 @@ Pour reprendre le travail : lire ce fichier, prendre le premier lot ⬜ dont les 1. ~~**3.8** livraison au moins une fois~~ ✅ 2. ~~**4.5** brancher `meow-store` dans le client et la CLI~~ ✅ 3. ~~5.5, 5.6, 5.9, 5.10~~ ✅ -4. ~~7.1 → 7.4~~ ✅, puis **7.5 → 7.8** (invitations, espaces cachés, Android en arrière-plan, retrait de la v1). +4. ~~7.1 → 7.5~~ ✅, puis **7.5b** (présentiel), **7.6 → 7.8** (espaces cachés, Android en arrière-plan, retrait de la v1). 5. Le reste (phases 8–10) selon les priorités. ### Journal | Date | Lots | Notes | |---|---|---| +| 2026-11-21 | 7.5 | Rust : `accept_invitation` (offre reçue par n'importe quel canal ; contact et réponse enregistrés **dans la même sauvegarde**, ce qui corrige une fenêtre où un plantage laissait un contact bloqué), `accept_published_invitation` s'appuie dessus ; FFI `acceptInvitation`. Flutter : feuille « Ajouter un contact », lien et mot de passe (12 caractères, environ 68 bits), QR code (`qr_flutter`) + copie et fichier `.bastet`, « Rejoindre » (`mobile_scanner` sur mobile, coller, fichier), option espace caché, fermeture auto quand le contact accepte. Format texte `bastet://invite/` (offre de 278 octets avec un serveur). Test d'intégration : lien (Bob), QR (Carol), rejoindre (Dave). **`peer_secure` audité** : voir annexe B ; présentiel reporté au 7.5b. | | 2026-11-21 | 7.4 | Identifiant d'application `im.bastet.bastet` (Android et Linux). Rust : `conversation_summary` (dernier message et non-lus, comptés à rebours par segments) et `Meow::conversations()` triées par activité. Flutter : flux d'événements unique par session, `conversationsProvider` (rafraîchi par les événements, avec anti-rebond) et `chatProvider` (famille par contact : segments, fusion du dernier segment, accusés appliqués sur place). Écrans de liste et de conversation, fiche contact, `file_picker` 13. Test d'intégration : Bob (identité FFI) accepte une invitation, écrit ; l'application affiche, répond depuis le champ de saisie ; Bob reçoit la réponse et l'accusé de lecture. Corrigés en route : le raccourci Entrée lisait un état périmé ; les SnackBars couvraient le champ de saisie sur bureau (largeur limitée sur grand écran). Formateur Dart à 120 colonnes. | | 2026-11-21 | 7.3 | Nouvelle application `../bastet` : Riverpod 3, session, thème sable conçu pour Material 3 (palette dérivée de Papyrus, contrastes vérifiés par test), écrans d'accueil, de déverrouillage, des conversations, des réglages et des serveurs, adaptatifs (bureau : panneau de marque et rail ; mobile : barre du bas). i18n en/fr (ARB). Sans `google_fonts` (fuite vers Google). Outil de captures `tool/screenshots_test.dart`. Test d'intégration réel sur Linux (création, serveur, verrouillage, mauvais mot de passe, déverrouillage). Corrigés en route : tailles de police perdues dans le thème (géométrie typographique absente), focus après une erreur de déverrouillage. Vérifié aussi sur l'émulateur Android. | | 2026-11-21 | 7.2 | `scripts/build-ffi.sh` ; `cargo-ndk` 4.1.2 et cibles Android installés. Linux : cible CMake `meow_ffi`, bibliothèque installée dans le bundle. Android : tâche Gradle `buildMeowFfi` avant `preBuild` (ABI déduites de `-Ptarget-platform`). `core_version()` sert de témoin de chargement, vérifié par une application de release Linux, une de debug Linux, et un APK debug lancé sur l'émulateur android-35 (journal : `bastet: meow 0.2.0 / protocol v2`). `main.dart` est provisoire jusqu'au 7.3. | @@ -135,7 +136,8 @@ conversation est un widget maison, léger. On réutilise de la v1 : | 7.2 | Builds Android (`cargo-ndk` : arm64-v8a, armeabi-v7a, x86_64) et Linux via `scripts/build-ffi.sh`, branchés dans CMake (Linux) et Gradle (Android) : `flutter run` et `flutter build` compilent et embarquent le cœur | `libmeow_ffi.so` chargée par l'application (Linux et émulateur Android) | ✅ | | 7.3 | Squelette de l'application : Riverpod, session (welcome → unlock → home), **thème sable clair/sombre** (contrastes WCAG testés), navigation adaptative (rail / barre), écrans création d'identité, déverrouillage, conversations (état vide), réglages (apparence, accusés, mot de passe, verrouillage), serveurs ; i18n en/fr ; icônes v1 | Lancement Linux et Android, test d'intégration réel | ✅ | | 7.4 | Liste des conversations (dernier message, non-lus, statuts, invitations en attente, contacts cachés) + **écran de conversation maison** : liste inversée chargée segment par segment, bulles groupées, séparateurs de jours, statuts (✓, ✓✓, lu), fichiers (envoi en octets, enregistrement), Entrée pour envoyer, lu à l'ouverture, fiche contact (numéro de sécurité, suppression). Maître-détail sur grand écran | Échange réel testé de bout en bout (test d'intégration) | ✅ | -| 7.5 | Invitations : par serveur (lien + mot de passe), par fichier ou QR, et en présentiel via `peer_secure` (BLE/LAN) qui transporte les octets d'invitation v2 | e2e manuel entre deux appareils | ⬜ | +| 7.5 | Invitations dans l'UI : **lien serveur + mot de passe** (généré), **QR code / texte / fichier en un seul transfert** (`accept_invitation` : seule l'offre circule hors réseau, la réponse passe par les serveurs), écran « J'ai reçu une invitation » (coller, scanner sur mobile, ouvrir un fichier, y compris un fichier de la CLI ; aperçu avant acceptation), option « garder dans un espace caché » | Test d'intégration réel des trois parcours | ✅ | +| 7.5b | **En présentiel (BLE / Wi-Fi local)** : réutiliser seulement les *transports* de `ble_connect` / `lan_connect` ; les 3 messages de l'invitation v2 passent sur le canal, puis les deux personnes comparent le **numéro de sécurité v2** (qui couvre la transcription signée, donc les octets réellement échangés). Pas de la couche session de `peer_secure` (voir annexe B) | e2e manuel entre deux appareils | ⬜ (décision à confirmer) | | 7.6 | Espaces cachés dans l'UI (cacher/révéler, inviter dans un espace caché, aucune trace visuelle sans déverrouillage), réglages (accusés, mot de passe) | | ⬜ | | 7.7 | Android : synchronisation en arrière-plan (service ou WorkManager) et notifications **sans le texte des messages** | Notifications | ⬜ | | 7.8 | Retrait de `meowjsonlib`, `meowwrapper.dart` et `bastet_v1` | | ⬜ | @@ -197,6 +199,10 @@ conversation est un widget maison, léger. On réutilise de la v1 : ## Annexe B — Points v1 à ne pas oublier +* `peer_secure` (audit du 2026-11-21, avant intégration) : + * Après la vérification SAS, `sendAppData` envoie les octets **en clair et sans authentification** : la clé de session dérivée n'est jamais utilisée, et tout message de type inconnu est livré comme donnée applicative. Le SAS ne protège donc pas les données échangées ensuite, et un attaquant au milieu du réseau local pourrait les remplacer. + * L'identité de long terme et la liste des pairs de confiance (noms, dates) sont stockées **en clair** dans `shared_preferences`. Une saisie de l'appareil révèle qui l'on a rencontré en personne, ce qui contredit le modèle de menace du stockage v2. + * Repérés pendant l'analyse, à corriger dans le dépôt Go tant que la v1 tourne : * `meowsrv/config/meowsrv.json` versionne la clé privée du serveur **et** `api_key`/`api_secret` LiveKit. **Ces secrets sont à changer.** * `meowsrv` envoie ses logs en dur à `https://log.redroom.link/loki`. diff --git a/crates/meow-client/src/lib.rs b/crates/meow-client/src/lib.rs index d325f9b..18c2a14 100644 --- a/crates/meow-client/src/lib.rs +++ b/crates/meow-client/src/lib.rs @@ -669,6 +669,45 @@ impl MeowClient { server_urls: &[String], space: Option<&str>, ) -> Result> { + let (_, contact, answer, si) = self.prepare_answer(offer_bytes, contact_name, server_urls, space)?; + self.spaces[si].state.contacts.push(contact); + self.save_space(si)?; + Ok(answer.encode_to_vec()) + } + + /// Step 2 for an offer received by any channel (QR code, file, nearby transfer): + /// answer it and send the answer to the initiator's answer mailbox, which then + /// completes the handshake in the background. Returns the initiator's name. + /// The contact and its answer are saved together. + pub async fn accept_invitation( + &mut self, + offer_bytes: &[u8], + contact_name: Option<&str>, + server_urls: &[String], + space: Option<&str>, + ) -> Result { + let (info, contact, answer, si) = self.prepare_answer(offer_bytes, contact_name, server_urls, space)?; + let queued = outbox::item( + &contact.id, + vec![], + &invitation::answer_deposit(&info, &answer), + info.answer_servers.clone(), + ); + self.spaces[si].state.contacts.push(contact); + self.spaces[si].state.outbox.push(queued); + self.save_space(si)?; + self.flush(false).await?; + Ok(info.initiator_name) + } + + /// Validate an offer and build the answering contact (not stored yet). + fn prepare_answer( + &mut self, + offer_bytes: &[u8], + contact_name: Option<&str>, + server_urls: &[String], + space: Option<&str>, + ) -> Result<(OfferInfo, Contact, v2::InvitationMessage, usize)> { let info = self.inspect_invitation(offer_bytes)?; let name = contact_name.unwrap_or(&info.initiator_name).to_string(); self.ensure_free_name(&name)?; @@ -678,9 +717,7 @@ impl MeowClient { let servers = self.resolve_servers(server_urls)?; let (contact, answer) = invitation::answer(offer_bytes, &name, self.nickname(), servers, now())?; let si = self.target_space(space)?; - self.spaces[si].state.contacts.push(contact); - self.save_space(si)?; - Ok(answer.encode_to_vec()) + Ok((info, contact, answer, si)) } fn by_invitation(&self, id: &[u8]) -> Result<(usize, usize)> { @@ -774,22 +811,8 @@ impl MeowClient { let Resp::InvFetched(f) = resp else { return Err(Error::Network("unexpected response".into())); }; - let info = self.inspect_invitation(&f.payload)?; - let answer_bytes = self - .answer_invitation(&f.payload, contact_name, server_urls, space) - .await?; - let answer = v2::InvitationMessage::decode(answer_bytes.as_slice()).map_err(meow_core::Error::from)?; - let (si, ci) = self.by_invitation(&info.invitation_id)?; - let queued = outbox::item( - &self.spaces[si].state.contacts[ci].id, - vec![], - &invitation::answer_deposit(&info, &answer), - info.answer_servers.clone(), - ); - self.spaces[si].state.outbox.push(queued); - self.save_space(si)?; - self.flush(false).await?; - Ok(info.initiator_name) + self.accept_invitation(&f.payload, contact_name, server_urls, space) + .await } // ───────────────────────── messaging ───────────────────────── diff --git a/crates/meow-client/tests/flow.rs b/crates/meow-client/tests/flow.rs index 1aa7211..1a9581b 100644 --- a/crates/meow-client/tests/flow.rs +++ b/crates/meow-client/tests/flow.rs @@ -820,3 +820,32 @@ async fn background_task_wakes_up_on_new_contacts() { bob.stop().await; let _ = std::fs::remove_dir_all(&dir); } + +/// One-shot invitation (QR code, file, nearby): only the offer travels out of band. +#[tokio::test(flavor = "multi_thread")] +async fn one_shot_invitation_completes_through_servers() { + let servers = vec![spawn_server().await]; + let dir = tmpdir(); + let mut alice = client(&dir, "alice", &servers).await; + let mut bob = client(&dir, "bob", &servers).await; + let offer = alice + .create_invitation("Bob", &[], "scan me", 3600, None) + .await + .unwrap(); + assert_eq!(bob.accept_invitation(&offer, None, &[], None).await.unwrap(), "alice"); + // Accepting twice is refused. + assert!(bob.accept_invitation(&offer, Some("other"), &[], None).await.is_err()); + assert_eq!( + no_receipts(alice.sync(Duration::ZERO).await.unwrap()), + vec![Event::InvitationAccepted { contact: "Bob".into() }] + ); + bob.sync(Duration::ZERO).await.unwrap(); + alice.sync(Duration::ZERO).await.unwrap(); + assert_eq!(alice.contact("Bob").unwrap().state, State::Active); + assert_eq!(bob.contact("alice").unwrap().state, State::Active); + assert_eq!( + alice.contact("Bob").unwrap().safety_number(), + bob.contact("alice").unwrap().safety_number() + ); + let _ = std::fs::remove_dir_all(&dir); +} diff --git a/crates/meow-ffi/src/api/meow.rs b/crates/meow-ffi/src/api/meow.rs index 474b95d..f10d958 100644 --- a/crates/meow-ffi/src/api/meow.rs +++ b/crates/meow-ffi/src/api/meow.rs @@ -528,6 +528,26 @@ impl Meow { .await?)) } + /// Answer an invitation received by any channel (QR code, file, nearby): the + /// answer goes back through the inviter's servers and the handshake completes in + /// the background. Returns the inviter's name. + pub async fn accept_invitation( + &self, + invitation: Vec, + contact_name: Option, + servers: Vec, + space_password: Option, + ) -> Result { + with_client!(self, |c| Ok(c + .accept_invitation( + &invitation, + opt(contact_name).as_deref(), + &servers, + opt(space_password).as_deref() + ) + .await?)) + } + /// Step 3 (file / QR): returns the confirmation bytes to hand over. pub async fn accept_answer(&self, answer: Vec) -> Result> { with_client!(self, |c| Ok(c.accept_answer(&answer).await?)) diff --git a/crates/meow-ffi/src/frb_generated.rs b/crates/meow-ffi/src/frb_generated.rs index a322143..f1454af 100644 --- a/crates/meow-ffi/src/frb_generated.rs +++ b/crates/meow-ffi/src/frb_generated.rs @@ -40,7 +40,7 @@ flutter_rust_bridge::frb_generated_boilerplate!( default_rust_auto_opaque = RustAutoOpaqueMoi, ); pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.13.0"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 1332212757; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1405833860; // Section: executor @@ -93,6 +93,61 @@ fn wire__crate__api__meow__Meow_accept_answer_impl( }, ) } +fn wire__crate__api__meow__Meow_accept_invitation_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "Meow_accept_invitation", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) + }; + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = >>::sse_decode( + &mut deserializer, + ); + let api_invitation = >::sse_decode(&mut deserializer); + let api_contact_name = >::sse_decode(&mut deserializer); + let api_servers = >::sse_decode(&mut deserializer); + let api_space_password = >::sse_decode(&mut deserializer); + deserializer.end(); + move |context| async move { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || async move { + let mut api_that_guard = None; + let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ + flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false), + ]); + for i in decode_indices_ { + match i { + 0 => api_that_guard = Some(api_that.lockable_decode_async_ref().await), + _ => unreachable!(), + } + } + let api_that_guard = api_that_guard.unwrap(); + let output_ok = crate::api::meow::Meow::accept_invitation( + &*api_that_guard, + api_invitation, + api_contact_name, + api_servers, + api_space_password, + ) + .await?; + std::result::Result::Ok(output_ok) + })() + .await, + ) + } + }, + ) +} fn wire__crate__api__meow__Meow_accept_published_invitation_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -2031,37 +2086,38 @@ fn pde_ffi_dispatcher_primary_impl( // Codec=Pde (Serialization + dispatch), see doc to use other codecs match func_id { 1 => wire__crate__api__meow__Meow_accept_answer_impl(port, ptr, rust_vec_len, data_len), - 2 => wire__crate__api__meow__Meow_accept_published_invitation_impl(port, ptr, rust_vec_len, data_len), - 3 => wire__crate__api__meow__Meow_add_server_impl(port, ptr, rust_vec_len, data_len), - 4 => wire__crate__api__meow__Meow_answer_invitation_impl(port, ptr, rust_vec_len, data_len), - 5 => wire__crate__api__meow__Meow_change_password_impl(port, ptr, rust_vec_len, data_len), - 6 => wire__crate__api__meow__Meow_close_impl(port, ptr, rust_vec_len, data_len), - 7 => wire__crate__api__meow__Meow_contacts_impl(port, ptr, rust_vec_len, data_len), - 8 => wire__crate__api__meow__Meow_conversations_impl(port, ptr, rust_vec_len, data_len), - 9 => wire__crate__api__meow__Meow_create_impl(port, ptr, rust_vec_len, data_len), - 10 => wire__crate__api__meow__Meow_create_invitation_impl(port, ptr, rust_vec_len, data_len), - 11 => wire__crate__api__meow__Meow_events_impl(port, ptr, rust_vec_len, data_len), - 12 => wire__crate__api__meow__Meow_file_impl(port, ptr, rust_vec_len, data_len), - 13 => wire__crate__api__meow__Meow_finalize_invitation_impl(port, ptr, rust_vec_len, data_len), - 14 => wire__crate__api__meow__Meow_flush_outbox_impl(port, ptr, rust_vec_len, data_len), - 15 => wire__crate__api__meow__Meow_hide_contact_impl(port, ptr, rust_vec_len, data_len), - 16 => wire__crate__api__meow__Meow_history_impl(port, ptr, rust_vec_len, data_len), - 17 => wire__crate__api__meow__Meow_inspect_invitation_impl(port, ptr, rust_vec_len, data_len), - 18 => wire__crate__api__meow__Meow_mark_read_impl(port, ptr, rust_vec_len, data_len), - 19 => wire__crate__api__meow__Meow_nickname_impl(port, ptr, rust_vec_len, data_len), - 20 => wire__crate__api__meow__Meow_open_impl(port, ptr, rust_vec_len, data_len), - 21 => wire__crate__api__meow__Meow_pending_sends_impl(port, ptr, rust_vec_len, data_len), - 22 => wire__crate__api__meow__Meow_publish_invitation_impl(port, ptr, rust_vec_len, data_len), - 23 => wire__crate__api__meow__Meow_remove_contact_impl(port, ptr, rust_vec_len, data_len), - 24 => wire__crate__api__meow__Meow_remove_server_impl(port, ptr, rust_vec_len, data_len), - 25 => wire__crate__api__meow__Meow_reveal_contact_impl(port, ptr, rust_vec_len, data_len), - 26 => wire__crate__api__meow__Meow_send_file_impl(port, ptr, rust_vec_len, data_len), - 27 => wire__crate__api__meow__Meow_send_text_impl(port, ptr, rust_vec_len, data_len), - 28 => wire__crate__api__meow__Meow_servers_impl(port, ptr, rust_vec_len, data_len), - 29 => wire__crate__api__meow__Meow_set_settings_impl(port, ptr, rust_vec_len, data_len), - 30 => wire__crate__api__meow__Meow_settings_impl(port, ptr, rust_vec_len, data_len), - 31 => wire__crate__api__meow__Meow_unlock_impl(port, ptr, rust_vec_len, data_len), - 33 => wire__crate__api__meow__init_app_impl(port, ptr, rust_vec_len, data_len), + 2 => wire__crate__api__meow__Meow_accept_invitation_impl(port, ptr, rust_vec_len, data_len), + 3 => wire__crate__api__meow__Meow_accept_published_invitation_impl(port, ptr, rust_vec_len, data_len), + 4 => wire__crate__api__meow__Meow_add_server_impl(port, ptr, rust_vec_len, data_len), + 5 => wire__crate__api__meow__Meow_answer_invitation_impl(port, ptr, rust_vec_len, data_len), + 6 => wire__crate__api__meow__Meow_change_password_impl(port, ptr, rust_vec_len, data_len), + 7 => wire__crate__api__meow__Meow_close_impl(port, ptr, rust_vec_len, data_len), + 8 => wire__crate__api__meow__Meow_contacts_impl(port, ptr, rust_vec_len, data_len), + 9 => wire__crate__api__meow__Meow_conversations_impl(port, ptr, rust_vec_len, data_len), + 10 => wire__crate__api__meow__Meow_create_impl(port, ptr, rust_vec_len, data_len), + 11 => wire__crate__api__meow__Meow_create_invitation_impl(port, ptr, rust_vec_len, data_len), + 12 => wire__crate__api__meow__Meow_events_impl(port, ptr, rust_vec_len, data_len), + 13 => wire__crate__api__meow__Meow_file_impl(port, ptr, rust_vec_len, data_len), + 14 => wire__crate__api__meow__Meow_finalize_invitation_impl(port, ptr, rust_vec_len, data_len), + 15 => wire__crate__api__meow__Meow_flush_outbox_impl(port, ptr, rust_vec_len, data_len), + 16 => wire__crate__api__meow__Meow_hide_contact_impl(port, ptr, rust_vec_len, data_len), + 17 => wire__crate__api__meow__Meow_history_impl(port, ptr, rust_vec_len, data_len), + 18 => wire__crate__api__meow__Meow_inspect_invitation_impl(port, ptr, rust_vec_len, data_len), + 19 => wire__crate__api__meow__Meow_mark_read_impl(port, ptr, rust_vec_len, data_len), + 20 => wire__crate__api__meow__Meow_nickname_impl(port, ptr, rust_vec_len, data_len), + 21 => wire__crate__api__meow__Meow_open_impl(port, ptr, rust_vec_len, data_len), + 22 => wire__crate__api__meow__Meow_pending_sends_impl(port, ptr, rust_vec_len, data_len), + 23 => wire__crate__api__meow__Meow_publish_invitation_impl(port, ptr, rust_vec_len, data_len), + 24 => wire__crate__api__meow__Meow_remove_contact_impl(port, ptr, rust_vec_len, data_len), + 25 => wire__crate__api__meow__Meow_remove_server_impl(port, ptr, rust_vec_len, data_len), + 26 => wire__crate__api__meow__Meow_reveal_contact_impl(port, ptr, rust_vec_len, data_len), + 27 => wire__crate__api__meow__Meow_send_file_impl(port, ptr, rust_vec_len, data_len), + 28 => wire__crate__api__meow__Meow_send_text_impl(port, ptr, rust_vec_len, data_len), + 29 => wire__crate__api__meow__Meow_servers_impl(port, ptr, rust_vec_len, data_len), + 30 => wire__crate__api__meow__Meow_set_settings_impl(port, ptr, rust_vec_len, data_len), + 31 => wire__crate__api__meow__Meow_settings_impl(port, ptr, rust_vec_len, data_len), + 32 => wire__crate__api__meow__Meow_unlock_impl(port, ptr, rust_vec_len, data_len), + 34 => wire__crate__api__meow__init_app_impl(port, ptr, rust_vec_len, data_len), _ => unreachable!(), } } @@ -2074,7 +2130,7 @@ fn pde_ffi_dispatcher_sync_impl( ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { // Codec=Pde (Serialization + dispatch), see doc to use other codecs match func_id { - 32 => wire__crate__api__meow__core_version_impl(ptr, rust_vec_len, data_len), + 33 => wire__crate__api__meow__core_version_impl(ptr, rust_vec_len, data_len), _ => unreachable!(), } }