fix for SessionKey lifetime nonense?

Cargo.toml

···
 serde_html_form = "0.2"
 serde_ipld_dagcbor = "0.6"
 serde_repr = "0.1"
+facet = "0.6"
+facet-json = "0.6"
+cfg-if = "1.0"
 
 # Error handling
 miette = "7.6"
···
 jose-jwk = "0.1"
 
 # Text processing
-regex = { version = "1.11", default-features = false }
+regex = { version = "1.12", default-features = false }
 webpage = { version = "2.0", default-features = false }

crates/jacquard-lexicon/src/codegen/structs.rs

···
         let rust_type = if is_required {
             rust_type
         } else {
-            // Use std::option::Option for non-builder structs to avoid name collision
-            if is_builder {
-                quote! { Option<#rust_type> }
-            } else {
-                quote! { std::option::Option<#rust_type> }
-            }
+            quote! { std::option::Option<#rust_type> }
         };
 
         // Extract description from field type

crates/jacquard/src/client.rs

···
         async move {
             CredentialSession::<S, T, W>::session_info(self)
                 .await
-                .map(|(did, sid)| (did, Some(sid)))
+                .map(|key| (key.0, Some(key.1)))
         }
     }
     fn endpoint(&self) -> impl Future<Output = CowStr<'static>> {

crates/jacquard/src/client/credential_session.rs

···
 use jacquard_common::xrpc::XrpcSubscription;
 
 /// Storage key for app‑password sessions: `(account DID, session id)`.
-pub type SessionKey = (Did<'static>, CowStr<'static>);
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SessionKey(pub Did<'static>, pub CowStr<'static>);
 
 /// Stateful client for app‑password based sessions.
 ///
···
         let session = AtpSession::from(out);
 
         let sid = session_id.unwrap_or_else(|| CowStr::new_static("session"));
-        let key = (session.did.clone(), sid.into_static());
+        let key = SessionKey(session.did.clone(), sid.into_static());
         self.store
             .set(key.clone(), session.clone())
             .await
···
             tracing::info_span!("credential_session_restore", did = %did, session_id = %session_id)
                 .entered();
 
-        let key = (did.clone().into_static(), session_id.clone().into_static());
+        let key = SessionKey(did.clone().into_static(), session_id.clone().into_static());
         let Some(sess) = self.store.get(&key).await else {
             return Err(ClientError::auth(AuthError::NotAuthenticated));
         };
···
         *self.endpoint.write().await = Some(pds.to_cowstr().into_static());
         // ensure store has the session (no-op if it existed)
         self.store
-            .set((sess.did.clone(), session_id.into_static()), sess)
+            .set(SessionKey(sess.did.clone(), session_id.into_static()), sess)
             .await?;
         if let Some(file_store) =
             (&*self.store as &dyn Any).downcast_ref::<crate::client::token::FileAuthStore>()
···
     where
         S: Any + 'static,
     {
-        let key = (did.clone().into_static(), session_id.into_static());
+        let key = SessionKey(did.clone().into_static(), session_id.into_static());
         if self.store.get(&key).await.is_none() {
             return Err(ClientError::auth(AuthError::NotAuthenticated));
         }

crates/jacquard/src/client/token.rs

···
             did: Did::new_static("did:plc:alice").unwrap(),
             handle: Handle::new_static("alice.bsky.social").unwrap(),
         };
-        let key: SessionKey = (session.did.clone(), "session".into());
+        let key = SessionKey(session.did.clone(), "session".into());
         jacquard_common::session::SessionStore::set(&store, key.clone(), session.clone())
             .await
             .unwrap();

crates/jacquard/tests/agent.rs

···
         did: Did::new_static("did:plc:alice").unwrap(),
         handle: Handle::new_static("alice.bsky.social").unwrap(),
     };
-    let key: SessionKey = (atp.did.clone(), "session".into());
+    let key = SessionKey(atp.did.clone(), "session".into());
     jacquard_common::session::SessionStore::set(store.as_ref(), key.clone(), atp)
         .await
         .unwrap();

crates/jacquard/tests/credential_session.rs

···
     );
 
     // Verify store updated with refreshed tokens
-    let key: SessionKey = (
+    let key = SessionKey(
         Did::new_static("did:plc:alice").unwrap(),
         jacquard::CowStr::from("session"),
     );

crates/jacquard/tests/restore_pds_cache.rs

···
         did: Did::new_static("did:plc:alice").unwrap(),
         handle: Handle::new_static("alice.bsky.social").unwrap(),
     };
-    let key: SessionKey = (session.did.clone(), "session".into());
+    let key = SessionKey(session.did.clone(), "session".into());
     jacquard_common::session::SessionStore::set(store.as_ref(), key.clone(), session)
         .await
         .unwrap();