From 611bf7f15366b8a48e8aa032feaa982ce40b9f03 Mon Sep 17 00:00:00 2001
From: "@permadeath.com" <did:plc:nlzmjyfv6loqtxyzvdcznwgf>
Date: Fri, 21 Aug 2026 16:29:13 -0400
Subject: [PATCH] refactor(player-profile)!: a player's page is at /profile

The prefix, the shell, the module and its tests are all named for what the
page is rather than for a plural noun, and the api host's unfurl route moves
with them. infra's viewer function has to be applied before this build is
served.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Change-Id: I2610de1924fd9161d85e3864793181dddca2b9ac
---
 plan/player-profile.md                        | 14 +++---
 services/api/src/atproto/mod.rs               |  2 +-
 services/api/src/routes.rs                    |  6 +--
 services/api/src/unfurl.rs                    | 24 +++++-----
 web/astro.config.mjs                          | 14 +++---
 ...players.test.mjs => profile-page.test.mjs} | 48 +++++++++----------
 web/src/account.ts                            |  4 +-
 web/src/challenge-stash.ts                    |  2 +-
 web/src/destinations.ts                       | 18 +++----
 web/src/identity.ts                           |  2 +-
 .../pages/{players => profile}/index.astro    |  8 ++--
 web/src/{players.ts => profile-page.ts}       | 16 +++----
 12 files changed, 79 insertions(+), 79 deletions(-)
 rename web/scripts/{players.test.mjs => profile-page.test.mjs} (86%)
 rename web/src/pages/{players => profile}/index.astro (78%)
 rename web/src/{players.ts => profile-page.ts} (97%)

diff --git a/plan/player-profile.md b/plan/player-profile.md
index 608ddd4..6b78b63 100644
--- a/plan/player-profile.md
+++ b/plan/player-profile.md
@@ -11,7 +11,7 @@ exitCriterion: >
 
 # player-profile
 
-There is a page now, at `/players/<handle>` and `/players/<did>`, and it is
+There is a page now, at `/profile/<handle>` and `/profile/<did>`, and it is
 the same page for anybody: your own account, an opponent from a lineup, or a
 handle somebody pasted into a post. What is on it is what can be read without
 asking us — the identity, and the camo in the player's own repository — plus
@@ -117,13 +117,13 @@ now, mounted beside the account's and waiting on nothing.
       the page waits for it and a failure shows nothing at all. Both
       directions are read; only "you follow them" is drawn today.
 
-- [x] **A page at a real address**, `/players/<handle-or-did>`, rather than a
+- [x] **A page at a real address**, `/profile/<handle-or-did>`, rather than a
       hash route. A profile is what people link to about each other, so it has
       to be a path a reader can copy out of the bar — and, more than that, an
       address the distribution can route on its own, since that is what lets a
       card fetcher be answered per player without the page running.
 - [x] **One shell, not a page per player.** Astro has no list of players to
-      build from, so `web/src/pages/players/index.astro` is built once and a
+      build from, so `web/src/pages/profile/index.astro` is built once and a
       viewer-request rewrite serves it for every address under the prefix.
       `astro.config.mjs` carries the same rewrite for the dev server, which is
       otherwise the one place a player's page 404s.
@@ -144,8 +144,8 @@ now, mounted beside the account's and waiting on nothing.
       will be earned rather than rated, at which point it goes in the title
       and on the card together.
 - [x] **The address is the handle, with its @ and nothing escaped.**
-      `/players/@alice.example` is an address somebody can read out;
-      `/players/did%3Aplc%3Ah7k...` is one nobody can. Both forms answer, and
+      `/profile/@alice.example` is an address somebody can read out;
+      `/profile/did%3Aplc%3Ah7k...` is one nobody can. Both forms answer, and
       the handle's is what the site writes, what the canonical link names and
       what a card advertises as its own. The DID form covers the case the
       handle cannot - an account with no handle anybody can confirm - and a
@@ -162,7 +162,7 @@ now, mounted beside the account's and waiting on nothing.
       running out of it, the picture under corner ticks, a standing read as
       instruments and counts read as a ruled row - and they are not the same
       object: the card is one fixed 1200x630 drawing and the page reflows,
-      links onwards and has a match history coming. `players.test.mjs` holds
+      links onwards and has a match history coming. `profile-page.test.mjs` holds
       the two to the same figures in the same two kinds, since nothing else
       links a TypeScript screen to a Rust drawing.
 - [x] **A figure is one of two kinds, and is drawn as what it is.** A rating
@@ -176,7 +176,7 @@ now, mounted beside the account's and waiting on nothing.
       how a person does. What it was taking is the bio's room.
 - [x] **A shared link previews as the player, not as the site.** An unfurler
       runs no JavaScript, so one shell would preview as one generic card for
-      everybody. `services/api/src/unfurl.rs` answers `/unfurl/players/<...>`
+      everybody. `services/api/src/unfurl.rs` answers `/unfurl/profile/<...>`
       with the tags and a card drawn for whoever the address names, and the
       distribution sends card fetchers and crawlers there while everybody
       else is served the page from the bucket. The card is type on the site's
diff --git a/services/api/src/atproto/mod.rs b/services/api/src/atproto/mod.rs
index c76b98f..650272b 100644
--- a/services/api/src/atproto/mod.rs
+++ b/services/api/src/atproto/mod.rs
@@ -340,7 +340,7 @@ impl Atproto {
         }
     }
 
-    /// Who a `/players/<...>` address names, resolved from either form.
+    /// Who a `/profile/<...>` address names, resolved from either form.
     ///
     /// The web app does exactly this in `web/src/identity.ts`, and it has to
     /// be done here as well rather than shared: the page is drawn in the
diff --git a/services/api/src/routes.rs b/services/api/src/routes.rs
index 5e88bbd..ebfd504 100644
--- a/services/api/src/routes.rs
+++ b/services/api/src/routes.rs
@@ -123,12 +123,12 @@ pub fn app(state: AppState) -> Router {
         .route("/reports/{id}/card.png", get(crate::share::card))
         .route("/reports/fonts/{name}", get(crate::share::font))
         // What a link to a player unfurls as. A second prefix rather than
-        // /players/, because that address belongs to the site and is served
+        // /profile/, because that address belongs to the site and is served
         // from the bucket: the distribution sends a card fetcher here and
         // everybody else there. See unfurl.rs.
-        .route("/unfurl/players/{actor}", get(crate::unfurl::player))
+        .route("/unfurl/profile/{actor}", get(crate::unfurl::player))
         .route(
-            "/unfurl/players/{actor}/card.png",
+            "/unfurl/profile/{actor}/card.png",
             get(crate::unfurl::player_card),
         )
         .route("/match/{id}", get(crate::proxy::entry))
diff --git a/services/api/src/unfurl.rs b/services/api/src/unfurl.rs
index a3d2b00..0dee90c 100644
--- a/services/api/src/unfurl.rs
+++ b/services/api/src/unfurl.rs
@@ -1,6 +1,6 @@
 //! What a link to a player unfurls as.
 //!
-//! `/players/<handle-or-did>` is a page the site builds once and the browser
+//! `/profile/<handle-or-did>` is a page the site builds once and the browser
 //! fills in, which is right for a reader and useless to a card service: an
 //! unfurler runs no JavaScript, so one shell would preview as the same
 //! generic card for every player on the site.
@@ -44,7 +44,7 @@ struct Player {
     /// card prints and what the tags say.
     name: String,
     /// The same handle without its @, or None. What the address is written
-    /// with: `/players/@alice.example` carries one @ and not two.
+    /// with: `/profile/@alice.example` carries one @ and not two.
     handle: Option<String>,
     did: String,
     /// The account's own picture, as it uploaded it. None where it has none.
@@ -134,12 +134,12 @@ impl Player {
 
     /// The address of the page this is a preview of.
     fn here(&self, origin: &str) -> String {
-        format!("{origin}/players/{}", self.address())
+        format!("{origin}/profile/{}", self.address())
     }
 
     /// The picture's own address.
     ///
-    /// Under this prefix and not under the page's: `/players/...` is the
+    /// Under this prefix and not under the page's: `/profile/...` is the
     /// site's, and the distribution answers all of it from the bucket - a
     /// card asked for there would come back as the shell's HTML.
     ///
@@ -148,7 +148,7 @@ impl Player {
     /// than on the name it currently goes by means a rename does not strand
     /// the card a post is already carrying.
     fn card(&self, origin: &str) -> String {
-        format!("{origin}/unfurl/players/{}/card.png", self.did)
+        format!("{origin}/unfurl/profile/{}/card.png", self.did)
     }
 }
 
@@ -308,10 +308,10 @@ mod tests {
     fn the_page_names_the_site_and_the_card_names_this_service() {
         let player = player();
         let origin = "https://lance.blue";
-        assert_eq!(player.here(origin), "https://lance.blue/players/a.example");
+        assert_eq!(player.here(origin), "https://lance.blue/profile/a.example");
         assert_eq!(
             player.card(origin),
-            "https://lance.blue/unfurl/players/did:plc:abc123/card.png"
+            "https://lance.blue/unfurl/profile/did:plc:abc123/card.png"
         );
     }
 
@@ -323,16 +323,16 @@ mod tests {
         let html = document(&player, &player.here(origin), &player.card(origin));
         assert!(html.contains("<meta property=\"og:title\" content=\"@a.example\">"));
         assert!(html.contains(
-            "<meta property=\"og:url\" content=\"https://lance.blue/players/a.example\">"
+            "<meta property=\"og:url\" content=\"https://lance.blue/profile/a.example\">"
         ));
         assert!(html.contains(
-            "<meta property=\"og:image\" content=\"https://lance.blue/unfurl/players/did:plc:abc123/card.png\">"
+            "<meta property=\"og:image\" content=\"https://lance.blue/unfurl/profile/did:plc:abc123/card.png\">"
         ));
         assert!(html.contains("<meta name=\"twitter:card\" content=\"summary_large_image\">"));
         // The canonical address a crawler routed here should index is the
         // page's, never this document's own.
         assert!(
-            html.contains("<link rel=\"canonical\" href=\"https://lance.blue/players/a.example\">")
+            html.contains("<link rel=\"canonical\" href=\"https://lance.blue/profile/a.example\">")
         );
     }
 
@@ -344,7 +344,7 @@ mod tests {
         let player = player();
         let html = document(
             &player,
-            "https://lance.blue/players/a.example",
+            "https://lance.blue/profile/a.example",
             "https://x/c.png",
         );
         assert!(html.contains(&format!(
@@ -369,7 +369,7 @@ mod tests {
         };
         let html = document(
             &hostile,
-            "https://lance.blue/players/x",
+            "https://lance.blue/profile/x",
             "https://lance.blue/c.png",
         );
         assert!(!html.contains("<script>"));
diff --git a/web/astro.config.mjs b/web/astro.config.mjs
index 25ac009..8bf14a1 100644
--- a/web/astro.config.mjs
+++ b/web/astro.config.mjs
@@ -64,15 +64,15 @@ export default defineConfig({
       sourcemap: true,
     },
 
-    plugins: [playersRewrite()],
+    plugins: [profileRewrite()],
   },
 });
 
 /**
- * What CloudFront does for /players/<handle-or-did>, for the dev server.
+ * What CloudFront does for /profile/<handle-or-did>, for the dev server.
  *
  * There is one built file behind every player's address - see
- * src/pages/players/index.astro - and in production the distribution's
+ * src/pages/profile/index.astro - and in production the distribution's
  * viewer-request function rewrites the address onto it. Nothing does that
  * here, so a player's page is a 404 in development and only in development,
  * which is the worst place for the difference to be.
@@ -82,9 +82,9 @@ export default defineConfig({
  * and neither is a file.
  */
 /** @returns {import("vite").Plugin} */
-function playersRewrite() {
+function profileRewrite() {
   return {
-    name: "lance-blue:players-rewrite",
+    name: "lance-blue:profile-rewrite",
     enforce: "pre",
     /** @param {import("vite").ViteDevServer} server */
     configureServer(server) {
@@ -96,9 +96,9 @@ function playersRewrite() {
          */
         (req, _res, next) => {
           const url = req.url ?? "";
-          // "/players", with no slash: trailingSlash is "never", so that is
+          // "/profile", with no slash: trailingSlash is "never", so that is
           // the address Astro built the page at.
-          if (url.startsWith("/players/")) req.url = "/players";
+          if (url.startsWith("/profile/")) req.url = "/profile";
           next();
         },
       );
diff --git a/web/scripts/players.test.mjs b/web/scripts/profile-page.test.mjs
similarity index 86%
rename from web/scripts/players.test.mjs
rename to web/scripts/profile-page.test.mjs
index c9350ec..4e6e4b0 100644
--- a/web/scripts/players.test.mjs
+++ b/web/scripts/profile-page.test.mjs
@@ -1,7 +1,7 @@
 /**
  * A player's page is an address before it is a page.
  *
- * Three things have to agree about `/players/<handle-or-did>` and none of
+ * Three things have to agree about `/profile/<handle-or-did>` and none of
  * them can see the others: destinations.ts parses the address, Astro builds
  * one file for every address under the prefix, and a rewrite in front of the
  * bucket is what puts the two together. The failure is silent in both
@@ -16,33 +16,33 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
-import { actorFromPath, playerHref } from "../src/destinations.ts";
+import { actorFromPath, profileHref } from "../src/destinations.ts";
 
 const src = fileURLToPath(new URL("../src/", import.meta.url));
 
 test("the prefix has a page behind it", () => {
   assert.ok(
-    existsSync(`${src}pages/players/index.astro`),
-    "nothing builds /players, so every player's address is a 404",
+    existsSync(`${src}pages/profile/index.astro`),
+    "nothing builds /profile, so every player's address is a 404",
   );
 });
 
 test("an address names a handle or a DID, and both survive the trip", () => {
   assert.equal(
-    actorFromPath("/players/alice.example.com"),
+    actorFromPath("/profile/alice.example.com"),
     "alice.example.com",
   );
-  assert.equal(actorFromPath("/players/did:plc:abc123"), "did:plc:abc123");
+  assert.equal(actorFromPath("/profile/did:plc:abc123"), "did:plc:abc123");
   // A browser is within its rights to send the colons encoded.
-  assert.equal(actorFromPath("/players/did%3Aplc%3Aabc123"), "did:plc:abc123");
+  assert.equal(actorFromPath("/profile/did%3Aplc%3Aabc123"), "did:plc:abc123");
   // A trailing slash is the same page, not a dead end.
-  assert.equal(actorFromPath("/players/did:plc:abc123/"), "did:plc:abc123");
+  assert.equal(actorFromPath("/profile/did:plc:abc123/"), "did:plc:abc123");
   // Nobody named.
-  assert.equal(actorFromPath("/players/"), null);
-  assert.equal(actorFromPath("/players"), null);
+  assert.equal(actorFromPath("/profile/"), null);
+  assert.equal(actorFromPath("/profile"), null);
   assert.equal(actorFromPath("/blog"), null);
   // A malformed escape is not an address, and must not throw on the way out.
-  assert.equal(actorFromPath("/players/%E0%A4%A"), null);
+  assert.equal(actorFromPath("/profile/%E0%A4%A"), null);
 });
 
 test("the site writes the handle, and the DID where there is no handle", () => {
@@ -50,26 +50,26 @@ test("the site writes the handle, and the DID where there is no handle", () => {
   // Nothing is escaped: an @ and a colon are both legal in a path segment,
   // and an address is written to be read.
   assert.equal(
-    playerHref({ did, handle: "alice.example" }),
-    "/players/@alice.example",
+    profileHref({ did, handle: "alice.example" }),
+    "/profile/@alice.example",
   );
-  assert.equal(playerHref({ did, handle: null }), `/players/${did}`);
+  assert.equal(profileHref({ did, handle: null }), `/profile/${did}`);
 
   // Both forms come back out of the address they went into, and so does one
   // that arrived escaped from somewhere that tidied it.
   assert.equal(
-    actorFromPath(playerHref({ did, handle: "alice.example" })),
+    actorFromPath(profileHref({ did, handle: "alice.example" })),
     "@alice.example",
   );
-  assert.equal(actorFromPath(playerHref({ did, handle: null })), did);
-  assert.equal(actorFromPath("/players/%40alice.example"), "@alice.example");
+  assert.equal(actorFromPath(profileHref({ did, handle: null })), did);
+  assert.equal(actorFromPath("/profile/%40alice.example"), "@alice.example");
 });
 
 test("the account menu's Your account goes to the player's own page", async () => {
   const account = await readFile(`${src}account.ts`, "utf8");
   assert.match(
     account,
-    /playerHref\(session\)/,
+    /profileHref\(session\)/,
     "Your account points somewhere that is not the player's own page",
   );
 });
@@ -82,12 +82,12 @@ test("the dev server serves the shell for an address under the prefix", async ()
     fileURLToPath(new URL("../astro.config.mjs", import.meta.url)),
     "utf8",
   );
-  assert.match(config, /startsWith\("\/players\/"\)/);
-  assert.match(config, /req\.url = "\/players"/);
+  assert.match(config, /startsWith\("\/profile\/"\)/);
+  assert.match(config, /req\.url = "\/profile"/);
 });
 
 test("the page reads the address rather than being built per player", async () => {
-  const page = await readFile(`${src}pages/players/index.astro`, "utf8");
+  const page = await readFile(`${src}pages/profile/index.astro`, "utf8");
   assert.doesNotMatch(
     page,
     /getStaticPaths/,
@@ -102,7 +102,7 @@ test("the page reads the address rather than being built per player", async () =
 // "patterns". Somebody reading a post and then the page it points at sees
 // both within a second of each other.
 test("the page and the card count the same things, in the same two kinds", async () => {
-  const page = await readFile(`${src}players.ts`, "utf8");
+  const page = await readFile(`${src}profile-page.ts`, "utf8");
   const card = await readFile(
     fileURLToPath(new URL("../../services/api/src/unfurl.rs", import.meta.url)),
     "utf8",
@@ -193,7 +193,7 @@ test("the challenge opens a duel with them in it, not the Play screen", async ()
 // provider comes back into the fight rather than onto the front page. A
 // disabled button would be a dead end for the reader this page is most for.
 test("signed out, Challenge signs you in and remembers what you pressed", async () => {
-  const page = await readFile(`${src}players.ts`, "utf8");
+  const page = await readFile(`${src}profile-page.ts`, "utf8");
   const fn = page.match(/function challengeButton\([\s\S]*?\n\}/);
   assert.ok(fn, "challengeButton moved or was renamed");
 
@@ -219,7 +219,7 @@ test("signed out, Challenge signs you in and remembers what you pressed", async
 });
 
 test("neither Challenge nor the follow tick is drawn about yourself", async () => {
-  const page = await readFile(`${src}players.ts`, "utf8");
+  const page = await readFile(`${src}profile-page.ts`, "utf8");
   const mark = page.match(/function accountMark\([\s\S]*?\n\}/);
   assert.ok(mark, "accountMark moved or was renamed");
   // "You follow yourself" is not a fact, and there is no relationship to ask
diff --git a/web/src/account.ts b/web/src/account.ts
index 94bc934..2c3d7b4 100644
--- a/web/src/account.ts
+++ b/web/src/account.ts
@@ -32,7 +32,7 @@ import {
   PLAY_LABEL,
   RESUME_LABEL,
   isAppPage,
-  playerHref,
+  profileHref,
 } from "./destinations";
 import { el } from "./dom";
 import { attachMenu } from "./menu";
@@ -219,7 +219,7 @@ function signedIn(session: Session): HTMLElement {
     el("p", { className: "account-who", textContent: name }),
     // Your own player page: the same address anybody else's is at, so what
     // you see of yourself is what you can hand somebody else.
-    link(playerHref(session), "Your account"),
+    link(profileHref(session), "Your account"),
     link("/#operations", "Your matches"),
     link("/#camo", "Your camo"),
     report,
diff --git a/web/src/challenge-stash.ts b/web/src/challenge-stash.ts
index f407402..5b36f98 100644
--- a/web/src/challenge-stash.ts
+++ b/web/src/challenge-stash.ts
@@ -2,7 +2,7 @@
  * Carrying "the player somebody pressed Challenge on" from their page into
  * the app.
  *
- * A player's page is its own page — /players/@alice.example is a file the
+ * A player's page is its own page — /profile/@alice.example is a file the
  * build wrote, not a hash the app routes — so pressing Challenge there is a
  * navigation rather than a screen change. The intent has to survive that hop,
  * and it has to survive the longer one too: a signed-out reader presses
diff --git a/web/src/destinations.ts b/web/src/destinations.ts
index 391f15c..94de66c 100644
--- a/web/src/destinations.ts
+++ b/web/src/destinations.ts
@@ -306,19 +306,19 @@ export function lobbyIdFromHash(hash: string): string | null {
  * A path rather than a hash, unlike every destination above: a profile is
  * what people link to about each other, and an unfurler has to be able to be
  * answered per player - which needs an address the distribution can route on
- * its own, without running the page. See web/src/players.ts.
+ * its own, without running the page. See web/src/profile-page.ts.
  *
  * The segment is a handle or a fully qualified DID, and both name the same
  * page; identity.ts resolves whichever arrives. What the site *writes* is the
- * handle, with its @: `/players/@alice.example` is an address somebody can
- * read out, and `/players/did:plc:h7k...` is one nobody can. The DID form
+ * handle, with its @: `/profile/@alice.example` is an address somebody can
+ * read out, and `/profile/did:plc:h7k...` is one nobody can. The DID form
  * stays valid for exactly the case the handle cannot cover - an account whose
  * handle nothing can confirm - and for a link written before a handle moved.
  *
  * Neither is percent-encoded. An @ and a colon are both legal in a path
  * segment, browsers send them as typed, and an address is written to be read.
  */
-const PLAYER_PREFIX = "/players/";
+const PROFILE_PREFIX = "/profile/";
 
 /**
  * The page's address for an account.
@@ -326,11 +326,11 @@ const PLAYER_PREFIX = "/players/";
  * Handed the handle where there is one and the DID where there is not, which
  * is the same rule the page and the card follow for what to call somebody.
  */
-export function playerHref(actor: {
+export function profileHref(actor: {
   did: string;
   handle: string | null;
 }): string {
-  return `${PLAYER_PREFIX}${actor.handle ? `@${actor.handle}` : actor.did}`;
+  return `${PROFILE_PREFIX}${actor.handle ? `@${actor.handle}` : actor.did}`;
 }
 
 /**
@@ -339,12 +339,12 @@ export function playerHref(actor: {
  * A leading @ is part of the handle's address and is left on: identity.ts
  * takes it off before resolving, the way it takes one off anything typed.
  * Anything after a second slash is ignored rather than refused:
- * `/players/@alice.example/` is the same page, and a trailing slash is not
+ * `/profile/@alice.example/` is the same page, and a trailing slash is not
  * worth a dead end.
  */
 export function actorFromPath(pathname: string): string | null {
-  if (!pathname.startsWith(PLAYER_PREFIX)) return null;
-  const segment = pathname.slice(PLAYER_PREFIX.length).split("/")[0] ?? "";
+  if (!pathname.startsWith(PROFILE_PREFIX)) return null;
+  const segment = pathname.slice(PROFILE_PREFIX.length).split("/")[0] ?? "";
   if (segment === "") return null;
   try {
     // Nothing here writes an encoded address any more, and one can still
diff --git a/web/src/identity.ts b/web/src/identity.ts
index da9f6c4..91dd004 100644
--- a/web/src/identity.ts
+++ b/web/src/identity.ts
@@ -1,5 +1,5 @@
 /**
- * Who a `/players/<...>` address names.
+ * Who a `/profile/<...>` address names.
  *
  * The address takes either form — a handle, or a fully qualified DID — and
  * both have to end up at the same place, so this resolves in whichever
diff --git a/web/src/pages/players/index.astro b/web/src/pages/profile/index.astro
similarity index 78%
rename from web/src/pages/players/index.astro
rename to web/src/pages/profile/index.astro
index af79687..c163a3b 100644
--- a/web/src/pages/players/index.astro
+++ b/web/src/pages/profile/index.astro
@@ -2,10 +2,10 @@
 /**
  * The shell every player's page is served from.
  *
- * One file, for /players/<handle> and /players/<did> alike: there is no list
+ * One file, for /profile/<handle> and /profile/<did> alike: there is no list
  * of players for a build to prerender a page each from, so the distribution
- * rewrites every address under the prefix to this file and players.ts reads
- * which player off the address. See infra's index-rewrite.js.
+ * rewrites every address under the prefix to this file, and profile-page.ts
+ * reads which player off the address. See infra's index-rewrite.js.
  *
  * The tags in the head are the site's own, and they are not what a shared
  * link unfurls with: a card fetcher asking for one of these addresses is sent
@@ -25,6 +25,6 @@ import Base from "../../layouts/Base.astro";
     >
   </main>
   <script>
-    import "../../players";
+    import "../../profile-page";
   </script>
 </Base>
diff --git a/web/src/players.ts b/web/src/profile-page.ts
similarity index 97%
rename from web/src/players.ts
rename to web/src/profile-page.ts
index aa3ba28..258ead8 100644
--- a/web/src/players.ts
+++ b/web/src/profile-page.ts
@@ -1,5 +1,5 @@
 /**
- * A player's page: /players/<handle> and /players/<did>, the same page.
+ * A player's page: /profile/<handle> and /profile/<did>, the same page.
  *
  * It is a page rather than a hash route on purpose. A profile is the thing
  * people link to about each other, and an address a reader can copy out of
@@ -24,7 +24,7 @@ import { currentSession, listMatches, type Session } from "./api";
 import { stashChallenge } from "./challenge-stash";
 import { footer, pageHead } from "./chrome";
 import { el, render } from "./dom";
-import { actorFromPath, playerHref } from "./destinations";
+import { actorFromPath, profileHref } from "./destinations";
 import { resolveActor, type Actor } from "./identity";
 import { relationship } from "./relationships";
 import { avatarUrl, monogram } from "./profile";
@@ -147,7 +147,7 @@ function face(actor: Actor): HTMLElement {
       image.addEventListener("load", () => box.replaceChildren(image));
     })
     .catch((error: unknown) => {
-      console.warn("players: the picture could not be found", error);
+      console.warn("profile: the picture could not be found", error);
     });
 
   return box;
@@ -188,7 +188,7 @@ function figure(spec: Figure, actor: Actor, self: boolean): HTMLElement {
     .catch((error: unknown) => {
       // A figure that cannot be read stays an em dash. Nothing on this page is
       // worth an error screen, and the rest of it may have arrived.
-      console.warn(`players: ${spec.label} could not be counted`, error);
+      console.warn(`profile: ${spec.label} could not be counted`, error);
       row.title = "This could not be read just now.";
     });
 
@@ -248,7 +248,7 @@ function challengeButton(
         // this page is read from the network the account lives on and is
         // still true - but not silence either: a press that appears to do
         // nothing is the worst of the three answers.
-        console.warn("players: the challenge could not be started", error);
+        console.warn("profile: the challenge could not be started", error);
         button.disabled = false;
         trouble.textContent = "A challenge could not be started just now.";
       });
@@ -422,7 +422,7 @@ function profile(actor: Actor, session: Session | null): Node[] {
  * this page at all: the distribution sends it to the unfurl route instead.
  */
 function markCanonical(actor: Actor): void {
-  const href = new URL(playerHref(actor), window.location.origin).href;
+  const href = new URL(profileHref(actor), window.location.origin).href;
   const existing = document.querySelector<HTMLLinkElement>(
     "link[rel=canonical]",
   );
@@ -436,11 +436,11 @@ async function start(): Promise<void> {
   const asked = actorFromPath(window.location.pathname);
 
   if (!asked) {
-    // /players with nobody after it. Your own page is the only sensible
+    // /profile with nobody after it. Your own page is the only sensible
     // answer, and a stranger is told what the address is for.
     const session = await currentSession().catch(() => null);
     if (session) {
-      window.location.replace(playerHref(session));
+      window.location.replace(profileHref(session));
       return;
     }
     render(...nobody(window.location.pathname));
-- 
2.51.2