Merge branch 'prop/rename-login-to-user'

65 files changed, 315 insertions, 313 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..f531afe 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,15 +22,15 @@ 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 users = tx.users().all(resume_point).await?;
         let channels = tx.channels().all(resume_point).await?;
         let messages = tx.messages().all(resume_point).await?;
 
         tx.commit().await?;
 
-        let logins = logins
+        let users = users
             .into_iter()
-            .filter_map(|login| login.as_of(resume_point))
+            .filter_map(|user| user.as_of(resume_point))
             .collect();
 
         let channels = channels
@@ -45,7 +45,7 @@ impl<'a> Boot<'a> {
 
         Ok(Snapshot {
             resume_point,
-            logins,
+            users,
             channels,
             messages,
         })
@@ -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..c52b088 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 users: 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..4873b7a 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,
+        user: identity.user,
         snapshot,
     })
 }
 
 #[derive(serde::Serialize)]
 pub struct Response {
-    pub login: Login,
+    pub user: User,
     #[serde(flatten)]
     pub snapshot: Snapshot,
 }
diff --git a/src/boot/routes/test.rs b/src/boot/routes/test.rs
index 202dcb9..55802fe 100644
--- a/src/boot/routes/test.rs
+++ b/src/boot/routes/test.rs
@@ -12,20 +12,20 @@ async fn returns_identity() {
         .await
         .expect("boot always succeeds");
 
-    assert_eq!(viewer.login, response.login);
+    assert_eq!(viewer.user, response.user);
 }
 
 #[tokio::test]
 async fn includes_logins() {
     let app = fixtures::scratch_app().await;
-    let spectator = fixtures::login::create(&app, &fixtures::now()).await;
+    let spectator = fixtures::user::create(&app, &fixtures::now()).await;
 
     let viewer = fixtures::identity::fictitious();
     let response = get::handler(State(app), viewer)
         .await
         .expect("boot always succeeds");
 
-    assert!(response.snapshot.logins.contains(&spectator));
+    assert!(response.snapshot.users.contains(&spectator));
 }
 
 #[tokio::test]
@@ -44,7 +44,7 @@ async fn includes_channels() {
 #[tokio::test]
 async fn includes_messages() {
     let app = fixtures::scratch_app().await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
     let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
 
@@ -59,7 +59,7 @@ async fn includes_messages() {
 #[tokio::test]
 async fn excludes_expired_messages() {
     let app = fixtures::scratch_app().await;
-    let sender = fixtures::login::create(&app, &fixtures::ancient()).await;
+    let sender = fixtures::user::create(&app, &fixtures::ancient()).await;
     let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
     let expired_message =
         fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await;
@@ -80,7 +80,7 @@ async fn excludes_expired_messages() {
 #[tokio::test]
 async fn excludes_deleted_messages() {
     let app = fixtures::scratch_app().await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
     let deleted_message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
 
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/delete.rs b/src/channel/routes/channel/test/delete.rs
index 77a0b03..bd9261d 100644
--- a/src/channel/routes/channel/test/delete.rs
+++ b/src/channel/routes/channel/test/delete.rs
@@ -156,7 +156,7 @@ pub async fn channel_not_empty() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
 
     // Send the request
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..45a9099 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 login_events = logins
+        let users = tx.users().replay(resume_at).await?;
+        let user_events = users
             .iter()
-            .map(login::History::events)
+            .map(user::History::events)
             .kmerge_by(Sequence::merge)
             .filter(Sequence::after(resume_at))
             .map(Event::from);
@@ -57,7 +57,7 @@ impl<'a> Events<'a> {
             .filter(Sequence::after(resume_at))
             .map(Event::from);
 
-        let replay_events = login_events
+        let replay_events = user_events
             .merge_by(channel_events, Sequence::merge)
             .merge_by(message_events, Sequence::merge)
             .collect::<Vec<_>>();
@@ -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..3ab88ec 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),
+    User(user::Event),
     Channel(channel::Event),
     Message(message::Event),
 }
@@ -24,16 +24,16 @@ pub enum Event {
 impl Sequenced for Event {
     fn instant(&self) -> Instant {
         match self {
-            Self::Login(event) => event.instant(),
+            Self::User(event) => event.instant(),
             Self::Channel(event) => event.instant(),
             Self::Message(event) => event.instant(),
         }
     }
 }
 
-impl From<login::Event> for Event {
-    fn from(event: login::Event) -> Self {
-        Self::Login(event)
+impl From<user::Event> for Event {
+    fn from(event: user::Event) -> Self {
+        Self::User(event)
     }
 }
 
diff --git a/src/event/routes/test/invite.rs b/src/event/routes/test/invite.rs
index 73af62d..1d1bec6 100644
--- a/src/event/routes/test/invite.rs
+++ b/src/event/routes/test/invite.rs
@@ -12,7 +12,7 @@ async fn accepting_invite() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let issuer = fixtures::login::create(&app, &fixtures::now()).await;
+    let issuer = fixtures::user::create(&app, &fixtures::now()).await;
     let invite = fixtures::invite::issue(&app, &issuer, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
@@ -30,7 +30,7 @@ async fn accepting_invite() {
 
     // Accept the invite
 
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     let (joiner, _) = app
         .invites()
         .accept(&invite.id, &name, &password, &fixtures::now())
@@ -40,9 +40,9 @@ async fn accepting_invite() {
     // Expect a login created event
 
     let _ = events
-        .filter_map(fixtures::event::login)
-        .filter_map(fixtures::event::login::created)
-        .filter(|event| future::ready(event.login == joiner))
+        .filter_map(fixtures::event::user)
+        .filter_map(fixtures::event::user::created)
+        .filter(|event| future::ready(event.user == joiner))
         .next()
         .expect_some("a login created event is sent")
         .await;
@@ -53,13 +53,13 @@ async fn previously_accepted_invite() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let issuer = fixtures::login::create(&app, &fixtures::now()).await;
+    let issuer = fixtures::user::create(&app, &fixtures::now()).await;
     let invite = fixtures::invite::issue(&app, &issuer, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Accept the invite
 
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     let (joiner, _) = app
         .invites()
         .accept(&invite.id, &name, &password, &fixtures::now())
@@ -81,9 +81,9 @@ async fn previously_accepted_invite() {
     // Expect a login created event
 
     let _ = events
-        .filter_map(fixtures::event::login)
-        .filter_map(fixtures::event::login::created)
-        .filter(|event| future::ready(event.login == joiner))
+        .filter_map(fixtures::event::user)
+        .filter_map(fixtures::event::user::created)
+        .filter(|event| future::ready(event.user == joiner))
         .next()
         .expect_some("a login created event is sent")
         .await;
diff --git a/src/event/routes/test/message.rs b/src/event/routes/test/message.rs
index fafaeb3..84a3aec 100644
--- a/src/event/routes/test/message.rs
+++ b/src/event/routes/test/message.rs
@@ -32,7 +32,7 @@ async fn sending() {
 
     // Send a message
 
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let message = app
         .messages()
         .send(
@@ -65,7 +65,7 @@ async fn previously_sent() {
 
     // Send a message
 
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let message = app
         .messages()
         .send(
@@ -105,7 +105,7 @@ async fn sent_in_multiple_channels() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     let channels = [
@@ -156,7 +156,7 @@ async fn sent_sequentially() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     let messages = vec![
@@ -200,7 +200,7 @@ async fn expiring() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
-    let sender = fixtures::login::create(&app, &fixtures::ancient()).await;
+    let sender = fixtures::user::create(&app, &fixtures::ancient()).await;
     let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
@@ -239,7 +239,7 @@ async fn previously_expired() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
-    let sender = fixtures::login::create(&app, &fixtures::ancient()).await;
+    let sender = fixtures::user::create(&app, &fixtures::ancient()).await;
     let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
@@ -278,7 +278,7 @@ async fn deleting() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
@@ -317,7 +317,7 @@ async fn previously_deleted() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
@@ -356,7 +356,7 @@ async fn previously_purged() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
-    let sender = fixtures::login::create(&app, &fixtures::ancient()).await;
+    let sender = fixtures::user::create(&app, &fixtures::ancient()).await;
     let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
diff --git a/src/event/routes/test/resume.rs b/src/event/routes/test/resume.rs
index dc27691..633eae3 100644
--- a/src/event/routes/test/resume.rs
+++ b/src/event/routes/test/resume.rs
@@ -15,7 +15,7 @@ async fn resume() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     let initial_message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
@@ -96,7 +96,7 @@ async fn serial_resume() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let channel_a = fixtures::channel::create(&app, &fixtures::now()).await;
     let channel_b = fixtures::channel::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
diff --git a/src/event/routes/test/setup.rs b/src/event/routes/test/setup.rs
index 26b7ea7..1170fe4 100644
--- a/src/event/routes/test/setup.rs
+++ b/src/event/routes/test/setup.rs
@@ -19,7 +19,7 @@ async fn previously_completed() {
 
     // Complete initial setup
 
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     let (owner, _) = app
         .setup()
         .initial(&name, &password, &fixtures::now())
@@ -41,9 +41,9 @@ async fn previously_completed() {
     // Expect a login created event
 
     let _ = events
-        .filter_map(fixtures::event::login)
-        .filter_map(fixtures::event::login::created)
-        .filter(|event| future::ready(event.login == owner))
+        .filter_map(fixtures::event::user)
+        .filter_map(fixtures::event::user::created)
+        .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..a467de5 100644
--- a/src/event/routes/test/token.rs
+++ b/src/event/routes/test/token.rs
@@ -13,12 +13,12 @@ async fn terminates_on_token_expiry() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Subscribe via the endpoint
 
-    let subscriber_creds = fixtures::login::create_with_password(&app, &fixtures::now()).await;
+    let subscriber_creds = fixtures::user::create_with_password(&app, &fixtures::now()).await;
     let subscriber =
         fixtures::identity::logged_in(&app, &subscriber_creds, &fixtures::ancient()).await;
 
@@ -60,7 +60,7 @@ async fn terminates_on_logout() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Subscribe via the endpoint
@@ -106,12 +106,12 @@ async fn terminates_on_password_change() {
 
     let app = fixtures::scratch_app().await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Subscribe via the endpoint
 
-    let creds = fixtures::login::create_with_password(&app, &fixtures::now()).await;
+    let creds = fixtures::user::create_with_password(&app, &fixtures::now()).await;
     let cookie = fixtures::cookie::logged_in(&app, &creds, &fixtures::now()).await;
     let subscriber = fixtures::identity::from_cookie(&app, &cookie, &fixtures::now()).await;
 
@@ -127,9 +127,9 @@ async fn terminates_on_password_change() {
     // Verify the resulting stream's behaviour
 
     let (_, password) = creds;
-    let to = fixtures::login::propose_password();
+    let to = fixtures::user::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 c1dc701..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,11 +70,11 @@ 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
-                join login as issuer on (invite.issuer = issuer.id)
+                join user as issuer on (invite.issuer = issuer.id)
                 where invite.id = $1
             "#,
             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/get.rs b/src/invite/routes/invite/test/get.rs
index c6780ed..0dc8a79 100644
--- a/src/invite/routes/invite/test/get.rs
+++ b/src/invite/routes/invite/test/get.rs
@@ -7,7 +7,7 @@ async fn valid_invite() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let issuer = fixtures::login::create(&app, &fixtures::now()).await;
+    let issuer = fixtures::user::create(&app, &fixtures::now()).await;
     let invite = fixtures::invite::issue(&app, &issuer, &fixtures::now()).await;
 
     // Call endpoint
@@ -45,7 +45,7 @@ async fn expired_invite() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let issuer = fixtures::login::create(&app, &fixtures::ancient()).await;
+    let issuer = fixtures::user::create(&app, &fixtures::ancient()).await;
     let invite = fixtures::invite::issue(&app, &issuer, &fixtures::ancient()).await;
 
     app.invites()
diff --git a/src/invite/routes/invite/test/post.rs b/src/invite/routes/invite/test/post.rs
index 40e0580..b204b32 100644
--- a/src/invite/routes/invite/test/post.rs
+++ b/src/invite/routes/invite/test/post.rs
@@ -11,12 +11,12 @@ async fn valid_invite() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let issuer = fixtures::login::create(&app, &fixtures::now()).await;
+    let issuer = fixtures::user::create(&app, &fixtures::now()).await;
     let invite = fixtures::invite::issue(&app, &issuer, &fixtures::now()).await;
 
     // Call the endpoint
 
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     let identity = fixtures::cookie::not_logged_in();
     let request = post::Request {
         name: name.clone(),
@@ -68,7 +68,7 @@ async fn nonexistent_invite() {
 
     // Call the endpoint
 
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     let identity = fixtures::cookie::not_logged_in();
     let request = post::Request {
         name: name.clone(),
@@ -94,7 +94,7 @@ async fn expired_invite() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let issuer = fixtures::login::create(&app, &fixtures::ancient()).await;
+    let issuer = fixtures::user::create(&app, &fixtures::ancient()).await;
     let invite = fixtures::invite::issue(&app, &issuer, &fixtures::ancient()).await;
 
     app.invites()
@@ -104,7 +104,7 @@ async fn expired_invite() {
 
     // Call the endpoint
 
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     let identity = fixtures::cookie::not_logged_in();
     let request = post::Request {
         name: name.clone(),
@@ -130,10 +130,10 @@ async fn accepted_invite() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let issuer = fixtures::login::create(&app, &fixtures::ancient()).await;
+    let issuer = fixtures::user::create(&app, &fixtures::ancient()).await;
     let invite = fixtures::invite::issue(&app, &issuer, &fixtures::ancient()).await;
 
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     app.invites()
         .accept(&invite.id, &name, &password, &fixtures::now())
         .await
@@ -141,7 +141,7 @@ async fn accepted_invite() {
 
     // Call the endpoint
 
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     let identity = fixtures::cookie::not_logged_in();
     let request = post::Request {
         name: name.clone(),
@@ -167,23 +167,23 @@ async fn conflicting_name() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let issuer = fixtures::login::create(&app, &fixtures::ancient()).await;
+    let issuer = fixtures::user::create(&app, &fixtures::ancient()).await;
     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::user::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
 
     let conflicting_name = Name::from("r\u{0133}ksmuseum");
-    let password = fixtures::login::propose_password();
+    let password = fixtures::user::propose_password();
 
     let identity = fixtures::cookie::not_logged_in();
     let request = post::Request {
@@ -212,13 +212,13 @@ async fn invalid_name() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let issuer = fixtures::login::create(&app, &fixtures::now()).await;
+    let issuer = fixtures::user::create(&app, &fixtures::now()).await;
     let invite = fixtures::invite::issue(&app, &issuer, &fixtures::now()).await;
 
     // Call the endpoint
 
-    let name = fixtures::login::propose_invalid_name();
-    let password = fixtures::login::propose_password();
+    let name = fixtures::user::propose_invalid_name();
+    let password = fixtures::user::propose_password();
     let identity = fixtures::cookie::not_logged_in();
     let request = post::Request {
         name: name.clone(),
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..1888be7 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
 
@@ -62,7 +62,7 @@ pub async fn delete_deleted() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
     let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
 
@@ -93,7 +93,7 @@ pub async fn delete_expired() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let sender = fixtures::login::create(&app, &fixtures::ancient()).await;
+    let sender = fixtures::user::create(&app, &fixtures::ancient()).await;
     let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
     let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await;
 
@@ -124,7 +124,7 @@ pub async fn delete_purged() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let sender = fixtures::login::create(&app, &fixtures::ancient()).await;
+    let sender = fixtures::user::create(&app, &fixtures::ancient()).await;
     let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
     let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await;
 
@@ -160,7 +160,7 @@ pub async fn delete_not_sender() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let sender = fixtures::login::create(&app, &fixtures::now()).await;
+    let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let channel = fixtures::channel::create(&app, &fixtures::now()).await;
     let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
 
@@ -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..26eed7a 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,12 +38,12 @@ 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);
+        let user = stored.publish(self.events);
 
-        Ok((login.as_created(), secret))
+        Ok((user.as_created(), secret))
     }
 
     pub async fn completed(&self) -> Result<bool, sqlx::Error> {
@@ -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/repo.rs b/src/setup/repo.rs
index ac01496..c4f5fd8 100644
--- a/src/setup/repo.rs
+++ b/src/setup/repo.rs
@@ -17,7 +17,7 @@ impl Setup<'_> {
         let completed = sqlx::query_scalar!(
             r#"
                 select count(*) > 0 as "completed: bool"
-                from login
+                from user
             "#,
         )
         .fetch_one(&mut *self.0)
diff --git a/src/setup/routes/post.rs b/src/setup/routes/post.rs
index 2a46b04..0ff5d69 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,14 +19,14 @@ pub async fn handler(
     RequestedAt(setup_at): 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
         .setup()
         .initial(&request.name, &request.password, &setup_at)
         .await
         .map_err(Error)?;
     let identity = identity.set(secret);
-    Ok((identity, Json(login)))
+    Ok((identity, Json(user)))
 }
 
 #[derive(serde::Deserialize)]
diff --git a/src/setup/routes/test.rs b/src/setup/routes/test.rs
index 5794b78..e9f5cd6 100644
--- a/src/setup/routes/test.rs
+++ b/src/setup/routes/test.rs
@@ -11,7 +11,7 @@ async fn fresh_instance() {
 
     // Call the endpoint
     let identity = fixtures::cookie::not_logged_in();
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     let request = post::Request {
         name: name.clone(),
         password: password.clone(),
@@ -52,11 +52,11 @@ async fn login_exists() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    fixtures::login::create(&app, &fixtures::now()).await;
+    fixtures::user::create(&app, &fixtures::now()).await;
 
     // Call the endpoint
     let identity = fixtures::cookie::not_logged_in();
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     let request = post::Request { name, password };
     let post::Error(error) =
         post::handler(State(app.clone()), fixtures::now(), identity, Json(request))
@@ -76,8 +76,8 @@ async fn invalid_name() {
 
     // Call the endpoint
 
-    let name = fixtures::login::propose_invalid_name();
-    let password = fixtures::login::propose_password();
+    let name = fixtures::user::propose_invalid_name();
+    let password = fixtures::user::propose_password();
     let identity = fixtures::cookie::not_logged_in();
     let request = post::Request {
         name: name.clone(),
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..a30bb4b 100644
--- a/src/test/fixtures/event.rs
+++ b/src/test/fixtures/event.rs
@@ -16,9 +16,9 @@ pub fn message(event: Event) -> Ready<Option<message::Event>> {
     })
 }
 
-pub fn login(event: Event) -> Ready<Option<login::Event>> {
+pub fn user(event: Event) -> Ready<Option<user::Event>> {
     future::ready(match event {
-        Event::Login(event) => Some(event),
+        Event::User(event) => Some(event),
         _ => None,
     })
 }
@@ -65,11 +65,11 @@ pub mod message {
     }
 }
 
-pub mod login {
+pub mod user {
     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..cb325d8 100644
--- a/src/test/fixtures/identity.rs
+++ b/src/test/fixtures/identity.rs
@@ -1,17 +1,17 @@
 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 {
-    let credentials = fixtures::login::create_with_password(app, created_at).await;
+    let credentials = fixtures::user::create_with_password(app, created_at).await;
     logged_in(app, &credentials, created_at).await
 }
 
@@ -21,13 +21,13 @@ pub async fn from_cookie(
     validated_at: &RequestedAt,
 ) -> Identity {
     let secret = cookie.secret().expect("identity token has a secret");
-    let (token, login) = app
+    let (token, user) = app
         .tokens()
         .validate(&secret, validated_at)
         .await
         .expect("always validates newly-issued secret");
 
-    Identity { token, login }
+    Identity { token, user }
 }
 
 pub async fn logged_in(
@@ -41,7 +41,7 @@ pub async fn logged_in(
 
 pub fn fictitious() -> Identity {
     let token = token::Id::generate();
-    let login = fixtures::login::fictitious();
+    let user = fixtures::user::fictitious();
 
-    Identity { token, login }
+    Identity { token, user }
 }
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/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/test/fixtures/mod.rs b/src/test/fixtures/mod.rs
index 57eee30..418bdb5 100644
--- a/src/test/fixtures/mod.rs
+++ b/src/test/fixtures/mod.rs
@@ -9,8 +9,8 @@ pub mod event;
 pub mod future;
 pub mod identity;
 pub mod invite;
-pub mod login;
 pub mod message;
+pub mod user;
 
 pub async fn scratch_app() -> App {
     let pool = db::prepare("sqlite::memory:", "sqlite::memory:")
diff --git a/src/test/fixtures/login.rs b/src/test/fixtures/user.rs
index 86e3e39..6448f64 100644
--- a/src/test/fixtures/login.rs
+++ b/src/test/fixtures/user.rs
@@ -4,32 +4,32 @@ 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()
+    let user = app
+        .users()
         .create(&name, &password, created_at)
         .await
         .expect("should always succeed if the login is actually new");
 
-    (login.name, password)
+    (user.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/token/app.rs b/src/token/app.rs
index 3f054ff..46b2d73 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,9 +31,9 @@ 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
+        let (user, stored_hash) = tx
             .auth()
             .for_name(name)
             .await
@@ -46,11 +46,11 @@ impl<'a> Tokens<'a> {
         // if the account is deleted during that time.
         tx.commit().await?;
 
-        let snapshot = login.as_snapshot().ok_or(LoginError::Rejected)?;
+        let snapshot = user.as_snapshot().ok_or(LoginError::Rejected)?;
 
         let token = if stored_hash.verify(password)? {
             let mut tx = self.db.begin().await?;
-            let token = tx.tokens().issue(&login, login_at).await?;
+            let token = tx.tokens().issue(&user, login_at).await?;
             tx.commit().await?;
             token
         } else {
@@ -62,15 +62,15 @@ impl<'a> Tokens<'a> {
 
     pub async fn change_password(
         &self,
-        login: &Login,
+        user: &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
+        let (user, stored_hash) = tx
             .auth()
-            .for_login(login)
+            .for_user(user)
             .await
             .optional()?
             .ok_or(LoginError::Rejected)?;
@@ -85,13 +85,13 @@ impl<'a> Tokens<'a> {
             return Err(LoginError::Rejected);
         }
 
-        let snapshot = login.as_snapshot().ok_or(LoginError::Rejected)?;
+        let snapshot = user.as_snapshot().ok_or(LoginError::Rejected)?;
         let to_hash = to.hash()?;
 
         let mut tx = self.db.begin().await?;
-        let tokens = tx.tokens().revoke_all(&login).await?;
-        tx.logins().set_password(&login, &to_hash).await?;
-        let secret = tx.tokens().issue(&login, changed_at).await?;
+        let tokens = tx.tokens().revoke_all(&user).await?;
+        tx.users().set_password(&user, &to_hash).await?;
+        let secret = tx.tokens().issue(&user, changed_at).await?;
         tx.commit().await?;
 
         for event in tokens.into_iter().map(TokenEvent::Revoked) {
@@ -105,18 +105,18 @@ 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
+        let (token, user) = tx
             .tokens()
             .validate(secret, used_at)
             .await
             .not_found(|| ValidateError::InvalidToken)?;
         tx.commit().await?;
 
-        let login = login.as_snapshot().ok_or(ValidateError::LoginDeleted)?;
+        let user = user.as_snapshot().ok_or(ValidateError::LoginDeleted)?;
 
-        Ok((token, login))
+        Ok((token, user))
     }
 
     pub async fn limit_stream<S, E>(
@@ -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 0deed10..68a81c7 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,13 +26,13 @@ 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",
                     created_at as "created_at: DateTime",
                     password_hash as "password_hash: StoredHash"
-                from login
+                from user
                 where canonical_name = $1
             "#,
             name,
@@ -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,33 +51,33 @@ impl Auth<'_> {
         Ok((login, row.password_hash))
     }
 
-    pub async fn for_login(&mut self, login: &Login) -> Result<(History, StoredHash), LoadError> {
+    pub async fn for_user(&mut self, user: &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",
                     created_at as "created_at: DateTime",
                     password_hash as "password_hash: StoredHash"
-                from login
+                from user
                 where id = $1
             "#,
-            login.id,
+            user.id,
         )
         .fetch_one(&mut *self.0)
         .await?;
 
-        let login = History {
-            login: Login {
+        let user = History {
+            user: User {
                 id: row.id,
                 name: Name::new(row.display_name, row.canonical_name)?,
             },
             created: Instant::new(row.created_at, row.created_sequence),
         };
 
-        Ok((login, row.password_hash))
+        Ok((user, row.password_hash))
     }
 }
 
diff --git a/src/token/repo/token.rs b/src/token/repo/token.rs
index ff42fad..e49c2d4 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 {
@@ -27,23 +27,23 @@ impl Tokens<'_> {
     // be used to control expiry, until the token is actually used.
     pub async fn issue(
         &mut self,
-        login: &History,
+        user: &History,
         issued_at: &DateTime,
     ) -> Result<Secret, sqlx::Error> {
         let id = Id::generate();
         let secret = Uuid::new_v4().to_string();
-        let login = login.id();
+        let user = user.id();
 
         let secret = sqlx::query_scalar!(
             r#"
                 insert
-                into token (id, secret, login, issued_at, last_used_at)
+                into token (id, secret, user, issued_at, last_used_at)
                 values ($1, $2, $3, $4, $4)
                 returning secret as "secret!: Secret"
             "#,
             id,
             secret,
-            login,
+            user,
             issued_at,
         )
         .fetch_one(&mut *self.0)
@@ -85,16 +85,16 @@ impl Tokens<'_> {
     }
 
     // Revoke tokens for a login
-    pub async fn revoke_all(&mut self, login: &login::History) -> Result<Vec<Id>, sqlx::Error> {
-        let login = login.id();
+    pub async fn revoke_all(&mut self, user: &user::History) -> Result<Vec<Id>, sqlx::Error> {
+        let user = user.id();
         let tokens = sqlx::query_scalar!(
             r#"
                 delete
                 from token
-                where login = $1
+                where user = $1
                 returning id as "id: Id"
             "#,
-            login,
+            user,
         )
         .fetch_all(&mut *self.0)
         .await?;
@@ -132,38 +132,38 @@ impl Tokens<'_> {
         // sqlite3, as of this writing, does not allow an update's `returning`
         // clause to reference columns from tables joined into the update. Two
         // queries is fine, but it feels untidy.
-        let (token, login) = sqlx::query!(
+        let (token, user) = sqlx::query!(
             r#"
                 update token
                 set last_used_at = $1
                 where secret = $2
                 returning
                     id as "token: Id",
-                    login as "login: login::Id"
+                    user as "user: user::Id"
             "#,
             used_at,
             secret,
         )
-        .map(|row| (row.token, row.login))
+        .map(|row| (row.token, row.user))
         .fetch_one(&mut *self.0)
         .await?;
 
-        let login = sqlx::query!(
+        let user = 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",
                     created_at as "created_at: DateTime"
-                from login
+                from user
                 where id = $1
             "#,
-            login,
+            user,
         )
         .map(|row| {
             Ok::<_, name::Error>(History {
-                login: Login {
+                user: User {
                     id: row.id,
                     name: Name::new(row.display_name, row.canonical_name)?,
                 },
@@ -173,7 +173,7 @@ impl Tokens<'_> {
         .fetch_one(&mut *self.0)
         .await??;
 
-        Ok((token, login))
+        Ok((token, user))
     }
 }
 
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..bc14c1f 100644
--- a/src/login/id.rs
+++ b/src/user/id.rs
@@ -1,6 +1,7 @@
 use crate::id::Id as BaseId;
 
-// Stable identifier for a [Login]. Prefixed with `L`.
+// Stable identifier for a User. Prefixed with `U`. Users created before March, 2025 may have an `L`
+// prefix, instead.
 #[derive(Clone, Debug, Eq, PartialEq, sqlx::Type, serde::Serialize)]
 #[sqlx(transparent)]
 pub struct Id(BaseId);
@@ -13,7 +14,7 @@ impl From<BaseId> for Id {
 
 impl Id {
     pub fn generate() -> Self {
-        BaseId::generate("L")
+        BaseId::generate("U")
     }
 }
 
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 03f2c17..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,
@@ -34,7 +34,7 @@ impl Logins<'_> {
         sqlx::query!(
             r#"
                 insert
-                into login (id, display_name, canonical_name, password_hash, created_sequence, created_at)
+                into user (id, display_name, canonical_name, password_hash, created_sequence, created_at)
                 values ($1, $2, $3, $4, $5, $6)
             "#,
             id,
@@ -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(
@@ -67,7 +67,7 @@ impl Logins<'_> {
 
         sqlx::query_scalar!(
             r#"
-                update login
+                update user
                 set password_hash = $1
                 where id = $2
                 returning id as "id: Id"
@@ -90,7 +90,7 @@ impl Logins<'_> {
                     canonical_name as "canonical_name: String",
                     created_sequence as "created_sequence: Sequence",
                     created_at as "created_at: DateTime"
-                from login
+                from user
                     where created_sequence <= $1
                     order by canonical_name
             "#,
@@ -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)?,
                 },
@@ -122,14 +122,14 @@ impl Logins<'_> {
                     canonical_name as "canonical_name: String",
                     created_sequence as "created_sequence: Sequence",
                     created_at as "created_at: DateTime"
-                from login
-                where login.created_sequence > $1
+                from user
+                where created_sequence > $1
             "#,
             resume_at,
         )
         .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..d2e7ee2 100644
--- a/src/login/routes/login/test.rs
+++ b/src/user/routes/login/test.rs
@@ -8,7 +8,7 @@ async fn correct_credentials() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let (name, password) = fixtures::login::create_with_password(&app, &fixtures::now()).await;
+    let (name, password) = fixtures::user::create_with_password(&app, &fixtures::now()).await;
 
     // Call the endpoint
 
@@ -52,7 +52,7 @@ async fn invalid_name() {
 
     let identity = fixtures::cookie::not_logged_in();
     let logged_in_at = fixtures::now();
-    let (name, password) = fixtures::login::propose();
+    let (name, password) = fixtures::user::propose();
     let request = post::Request {
         name: name.clone(),
         password,
@@ -72,7 +72,7 @@ async fn incorrect_password() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let login = fixtures::login::create(&app, &fixtures::now()).await;
+    let login = fixtures::user::create(&app, &fixtures::now()).await;
 
     // Call the endpoint
 
@@ -80,7 +80,7 @@ async fn incorrect_password() {
     let identity = fixtures::cookie::not_logged_in();
     let request = post::Request {
         name: login.name,
-        password: fixtures::login::propose_password(),
+        password: fixtures::user::propose_password(),
     };
     let post::Error(error) =
         post::handler(State(app.clone()), logged_in_at, identity, Json(request))
@@ -97,7 +97,7 @@ async fn token_expires() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let (name, password) = fixtures::login::create_with_password(&app, &fixtures::now()).await;
+    let (name, password) = fixtures::user::create_with_password(&app, &fixtures::now()).await;
 
     // Call the endpoint
 
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..ce93760 100644
--- a/src/login/routes/logout/test.rs
+++ b/src/user/routes/logout/test.rs
@@ -12,7 +12,7 @@ async fn successful() {
 
     let app = fixtures::scratch_app().await;
     let now = fixtures::now();
-    let creds = fixtures::login::create_with_password(&app, &fixtures::now()).await;
+    let creds = fixtures::user::create_with_password(&app, &fixtures::now()).await;
     let identity = fixtures::cookie::logged_in(&app, &creds, &now).await;
     let secret = fixtures::cookie::secret(&identity);
 
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..f977327 100644
--- a/src/login/routes/password/test.rs
+++ b/src/user/routes/password/test.rs
@@ -10,13 +10,13 @@ use crate::{
 async fn password_change() {
     // Set up the environment
     let app = fixtures::scratch_app().await;
-    let creds = fixtures::login::create_with_password(&app, &fixtures::now()).await;
+    let creds = fixtures::user::create_with_password(&app, &fixtures::now()).await;
     let cookie = fixtures::cookie::logged_in(&app, &creds, &fixtures::now()).await;
     let identity = fixtures::identity::from_cookie(&app, &cookie, &fixtures::now()).await;
 
     // Call the endpoint
     let (name, password) = creds;
-    let to = fixtures::login::propose_password();
+    let to = fixtures::user::propose_password();
     let request = post::Request {
         password: password.clone(),
         to: to.clone(),
@@ -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