Rename the `login` module to `user`.

58 files changed, 190 insertions, 189 deletions

diff --git a/src/app.rs b/src/app.rs
index 0dbf017..b7e52a4 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -11,7 +11,7 @@ use crate::{
 };
 
 #[cfg(test)]
-use crate::login::app::Logins;
+use crate::user::app::Users;
 
 #[derive(Clone)]
 pub struct App {
@@ -50,8 +50,8 @@ impl App {
     }
 
     #[cfg(test)]
-    pub const fn logins(&self) -> Logins {
-        Logins::new(&self.db, &self.events)
+    pub const fn users(&self) -> Users {
+        Users::new(&self.db, &self.events)
     }
 
     pub const fn messages(&self) -> Messages {
diff --git a/src/boot/app.rs b/src/boot/app.rs
index 909f7d8..9c2559e 100644
--- a/src/boot/app.rs
+++ b/src/boot/app.rs
@@ -4,9 +4,9 @@ use super::Snapshot;
 use crate::{
     channel::{self, repo::Provider as _},
     event::repo::Provider as _,
-    login::{self, repo::Provider as _},
     message::repo::Provider as _,
     name,
+    user::{self, repo::Provider as _},
 };
 
 pub struct Boot<'a> {
@@ -22,7 +22,7 @@ impl<'a> Boot<'a> {
         let mut tx = self.db.begin().await?;
         let resume_point = tx.sequence().current().await?;
 
-        let logins = tx.logins().all(resume_point).await?;
+        let logins = tx.users().all(resume_point).await?;
         let channels = tx.channels().all(resume_point).await?;
         let messages = tx.messages().all(resume_point).await?;
 
@@ -59,9 +59,9 @@ pub enum Error {
     Database(#[from] sqlx::Error),
 }
 
-impl From<login::repo::LoadError> for Error {
-    fn from(error: login::repo::LoadError) -> Self {
-        use login::repo::LoadError;
+impl From<user::repo::LoadError> for Error {
+    fn from(error: user::repo::LoadError) -> Self {
+        use user::repo::LoadError;
         match error {
             LoadError::Name(error) => error.into(),
             LoadError::Database(error) => error.into(),
diff --git a/src/boot/mod.rs b/src/boot/mod.rs
index ed4764a..d614df5 100644
--- a/src/boot/mod.rs
+++ b/src/boot/mod.rs
@@ -1,14 +1,14 @@
 pub mod app;
 mod routes;
 
-use crate::{channel::Channel, event::Sequence, login::Login, message::Message};
+use crate::{channel::Channel, event::Sequence, message::Message, user::User};
 
 pub use self::routes::router;
 
 #[derive(serde::Serialize)]
 pub struct Snapshot {
     pub resume_point: Sequence,
-    pub logins: Vec<Login>,
+    pub logins: Vec<User>,
     pub channels: Vec<Channel>,
     pub messages: Vec<Message>,
 }
diff --git a/src/boot/routes/get.rs b/src/boot/routes/get.rs
index 563fbf1..c04c6b3 100644
--- a/src/boot/routes/get.rs
+++ b/src/boot/routes/get.rs
@@ -3,19 +3,19 @@ use axum::{
     response::{self, IntoResponse},
 };
 
-use crate::{app::App, boot::Snapshot, error::Internal, login::Login, token::extract::Identity};
+use crate::{app::App, boot::Snapshot, error::Internal, token::extract::Identity, user::User};
 
 pub async fn handler(State(app): State<App>, identity: Identity) -> Result<Response, Internal> {
     let snapshot = app.boot().snapshot().await?;
     Ok(Response {
-        login: identity.login,
+        login: identity.user,
         snapshot,
     })
 }
 
 #[derive(serde::Serialize)]
 pub struct Response {
-    pub login: Login,
+    pub login: User,
     #[serde(flatten)]
     pub snapshot: Snapshot,
 }
diff --git a/src/boot/routes/test.rs b/src/boot/routes/test.rs
index 202dcb9..5bd9f66 100644
--- a/src/boot/routes/test.rs
+++ b/src/boot/routes/test.rs
@@ -12,7 +12,7 @@ async fn returns_identity() {
         .await
         .expect("boot always succeeds");
 
-    assert_eq!(viewer.login, response.login);
+    assert_eq!(viewer.user, response.login);
 }
 
 #[tokio::test]
diff --git a/src/channel/routes/channel/post.rs b/src/channel/routes/channel/post.rs
index 3f14d64..0aad5e5 100644
--- a/src/channel/routes/channel/post.rs
+++ b/src/channel/routes/channel/post.rs
@@ -21,7 +21,7 @@ pub async fn handler(
 ) -> Result<Response, Error> {
     let message = app
         .messages()
-        .send(&channel, &identity.login, &sent_at, &request.body)
+        .send(&channel, &identity.user, &sent_at, &request.body)
         .await?;
 
     Ok(Response(message))
diff --git a/src/channel/routes/channel/test/post.rs b/src/channel/routes/channel/test/post.rs
index bc0684b..d9527ac 100644
--- a/src/channel/routes/channel/test/post.rs
+++ b/src/channel/routes/channel/test/post.rs
@@ -55,7 +55,7 @@ async fn messages_in_order() {
         .await
     {
         assert_eq!(*sent_at, event.at());
-        assert_eq!(sender.login.id, event.message.sender);
+        assert_eq!(sender.user.id, event.message.sender);
         assert_eq!(body, event.message.body);
     }
 }
diff --git a/src/cli.rs b/src/cli.rs
index 775df7f..4232c00 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -17,9 +17,9 @@ use tokio::net;
 
 use crate::{
     app::App,
-    boot, channel, clock, db, event, expire, invite, login, message,
+    boot, channel, clock, db, event, expire, invite, message,
     setup::{self, middleware::setup_required},
-    ui,
+    ui, user,
 };
 
 /// Command-line entry point for running the `pilcrow` server.
@@ -136,7 +136,7 @@ fn routers(app: &App) -> Router<App> {
             channel::router(),
             event::router(),
             invite::router(),
-            login::router(),
+            user::router(),
             message::router(),
         ]
         .into_iter()
diff --git a/src/event/app.rs b/src/event/app.rs
index 8661c90..447a98f 100644
--- a/src/event/app.rs
+++ b/src/event/app.rs
@@ -8,9 +8,9 @@ use sqlx::sqlite::SqlitePool;
 use super::{Event, Sequence, Sequenced, broadcaster::Broadcaster};
 use crate::{
     channel::{self, repo::Provider as _},
-    login::{self, repo::Provider as _},
     message::{self, repo::Provider as _},
     name,
+    user::{self, repo::Provider as _},
 };
 
 pub struct Events<'a> {
@@ -33,10 +33,10 @@ impl<'a> Events<'a> {
 
         let mut tx = self.db.begin().await?;
 
-        let logins = tx.logins().replay(resume_at).await?;
+        let logins = tx.users().replay(resume_at).await?;
         let login_events = logins
             .iter()
-            .map(login::History::events)
+            .map(user::History::events)
             .kmerge_by(Sequence::merge)
             .filter(Sequence::after(resume_at))
             .map(Event::from);
@@ -88,9 +88,9 @@ pub enum Error {
     Name(#[from] name::Error),
 }
 
-impl From<login::repo::LoadError> for Error {
-    fn from(error: login::repo::LoadError) -> Self {
-        use login::repo::LoadError;
+impl From<user::repo::LoadError> for Error {
+    fn from(error: user::repo::LoadError) -> Self {
+        use user::repo::LoadError;
         match error {
             LoadError::Database(error) => error.into(),
             LoadError::Name(error) => error.into(),
diff --git a/src/event/mod.rs b/src/event/mod.rs
index 9996916..773adc3 100644
--- a/src/event/mod.rs
+++ b/src/event/mod.rs
@@ -1,4 +1,4 @@
-use crate::{channel, login, message};
+use crate::{channel, message, user};
 
 pub mod app;
 mod broadcaster;
@@ -16,7 +16,7 @@ pub use self::{
 #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum Event {
-    Login(login::Event),
+    Login(user::Event),
     Channel(channel::Event),
     Message(message::Event),
 }
@@ -31,8 +31,8 @@ impl Sequenced for Event {
     }
 }
 
-impl From<login::Event> for Event {
-    fn from(event: login::Event) -> Self {
+impl From<user::Event> for Event {
+    fn from(event: user::Event) -> Self {
         Self::Login(event)
     }
 }
diff --git a/src/event/routes/test/invite.rs b/src/event/routes/test/invite.rs
index 73af62d..80b4291 100644
--- a/src/event/routes/test/invite.rs
+++ b/src/event/routes/test/invite.rs
@@ -42,7 +42,7 @@ async fn accepting_invite() {
     let _ = events
         .filter_map(fixtures::event::login)
         .filter_map(fixtures::event::login::created)
-        .filter(|event| future::ready(event.login == joiner))
+        .filter(|event| future::ready(event.user == joiner))
         .next()
         .expect_some("a login created event is sent")
         .await;
@@ -83,7 +83,7 @@ async fn previously_accepted_invite() {
     let _ = events
         .filter_map(fixtures::event::login)
         .filter_map(fixtures::event::login::created)
-        .filter(|event| future::ready(event.login == joiner))
+        .filter(|event| future::ready(event.user == joiner))
         .next()
         .expect_some("a login created event is sent")
         .await;
diff --git a/src/event/routes/test/setup.rs b/src/event/routes/test/setup.rs
index 26b7ea7..345018e 100644
--- a/src/event/routes/test/setup.rs
+++ b/src/event/routes/test/setup.rs
@@ -43,7 +43,7 @@ async fn previously_completed() {
     let _ = events
         .filter_map(fixtures::event::login)
         .filter_map(fixtures::event::login::created)
-        .filter(|event| future::ready(event.login == owner))
+        .filter(|event| future::ready(event.user == owner))
         .next()
         .expect_some("a login created event is sent")
         .await;
diff --git a/src/event/routes/test/token.rs b/src/event/routes/test/token.rs
index fa76865..d2232a4 100644
--- a/src/event/routes/test/token.rs
+++ b/src/event/routes/test/token.rs
@@ -129,7 +129,7 @@ async fn terminates_on_password_change() {
     let (_, password) = creds;
     let to = fixtures::login::propose_password();
     app.tokens()
-        .change_password(&subscriber.login, &password, &to, &fixtures::now())
+        .change_password(&subscriber.user, &password, &to, &fixtures::now())
         .await
         .expect("expiring tokens succeeds");
 
diff --git a/src/invite/app.rs b/src/invite/app.rs
index c56c9b3..e7bd5c6 100644
--- a/src/invite/app.rs
+++ b/src/invite/app.rs
@@ -6,12 +6,12 @@ use crate::{
     clock::DateTime,
     db::{Duplicate as _, NotFound as _},
     event::Broadcaster,
-    login::{
-        Login, Password,
-        create::{self, Create},
-    },
     name::Name,
     token::{Secret, repo::Provider as _},
+    user::{
+        Password, User,
+        create::{self, Create},
+    },
 };
 
 pub struct Invites<'a> {
@@ -24,7 +24,7 @@ impl<'a> Invites<'a> {
         Self { db, events }
     }
 
-    pub async fn issue(&self, issuer: &Login, issued_at: &DateTime) -> Result<Invite, sqlx::Error> {
+    pub async fn issue(&self, issuer: &User, issued_at: &DateTime) -> Result<Invite, sqlx::Error> {
         let mut tx = self.db.begin().await?;
         let invite = tx.invites().create(issuer, issued_at).await?;
         tx.commit().await?;
@@ -46,7 +46,7 @@ impl<'a> Invites<'a> {
         name: &Name,
         password: &Password,
         accepted_at: &DateTime,
-    ) -> Result<(Login, Secret), AcceptError> {
+    ) -> Result<(User, Secret), AcceptError> {
         let create = Create::begin(name, password, accepted_at);
 
         let mut tx = self.db.begin().await?;
@@ -70,7 +70,7 @@ impl<'a> Invites<'a> {
             .store(&mut tx)
             .await
             .duplicate(|| AcceptError::DuplicateLogin(name.clone()))?;
-        let secret = tx.tokens().issue(stored.login(), accepted_at).await?;
+        let secret = tx.tokens().issue(stored.user(), accepted_at).await?;
         tx.commit().await?;
 
         let login = stored.publish(self.events);
@@ -94,7 +94,7 @@ impl<'a> Invites<'a> {
 pub enum AcceptError {
     #[error("invite not found: {0}")]
     NotFound(Id),
-    #[error("invalid login name: {0}")]
+    #[error("invalid user name: {0}")]
     InvalidName(Name),
     #[error("name in use: {0}")]
     DuplicateLogin(Name),
diff --git a/src/invite/mod.rs b/src/invite/mod.rs
index 53ca984..2d32fda 100644
--- a/src/invite/mod.rs
+++ b/src/invite/mod.rs
@@ -3,14 +3,14 @@ mod id;
 mod repo;
 mod routes;
 
-use crate::{clock::DateTime, login, normalize::nfc};
+use crate::{clock::DateTime, normalize::nfc, user};
 
 pub use self::{id::Id, routes::router};
 
 #[derive(Debug, serde::Serialize)]
 pub struct Invite {
     pub id: Id,
-    pub issuer: login::Id,
+    pub issuer: user::Id,
     pub issued_at: DateTime,
 }
 
diff --git a/src/invite/repo.rs b/src/invite/repo.rs
index c716ed9..79114ec 100644
--- a/src/invite/repo.rs
+++ b/src/invite/repo.rs
@@ -3,8 +3,8 @@ use sqlx::{SqliteConnection, Transaction, sqlite::Sqlite};
 use super::{Id, Invite, Summary};
 use crate::{
     clock::DateTime,
-    login::{self, Login},
     normalize::nfc,
+    user::{self, User},
 };
 
 pub trait Provider {
@@ -22,7 +22,7 @@ pub struct Invites<'t>(&'t mut SqliteConnection);
 impl Invites<'_> {
     pub async fn create(
         &mut self,
-        issuer: &Login,
+        issuer: &User,
         issued_at: &DateTime,
     ) -> Result<Invite, sqlx::Error> {
         let id = Id::generate();
@@ -33,7 +33,7 @@ impl Invites<'_> {
                 values ($1, $2, $3)
                 returning
                     id as "id: Id",
-                    issuer as "issuer: login::Id",
+                    issuer as "issuer: user::Id",
                     issued_at as "issued_at: DateTime"
             "#,
             id,
@@ -52,7 +52,7 @@ impl Invites<'_> {
             r#"
                 select
                     id as "id: Id",
-                    issuer as "issuer: login::Id",
+                    issuer as "issuer: user::Id",
                     issued_at as "issued_at: DateTime"
                 from invite
                 where id = $1
@@ -70,7 +70,7 @@ impl Invites<'_> {
             r#"
                 select
                     invite.id as "invite_id: Id",
-                    issuer.id as "issuer_id: login::Id",
+                    issuer.id as "issuer_id: user::Id",
                     issuer.display_name as "issuer_name: nfc::String",
                     invite.issued_at as "invite_issued_at: DateTime"
                 from invite
diff --git a/src/invite/routes/invite/post.rs b/src/invite/routes/invite/post.rs
index bb68e07..58d15c2 100644
--- a/src/invite/routes/invite/post.rs
+++ b/src/invite/routes/invite/post.rs
@@ -9,9 +9,9 @@ use crate::{
     clock::RequestedAt,
     error::{Internal, NotFound},
     invite::app,
-    login::{Login, Password},
     name::Name,
     token::extract::IdentityCookie,
+    user::{Password, User},
 };
 
 pub async fn handler(
@@ -20,7 +20,7 @@ pub async fn handler(
     identity: IdentityCookie,
     Path(invite): Path<super::PathInfo>,
     Json(request): Json<Request>,
-) -> Result<(IdentityCookie, Json<Login>), Error> {
+) -> Result<(IdentityCookie, Json<User>), Error> {
     let (login, secret) = app
         .invites()
         .accept(&invite, &request.name, &request.password, &accepted_at)
diff --git a/src/invite/routes/invite/test/post.rs b/src/invite/routes/invite/test/post.rs
index 40e0580..3db764c 100644
--- a/src/invite/routes/invite/test/post.rs
+++ b/src/invite/routes/invite/test/post.rs
@@ -171,14 +171,14 @@ async fn conflicting_name() {
     let invite = fixtures::invite::issue(&app, &issuer, &fixtures::ancient()).await;
 
     let existing_name = Name::from("rijksmuseum");
-    app.logins()
+    app.users()
         .create(
             &existing_name,
             &fixtures::login::propose_password(),
             &fixtures::now(),
         )
         .await
-        .expect("creating a login in an empty environment succeeds");
+        .expect("creating a user in an empty environment succeeds");
 
     // Call the endpoint
 
diff --git a/src/invite/routes/post.rs b/src/invite/routes/post.rs
index 898081e..f7ca76c 100644
--- a/src/invite/routes/post.rs
+++ b/src/invite/routes/post.rs
@@ -10,7 +10,7 @@ pub async fn handler(
     identity: Identity,
     _: Json<Request>,
 ) -> Result<Json<Invite>, Internal> {
-    let invite = app.invites().issue(&identity.login, &issued_at).await?;
+    let invite = app.invites().issue(&identity.user, &issued_at).await?;
     Ok(Json(invite))
 }
 
diff --git a/src/invite/routes/test.rs b/src/invite/routes/test.rs
index 4d99660..4ea8a3d 100644
--- a/src/invite/routes/test.rs
+++ b/src/invite/routes/test.rs
@@ -23,6 +23,6 @@ async fn create_invite() {
     .expect("creating an invite always succeeds");
 
     // Verify the response
-    assert_eq!(issuer.login.id, invite.issuer);
+    assert_eq!(issuer.user.id, invite.issuer);
     assert_eq!(&*issued_at, &invite.issued_at);
 }
diff --git a/src/lib.rs b/src/lib.rs
index 765e625..4cce63b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -14,7 +14,6 @@ mod event;
 mod expire;
 mod id;
 mod invite;
-mod login;
 mod message;
 mod name;
 mod normalize;
@@ -23,3 +22,4 @@ mod setup;
 mod test;
 mod token;
 mod ui;
+mod user;
diff --git a/src/message/app.rs b/src/message/app.rs
index 6f8f3d4..3c74628 100644
--- a/src/message/app.rs
+++ b/src/message/app.rs
@@ -8,8 +8,8 @@ use crate::{
     clock::DateTime,
     db::NotFound as _,
     event::{Broadcaster, Event, Sequence, repo::Provider as _},
-    login::Login,
     name,
+    user::User,
 };
 
 pub struct Messages<'a> {
@@ -25,7 +25,7 @@ impl<'a> Messages<'a> {
     pub async fn send(
         &self,
         channel: &channel::Id,
-        sender: &Login,
+        sender: &User,
         sent_at: &DateTime,
         body: &Body,
     ) -> Result<Message, SendError> {
@@ -47,7 +47,7 @@ impl<'a> Messages<'a> {
 
     pub async fn delete(
         &self,
-        deleted_by: &Login,
+        deleted_by: &User,
         message: &Id,
         deleted_at: &DateTime,
     ) -> Result<(), DeleteError> {
@@ -146,8 +146,8 @@ impl From<channel::repo::LoadError> for SendError {
 pub enum DeleteError {
     #[error("message {0} not found")]
     NotFound(Id),
-    #[error("login {} not the message's sender", .0.id)]
-    NotSender(Login),
+    #[error("user {} not the message's sender", .0.id)]
+    NotSender(User),
     #[error("message {0} deleted")]
     Deleted(Id),
     #[error(transparent)]
diff --git a/src/message/repo.rs b/src/message/repo.rs
index 8a0a72c..9a4f72f 100644
--- a/src/message/repo.rs
+++ b/src/message/repo.rs
@@ -5,7 +5,7 @@ use crate::{
     channel,
     clock::DateTime,
     event::{Instant, Sequence},
-    login::{self, Login},
+    user::{self, User},
 };
 
 pub trait Provider {
@@ -24,7 +24,7 @@ impl Messages<'_> {
     pub async fn create(
         &mut self,
         channel: &channel::History,
-        sender: &Login,
+        sender: &User,
         sent: &Instant,
         body: &Body,
     ) -> Result<History, sqlx::Error> {
@@ -39,7 +39,7 @@ impl Messages<'_> {
                 returning
                     id as "id: Id",
                     channel as "channel: channel::Id",
-                    sender as "sender: login::Id",
+                    sender as "sender: user::Id",
                     sent_at as "sent_at: DateTime",
                     sent_sequence as "sent_sequence: Sequence",
                     body as "body: Body"
@@ -75,7 +75,7 @@ impl Messages<'_> {
             r#"
                 select
                     message.channel as "channel: channel::Id",
-                    message.sender as "sender: login::Id",
+                    message.sender as "sender: user::Id",
                     id as "id: Id",
                     message.body as "body: Body",
                     message.sent_at as "sent_at: DateTime",
@@ -112,7 +112,7 @@ impl Messages<'_> {
             r#"
                 select
                     message.channel as "channel: channel::Id",
-                    message.sender as "sender: login::Id",
+                    message.sender as "sender: user::Id",
                     message.id as "id: Id",
                     message.body as "body: Body",
                     message.sent_at as "sent_at: DateTime",
@@ -149,7 +149,7 @@ impl Messages<'_> {
             r#"
                 select
                     message.channel as "channel: channel::Id",
-                    message.sender as "sender: login::Id",
+                    message.sender as "sender: user::Id",
                     id as "id: Id",
                     message.body as "body: Body",
                     message.sent_at as "sent_at: DateTime",
@@ -254,7 +254,7 @@ impl Messages<'_> {
                 select
                     id as "id: Id",
                     message.channel as "channel: channel::Id",
-                    message.sender as "sender: login::Id",
+                    message.sender as "sender: user::Id",
                     message.sent_at as "sent_at: DateTime",
                     message.sent_sequence as "sent_sequence: Sequence",
                     message.body as "body: Body",
@@ -291,7 +291,7 @@ impl Messages<'_> {
                 select
                     id as "id: Id",
                     message.channel as "channel: channel::Id",
-                    message.sender as "sender: login::Id",
+                    message.sender as "sender: user::Id",
                     message.sent_at as "sent_at: DateTime",
                     message.sent_sequence as "sent_sequence: Sequence",
                     message.body as "body: Body",
diff --git a/src/message/routes/message/mod.rs b/src/message/routes/message/mod.rs
index e92f556..4abd445 100644
--- a/src/message/routes/message/mod.rs
+++ b/src/message/routes/message/mod.rs
@@ -23,7 +23,7 @@ pub mod delete {
         identity: Identity,
     ) -> Result<Response, Error> {
         app.messages()
-            .delete(&identity.login, &message, &deleted_at)
+            .delete(&identity.user, &message, &deleted_at)
             .await?;
 
         Ok(Response { id: message })
diff --git a/src/message/routes/message/test.rs b/src/message/routes/message/test.rs
index 5178ab5..1abd91c 100644
--- a/src/message/routes/message/test.rs
+++ b/src/message/routes/message/test.rs
@@ -10,7 +10,7 @@ pub async fn delete_message() {
     let app = fixtures::scratch_app().await;
     let sender = fixtures::identity::create(&app, &fixtures::now()).await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-    let message = fixtures::message::send(&app, &channel, &sender.login, &fixtures::now()).await;
+    let message = fixtures::message::send(&app, &channel, &sender.user, &fixtures::now()).await;
 
     // Send the request
 
@@ -179,6 +179,6 @@ pub async fn delete_not_sender() {
     // Verify the response
 
     assert!(
-        matches!(error, app::DeleteError::NotSender(error_sender) if deleter.login == error_sender)
+        matches!(error, app::DeleteError::NotSender(error_sender) if deleter.user == error_sender)
     );
 }
diff --git a/src/message/snapshot.rs b/src/message/snapshot.rs
index d924ea1..ac067f7 100644
--- a/src/message/snapshot.rs
+++ b/src/message/snapshot.rs
@@ -2,14 +2,14 @@ use super::{
     Body, Id,
     event::{Event, Sent},
 };
-use crate::{channel, clock::DateTime, event::Instant, login};
+use crate::{channel, clock::DateTime, event::Instant, user};
 
 #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
 pub struct Message {
     #[serde(flatten)]
     pub sent: Instant,
     pub channel: channel::Id,
-    pub sender: login::Id,
+    pub sender: user::Id,
     pub id: Id,
     pub body: Body,
     #[serde(skip_serializing_if = "Option::is_none")]
diff --git a/src/setup/app.rs b/src/setup/app.rs
index 9553f40..9f31c01 100644
--- a/src/setup/app.rs
+++ b/src/setup/app.rs
@@ -4,12 +4,12 @@ use super::repo::Provider as _;
 use crate::{
     clock::DateTime,
     event::Broadcaster,
-    login::{
-        Login, Password,
-        create::{self, Create},
-    },
     name::Name,
     token::{Secret, repo::Provider as _},
+    user::{
+        Password, User,
+        create::{self, Create},
+    },
 };
 
 pub struct Setup<'a> {
@@ -27,7 +27,7 @@ impl<'a> Setup<'a> {
         name: &Name,
         password: &Password,
         created_at: &DateTime,
-    ) -> Result<(Login, Secret), Error> {
+    ) -> Result<(User, Secret), Error> {
         let create = Create::begin(name, password, created_at);
 
         let validated = create.validate()?;
@@ -38,7 +38,7 @@ impl<'a> Setup<'a> {
         } else {
             validated.store(&mut tx).await?
         };
-        let secret = tx.tokens().issue(stored.login(), created_at).await?;
+        let secret = tx.tokens().issue(stored.user(), created_at).await?;
         tx.commit().await?;
 
         let login = stored.publish(self.events);
@@ -59,7 +59,7 @@ impl<'a> Setup<'a> {
 pub enum Error {
     #[error("initial setup previously completed")]
     SetupCompleted,
-    #[error("invalid login name: {0}")]
+    #[error("invalid user name: {0}")]
     InvalidName(Name),
     #[error(transparent)]
     Database(#[from] sqlx::Error),
diff --git a/src/setup/routes/post.rs b/src/setup/routes/post.rs
index 2a46b04..9c6b7a6 100644
--- a/src/setup/routes/post.rs
+++ b/src/setup/routes/post.rs
@@ -8,10 +8,10 @@ use crate::{
     app::App,
     clock::RequestedAt,
     error::Internal,
-    login::{Login, Password},
     name::Name,
     setup::app,
     token::extract::IdentityCookie,
+    user::{Password, User},
 };
 
 pub async fn handler(
@@ -19,7 +19,7 @@ pub async fn handler(
     RequestedAt(setup_at): RequestedAt,
     identity: IdentityCookie,
     Json(request): Json<Request>,
-) -> Result<(IdentityCookie, Json<Login>), Error> {
+) -> Result<(IdentityCookie, Json<User>), Error> {
     let (login, secret) = app
         .setup()
         .initial(&request.name, &request.password, &setup_at)
diff --git a/src/test/fixtures/cookie.rs b/src/test/fixtures/cookie.rs
index fcb379f..bba53b8 100644
--- a/src/test/fixtures/cookie.rs
+++ b/src/test/fixtures/cookie.rs
@@ -3,9 +3,9 @@ use uuid::Uuid;
 use crate::{
     app::App,
     clock::RequestedAt,
-    login::Password,
     name::Name,
     token::{Secret, extract::IdentityCookie},
+    user::Password,
 };
 
 pub fn not_logged_in() -> IdentityCookie {
diff --git a/src/test/fixtures/event.rs b/src/test/fixtures/event.rs
index e11f6ee..c6e5337 100644
--- a/src/test/fixtures/event.rs
+++ b/src/test/fixtures/event.rs
@@ -68,8 +68,8 @@ pub mod message {
 pub mod login {
     use std::future::{self, Ready};
 
-    pub use crate::login::Event;
-    use crate::login::event;
+    pub use crate::user::Event;
+    use crate::user::event;
 
     pub fn created(event: Event) -> Ready<Option<event::Created>> {
         future::ready(match event {
diff --git a/src/test/fixtures/identity.rs b/src/test/fixtures/identity.rs
index ffc44c6..7611066 100644
--- a/src/test/fixtures/identity.rs
+++ b/src/test/fixtures/identity.rs
@@ -1,13 +1,13 @@
 use crate::{
     app::App,
     clock::RequestedAt,
-    login::Password,
     name::Name,
     test::fixtures,
     token::{
         self,
         extract::{Identity, IdentityCookie},
     },
+    user::Password,
 };
 
 pub async fn create(app: &App, created_at: &RequestedAt) -> Identity {
@@ -27,7 +27,7 @@ pub async fn from_cookie(
         .await
         .expect("always validates newly-issued secret");
 
-    Identity { token, login }
+    Identity { token, user: login }
 }
 
 pub async fn logged_in(
@@ -43,5 +43,5 @@ pub fn fictitious() -> Identity {
     let token = token::Id::generate();
     let login = fixtures::login::fictitious();
 
-    Identity { token, login }
+    Identity { token, user: login }
 }
diff --git a/src/test/fixtures/invite.rs b/src/test/fixtures/invite.rs
index 654d1b4..7a41eb6 100644
--- a/src/test/fixtures/invite.rs
+++ b/src/test/fixtures/invite.rs
@@ -2,10 +2,10 @@ use crate::{
     app::App,
     clock::DateTime,
     invite::{self, Invite},
-    login::Login,
+    user::User,
 };
 
-pub async fn issue(app: &App, issuer: &Login, issued_at: &DateTime) -> Invite {
+pub async fn issue(app: &App, issuer: &User, issued_at: &DateTime) -> Invite {
     app.invites()
         .issue(issuer, issued_at)
         .await
diff --git a/src/test/fixtures/login.rs b/src/test/fixtures/login.rs
index 86e3e39..e668c95 100644
--- a/src/test/fixtures/login.rs
+++ b/src/test/fixtures/login.rs
@@ -4,14 +4,14 @@ use uuid::Uuid;
 use crate::{
     app::App,
     clock::RequestedAt,
-    login::{self, Login, Password},
     name::Name,
+    user::{self, Password, User},
 };
 
 pub async fn create_with_password(app: &App, created_at: &RequestedAt) -> (Name, Password) {
     let (name, password) = propose();
     let login = app
-        .logins()
+        .users()
         .create(&name, &password, created_at)
         .await
         .expect("should always succeed if the login is actually new");
@@ -19,17 +19,17 @@ pub async fn create_with_password(app: &App, created_at: &RequestedAt) -> (Name,
     (login.name, password)
 }
 
-pub async fn create(app: &App, created_at: &RequestedAt) -> Login {
+pub async fn create(app: &App, created_at: &RequestedAt) -> User {
     let (name, password) = propose();
-    app.logins()
+    app.users()
         .create(&name, &password, created_at)
         .await
         .expect("should always succeed if the login is actually new")
 }
 
-pub fn fictitious() -> Login {
-    Login {
-        id: login::Id::generate(),
+pub fn fictitious() -> User {
+    User {
+        id: user::Id::generate(),
         name: propose_name(),
     }
 }
diff --git a/src/test/fixtures/message.rs b/src/test/fixtures/message.rs
index d3b4719..2254915 100644
--- a/src/test/fixtures/message.rs
+++ b/src/test/fixtures/message.rs
@@ -4,11 +4,11 @@ use crate::{
     app::App,
     channel::Channel,
     clock::RequestedAt,
-    login::Login,
     message::{self, Body, Message},
+    user::User,
 };
 
-pub async fn send(app: &App, channel: &Channel, sender: &Login, sent_at: &RequestedAt) -> Message {
+pub async fn send(app: &App, channel: &Channel, sender: &User, sent_at: &RequestedAt) -> Message {
     let body = propose();
 
     app.messages()
diff --git a/src/token/app.rs b/src/token/app.rs
index 3f054ff..211df81 100644
--- a/src/token/app.rs
+++ b/src/token/app.rs
@@ -12,8 +12,8 @@ use super::{
 use crate::{
     clock::DateTime,
     db::NotFound as _,
-    login::{Login, Password, repo::Provider as _},
     name::{self, Name},
+    user::{Password, User, repo::Provider as _},
 };
 
 pub struct Tokens<'a> {
@@ -31,7 +31,7 @@ impl<'a> Tokens<'a> {
         name: &Name,
         password: &Password,
         login_at: &DateTime,
-    ) -> Result<(Login, Secret), LoginError> {
+    ) -> Result<(User, Secret), LoginError> {
         let mut tx = self.db.begin().await?;
         let (login, stored_hash) = tx
             .auth()
@@ -62,11 +62,11 @@ impl<'a> Tokens<'a> {
 
     pub async fn change_password(
         &self,
-        login: &Login,
+        login: &User,
         password: &Password,
         to: &Password,
         changed_at: &DateTime,
-    ) -> Result<(Login, Secret), LoginError> {
+    ) -> Result<(User, Secret), LoginError> {
         let mut tx = self.db.begin().await?;
         let (login, stored_hash) = tx
             .auth()
@@ -90,7 +90,7 @@ impl<'a> Tokens<'a> {
 
         let mut tx = self.db.begin().await?;
         let tokens = tx.tokens().revoke_all(&login).await?;
-        tx.logins().set_password(&login, &to_hash).await?;
+        tx.users().set_password(&login, &to_hash).await?;
         let secret = tx.tokens().issue(&login, changed_at).await?;
         tx.commit().await?;
 
@@ -105,7 +105,7 @@ impl<'a> Tokens<'a> {
         &self,
         secret: &Secret,
         used_at: &DateTime,
-    ) -> Result<(Id, Login), ValidateError> {
+    ) -> Result<(Id, User), ValidateError> {
         let mut tx = self.db.begin().await?;
         let (token, login) = tx
             .tokens()
@@ -226,7 +226,7 @@ impl From<repo::auth::LoadError> for LoginError {
 pub enum ValidateError {
     #[error("invalid token")]
     InvalidToken,
-    #[error("login deleted")]
+    #[error("user deleted")]
     LoginDeleted,
     #[error(transparent)]
     Database(#[from] sqlx::Error),
diff --git a/src/token/extract/identity.rs b/src/token/extract/identity.rs
index acfd7ae..d1c0334 100644
--- a/src/token/extract/identity.rs
+++ b/src/token/extract/identity.rs
@@ -10,14 +10,14 @@ use crate::{
     app::App,
     clock::RequestedAt,
     error::{Internal, Unauthorized},
-    login::Login,
     token::{self, app::ValidateError},
+    user::User,
 };
 
 #[derive(Clone, Debug)]
 pub struct Identity {
     pub token: token::Id,
-    pub login: Login,
+    pub user: User,
 }
 
 impl FromRequestParts<App> for Identity {
@@ -31,7 +31,7 @@ impl FromRequestParts<App> for Identity {
 
         let app = State::<App>::from_request_parts(parts, state).await?;
         match app.tokens().validate(&secret, &used_at).await {
-            Ok((token, login)) => Ok(Identity { token, login }),
+            Ok((token, user)) => Ok(Identity { token, user }),
             Err(ValidateError::InvalidToken) => Err(LoginError::Unauthorized),
             Err(other) => Err(other.into()),
         }
diff --git a/src/token/repo/auth.rs b/src/token/repo/auth.rs
index 8900704..a1f4aad 100644
--- a/src/token/repo/auth.rs
+++ b/src/token/repo/auth.rs
@@ -4,8 +4,8 @@ use crate::{
     clock::DateTime,
     db::NotFound,
     event::{Instant, Sequence},
-    login::{self, History, Login, password::StoredHash},
     name::{self, Name},
+    user::{self, History, User, password::StoredHash},
 };
 
 pub trait Provider {
@@ -26,7 +26,7 @@ impl Auth<'_> {
         let row = sqlx::query!(
             r#"
                 select
-                    id as "id: login::Id",
+                    id as "id: user::Id",
                     display_name as "display_name: String",
                     canonical_name as "canonical_name: String",
                     created_sequence as "created_sequence: Sequence",
@@ -41,7 +41,7 @@ impl Auth<'_> {
         .await?;
 
         let login = History {
-            login: Login {
+            user: User {
                 id: row.id,
                 name: Name::new(row.display_name, row.canonical_name)?,
             },
@@ -51,11 +51,11 @@ impl Auth<'_> {
         Ok((login, row.password_hash))
     }
 
-    pub async fn for_login(&mut self, login: &Login) -> Result<(History, StoredHash), LoadError> {
+    pub async fn for_login(&mut self, login: &User) -> Result<(History, StoredHash), LoadError> {
         let row = sqlx::query!(
             r#"
                 select
-                    id as "id: login::Id",
+                    id as "id: user::Id",
                     display_name as "display_name: String",
                     canonical_name as "canonical_name: String",
                     created_sequence as "created_sequence: Sequence",
@@ -70,7 +70,7 @@ impl Auth<'_> {
         .await?;
 
         let login = History {
-            login: Login {
+            user: User {
                 id: row.id,
                 name: Name::new(row.display_name, row.canonical_name)?,
             },
diff --git a/src/token/repo/token.rs b/src/token/repo/token.rs
index 3428030..145ba2d 100644
--- a/src/token/repo/token.rs
+++ b/src/token/repo/token.rs
@@ -5,9 +5,9 @@ use crate::{
     clock::DateTime,
     db::NotFound,
     event::{Instant, Sequence},
-    login::{self, History, Login},
     name::{self, Name},
     token::{Id, Secret},
+    user::{self, History, User},
 };
 
 pub trait Provider {
@@ -85,7 +85,7 @@ impl Tokens<'_> {
     }
 
     // Revoke tokens for a login
-    pub async fn revoke_all(&mut self, login: &login::History) -> Result<Vec<Id>, sqlx::Error> {
+    pub async fn revoke_all(&mut self, login: &user::History) -> Result<Vec<Id>, sqlx::Error> {
         let login = login.id();
         let tokens = sqlx::query_scalar!(
             r#"
@@ -139,7 +139,7 @@ impl Tokens<'_> {
                 where secret = $2
                 returning
                     id as "token: Id",
-                    user as "user: login::Id"
+                    user as "user: user::Id"
             "#,
             used_at,
             secret,
@@ -151,7 +151,7 @@ impl Tokens<'_> {
         let login = sqlx::query!(
             r#"
                 select
-                    id as "id: login::Id",
+                    id as "id: user::Id",
                     display_name as "display_name: String",
                     canonical_name as "canonical_name: String",
                     created_sequence as "created_sequence: Sequence",
@@ -163,7 +163,7 @@ impl Tokens<'_> {
         )
         .map(|row| {
             Ok::<_, name::Error>(History {
-                login: Login {
+                user: User {
                     id: row.id,
                     name: Name::new(row.display_name, row.canonical_name)?,
                 },
diff --git a/src/login/app.rs b/src/user/app.rs
index 2da4d6a..2ab356f 100644
--- a/src/login/app.rs
+++ b/src/user/app.rs
@@ -1,17 +1,17 @@
 use sqlx::sqlite::SqlitePool;
 
 use super::{
-    Login, Password,
+    Password, User,
     create::{self, Create},
 };
 use crate::{clock::DateTime, event::Broadcaster, name::Name};
 
-pub struct Logins<'a> {
+pub struct Users<'a> {
     db: &'a SqlitePool,
     events: &'a Broadcaster,
 }
 
-impl<'a> Logins<'a> {
+impl<'a> Users<'a> {
     pub const fn new(db: &'a SqlitePool, events: &'a Broadcaster) -> Self {
         Self { db, events }
     }
@@ -21,7 +21,7 @@ impl<'a> Logins<'a> {
         name: &Name,
         password: &Password,
         created_at: &DateTime,
-    ) -> Result<Login, CreateError> {
+    ) -> Result<User, CreateError> {
         let create = Create::begin(name, password, created_at);
         let validated = create.validate()?;
 
@@ -29,15 +29,15 @@ impl<'a> Logins<'a> {
         let stored = validated.store(&mut tx).await?;
         tx.commit().await?;
 
-        let login = stored.publish(self.events);
+        let user = stored.publish(self.events);
 
-        Ok(login.as_created())
+        Ok(user.as_created())
     }
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum CreateError {
-    #[error("invalid login name: {0}")]
+    #[error("invalid user name: {0}")]
     InvalidName(Name),
     #[error(transparent)]
     PasswordHash(#[from] password_hash::Error),
diff --git a/src/login/create.rs b/src/user/create.rs
index c5cea08..da94685 100644
--- a/src/login/create.rs
+++ b/src/user/create.rs
@@ -1,13 +1,13 @@
-use sqlx::{sqlite::Sqlite, Transaction};
+use sqlx::{Transaction, sqlite::Sqlite};
 
-use super::{password::StoredHash, repo::Provider as _, validate, History, Password};
+use super::{History, Password, password::StoredHash, repo::Provider as _, validate};
 use crate::{
     clock::DateTime,
-    event::{repo::Provider as _, Broadcaster, Event},
+    event::{Broadcaster, Event, repo::Provider as _},
     name::Name,
 };
 
-#[must_use = "dropping a login creation attempt is likely a mistake"]
+#[must_use = "dropping a user creation attempt is likely a mistake"]
 pub struct Create<'a> {
     name: &'a Name,
     password: &'a Password,
@@ -44,7 +44,7 @@ impl<'a> Create<'a> {
     }
 }
 
-#[must_use = "dropping a login creation attempt is likely a mistake"]
+#[must_use = "dropping a user creation attempt is likely a mistake"]
 pub struct Validated<'a> {
     name: &'a Name,
     password_hash: StoredHash,
@@ -60,35 +60,35 @@ impl Validated<'_> {
         } = self;
 
         let created = tx.sequence().next(created_at).await?;
-        let login = tx.logins().create(name, &password_hash, &created).await?;
+        let user = tx.users().create(name, &password_hash, &created).await?;
 
-        Ok(Stored { login })
+        Ok(Stored { user })
     }
 }
 
-#[must_use = "dropping a login creation attempt is likely a mistake"]
+#[must_use = "dropping a user creation attempt is likely a mistake"]
 pub struct Stored {
-    login: History,
+    user: History,
 }
 
 impl Stored {
-    #[must_use = "dropping a login creation attempt is likely a mistake"]
+    #[must_use = "dropping a user creation attempt is likely a mistake"]
     pub fn publish(self, events: &Broadcaster) -> History {
-        let Self { login } = self;
+        let Self { user } = self;
 
-        events.broadcast(login.events().map(Event::from).collect::<Vec<_>>());
+        events.broadcast(user.events().map(Event::from).collect::<Vec<_>>());
 
-        login
+        user
     }
 
-    pub fn login(&self) -> &History {
-        &self.login
+    pub fn user(&self) -> &History {
+        &self.user
     }
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error("invalid login name: {0}")]
+    #[error("invalid user name: {0}")]
     InvalidName(Name),
     #[error(transparent)]
     PasswordHash(#[from] password_hash::Error),
diff --git a/src/login/event.rs b/src/user/event.rs
index b03451a..a748112 100644
--- a/src/login/event.rs
+++ b/src/user/event.rs
@@ -1,4 +1,4 @@
-use super::snapshot::Login;
+use super::snapshot::User;
 use crate::event::{Instant, Sequenced};
 
 #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
@@ -20,7 +20,7 @@ pub struct Created {
     #[serde(flatten)]
     pub instant: Instant,
     #[serde(flatten)]
-    pub login: Login,
+    pub user: User,
 }
 
 impl Sequenced for Created {
diff --git a/src/login/history.rs b/src/user/history.rs
index d67bcce..ae7a561 100644
--- a/src/login/history.rs
+++ b/src/user/history.rs
@@ -1,37 +1,37 @@
 use super::{
-    Id, Login,
+    Id, User,
     event::{Created, Event},
 };
 use crate::event::{Instant, Sequence};
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct History {
-    pub login: Login,
+    pub user: User,
     pub created: Instant,
 }
 
 // State interface
 impl History {
     pub fn id(&self) -> &Id {
-        &self.login.id
+        &self.user.id
     }
 
-    // Snapshot of this login as it was when created. (Note to the future: it's okay
-    // if this returns a redacted or modified version of the login. If we  implement
+    // Snapshot of this user as it was when created. (Note to the future: it's okay
+    // if this returns a redacted or modified version of the user. If we  implement
     // renames by redacting the original name, then this should return the edited
-    // login, not the original, even if that's not how it was "as created.")
-    pub fn as_created(&self) -> Login {
-        self.login.clone()
+    // user, not the original, even if that's not how it was "as created.")
+    pub fn as_created(&self) -> User {
+        self.user.clone()
     }
 
-    pub fn as_of(&self, resume_point: Sequence) -> Option<Login> {
+    pub fn as_of(&self, resume_point: Sequence) -> Option<User> {
         self.events()
             .filter(Sequence::up_to(resume_point))
             .collect()
     }
 
-    // Snapshot of this login, as of all events recorded in this history.
-    pub fn as_snapshot(&self) -> Option<Login> {
+    // Snapshot of this user, as of all events recorded in this history.
+    pub fn as_snapshot(&self) -> Option<User> {
         self.events().collect()
     }
 }
@@ -41,7 +41,7 @@ impl History {
     fn created(&self) -> Event {
         Created {
             instant: self.created,
-            login: self.login.clone(),
+            user: self.user.clone(),
         }
         .into()
     }
diff --git a/src/login/id.rs b/src/user/id.rs
index c46d697..9455deb 100644
--- a/src/login/id.rs
+++ b/src/user/id.rs
@@ -1,6 +1,6 @@
 use crate::id::Id as BaseId;
 
-// Stable identifier for a [Login]. Prefixed with `L`.
+// Stable identifier for a User. Prefixed with `L`.
 #[derive(Clone, Debug, Eq, PartialEq, sqlx::Type, serde::Serialize)]
 #[sqlx(transparent)]
 pub struct Id(BaseId);
diff --git a/src/login/mod.rs b/src/user/mod.rs
index 006fa0c..f4c66ab 100644
--- a/src/login/mod.rs
+++ b/src/user/mod.rs
@@ -11,5 +11,5 @@ mod snapshot;
 mod validate;
 
 pub use self::{
-    event::Event, history::History, id::Id, password::Password, routes::router, snapshot::Login,
+    event::Event, history::History, id::Id, password::Password, routes::router, snapshot::User,
 };
diff --git a/src/login/password.rs b/src/user/password.rs
index e1d164e..e1d164e 100644
--- a/src/login/password.rs
+++ b/src/user/password.rs
diff --git a/src/login/repo.rs b/src/user/repo.rs
index 128d6b8..c02d50f 100644
--- a/src/login/repo.rs
+++ b/src/user/repo.rs
@@ -4,23 +4,23 @@ use sqlx::{SqliteConnection, Transaction, sqlite::Sqlite};
 use crate::{
     clock::DateTime,
     event::{Instant, Sequence},
-    login::{History, Id, Login, password::StoredHash},
     name::{self, Name},
+    user::{History, Id, User, password::StoredHash},
 };
 
 pub trait Provider {
-    fn logins(&mut self) -> Logins;
+    fn users(&mut self) -> Users;
 }
 
 impl Provider for Transaction<'_, Sqlite> {
-    fn logins(&mut self) -> Logins {
-        Logins(self)
+    fn users(&mut self) -> Users {
+        Users(self)
     }
 }
 
-pub struct Logins<'t>(&'t mut SqliteConnection);
+pub struct Users<'t>(&'t mut SqliteConnection);
 
-impl Logins<'_> {
+impl Users<'_> {
     pub async fn create(
         &mut self,
         name: &Name,
@@ -47,15 +47,15 @@ impl Logins<'_> {
         .execute(&mut *self.0)
         .await?;
 
-        let login = History {
+        let user = History {
             created: *created,
-            login: Login {
+            user: User {
                 id,
                 name: name.clone(),
             },
         };
 
-        Ok(login)
+        Ok(user)
     }
 
     pub async fn set_password(
@@ -98,7 +98,7 @@ impl Logins<'_> {
         )
         .map(|row| {
             Ok::<_, LoadError>(History {
-                login: Login {
+                user: User {
                     id: row.id,
                     name: Name::new(row.display_name, row.canonical_name)?,
                 },
@@ -129,7 +129,7 @@ impl Logins<'_> {
         )
         .map(|row| {
             Ok::<_, name::Error>(History {
-                login: Login {
+                user: User {
                     id: row.id,
                     name: Name::new(row.display_name, row.canonical_name)?,
                 },
diff --git a/src/login/routes/login/mod.rs b/src/user/routes/login/mod.rs
index 36b384e..36b384e 100644
--- a/src/login/routes/login/mod.rs
+++ b/src/user/routes/login/mod.rs
diff --git a/src/login/routes/login/post.rs b/src/user/routes/login/post.rs
index 96da5c5..39f9eea 100644
--- a/src/login/routes/login/post.rs
+++ b/src/user/routes/login/post.rs
@@ -8,9 +8,9 @@ use crate::{
     app::App,
     clock::RequestedAt,
     error::Internal,
-    login::{Login, Password},
     name::Name,
     token::{app, extract::IdentityCookie},
+    user::{Password, User},
 };
 
 pub async fn handler(
@@ -18,14 +18,14 @@ pub async fn handler(
     RequestedAt(now): RequestedAt,
     identity: IdentityCookie,
     Json(request): Json<Request>,
-) -> Result<(IdentityCookie, Json<Login>), Error> {
-    let (login, secret) = app
+) -> Result<(IdentityCookie, Json<User>), Error> {
+    let (user, secret) = app
         .tokens()
         .login(&request.name, &request.password, &now)
         .await
         .map_err(Error)?;
     let identity = identity.set(secret);
-    Ok((identity, Json(login)))
+    Ok((identity, Json(user)))
 }
 
 #[derive(serde::Deserialize)]
diff --git a/src/login/routes/login/test.rs b/src/user/routes/login/test.rs
index 7399796..7399796 100644
--- a/src/login/routes/login/test.rs
+++ b/src/user/routes/login/test.rs
diff --git a/src/login/routes/logout/mod.rs b/src/user/routes/logout/mod.rs
index 36b384e..36b384e 100644
--- a/src/login/routes/logout/mod.rs
+++ b/src/user/routes/logout/mod.rs
diff --git a/src/login/routes/logout/post.rs b/src/user/routes/logout/post.rs
index bb09b9f..bb09b9f 100644
--- a/src/login/routes/logout/post.rs
+++ b/src/user/routes/logout/post.rs
diff --git a/src/login/routes/logout/test.rs b/src/user/routes/logout/test.rs
index 775fa9f..775fa9f 100644
--- a/src/login/routes/logout/test.rs
+++ b/src/user/routes/logout/test.rs
diff --git a/src/login/routes/mod.rs b/src/user/routes/mod.rs
index ade96cb..ade96cb 100644
--- a/src/login/routes/mod.rs
+++ b/src/user/routes/mod.rs
diff --git a/src/login/routes/password/mod.rs b/src/user/routes/password/mod.rs
index 36b384e..36b384e 100644
--- a/src/login/routes/password/mod.rs
+++ b/src/user/routes/password/mod.rs
diff --git a/src/login/routes/password/post.rs b/src/user/routes/password/post.rs
index 4723754..296f6cd 100644
--- a/src/login/routes/password/post.rs
+++ b/src/user/routes/password/post.rs
@@ -8,11 +8,11 @@ use crate::{
     app::App,
     clock::RequestedAt,
     error::Internal,
-    login::{Login, Password},
     token::{
         app,
         extract::{Identity, IdentityCookie},
     },
+    user::{Password, User},
 };
 
 pub async fn handler(
@@ -21,10 +21,10 @@ pub async fn handler(
     identity: Identity,
     cookie: IdentityCookie,
     Json(request): Json<Request>,
-) -> Result<(IdentityCookie, Json<Login>), Error> {
+) -> Result<(IdentityCookie, Json<User>), Error> {
     let (login, secret) = app
         .tokens()
-        .change_password(&identity.login, &request.password, &request.to, &now)
+        .change_password(&identity.user, &request.password, &request.to, &now)
         .await
         .map_err(Error)?;
     let cookie = cookie.set(secret);
diff --git a/src/login/routes/password/test.rs b/src/user/routes/password/test.rs
index c1974bf..01dcb38 100644
--- a/src/login/routes/password/test.rs
+++ b/src/user/routes/password/test.rs
@@ -35,7 +35,7 @@ async fn password_change() {
     assert_ne!(cookie.secret(), new_cookie.secret());
 
     // Verify that we're still ourselves
-    assert_eq!(identity.login, response);
+    assert_eq!(identity.user, response);
 
     // Verify that our original token is no longer valid
     let validate_err = app
@@ -64,5 +64,5 @@ async fn password_change() {
         .login(&name, &to, &fixtures::now())
         .await
         .expect("logging in with the new password should succeed");
-    assert_eq!(identity.login, login);
+    assert_eq!(identity.user, login);
 }
diff --git a/src/login/snapshot.rs b/src/user/snapshot.rs
index 5c5dce0..d548e06 100644
--- a/src/login/snapshot.rs
+++ b/src/user/snapshot.rs
@@ -5,11 +5,11 @@ use super::{
 use crate::name::Name;
 
 // This also implements FromRequestParts (see `./extract.rs`). As a result, it
-// can be used as an extractor for endpoints that want to require login, or for
+// can be used as an extractor for endpoints that want to require a user, or for
 // endpoints that need to behave differently depending on whether the client is
 // or is not logged in.
 #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
-pub struct Login {
+pub struct User {
     pub id: Id,
     pub name: Name,
     // The omission of the hashed password is deliberate, to minimize the
@@ -17,8 +17,9 @@ pub struct Login {
     // of logic elsewhere.
 }
 
-impl Login {
-    // Two reasons for this allow:
+impl User {
+    // Without this allow, clippy wants the `Option<Self>` return type to be `Self`. It's not a bad
+    // suggestion, but we need `Option` here, for two reasons:
     //
     // 1. This is used to collect streams using a fold, below, which requires a type
     //    consistent with the fold, and
@@ -32,20 +33,20 @@ impl Login {
     }
 }
 
-impl FromIterator<Event> for Option<Login> {
+impl FromIterator<Event> for Option<User> {
     fn from_iter<I: IntoIterator<Item = Event>>(events: I) -> Self {
-        events.into_iter().fold(None, Login::apply)
+        events.into_iter().fold(None, User::apply)
     }
 }
 
-impl From<&Created> for Login {
+impl From<&Created> for User {
     fn from(event: &Created) -> Self {
-        event.login.clone()
+        event.user.clone()
     }
 }
 
-impl From<Created> for Login {
+impl From<Created> for User {
     fn from(event: Created) -> Self {
-        event.login
+        event.user
     }
 }
diff --git a/src/login/validate.rs b/src/user/validate.rs
index 0c97293..0c97293 100644
--- a/src/login/validate.rs
+++ b/src/user/validate.rs