diff --git a/CLAUDE.md b/CLAUDE.md
index 4cc1a21..bf06c0b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -22,6 +22,9 @@ JARL ("JARL: Atomic Routing Library") is a controlled-component router for React
 - `infra/` — AWS CDK app provisioning the hosting for jarl.randomdev.co.uk. Also a separate
   npm project, kept out of the workspaces so it is never published: `infra/README.md`.
 
+A new atom's name says what it returns: `*RouteAtom` if its value is a `RouteAtom`, `*Atom`
+otherwise. See `packages/jarl-atoms/DESIGN-NOTES.md`.
+
 The two packages are deliberately separate import paths: `jarl-react` does **not** re-export
 `jarl-atoms`. Consumers get route atoms from `jarl-atoms` and the React bindings from
 `jarl-react`, so the framework boundary stays visible and `jarl-atoms` is usable on its own.
diff --git a/README.md b/README.md
index 47b288d..60f0e5d 100644
--- a/README.md
+++ b/README.md
@@ -16,30 +16,30 @@ wanted something that did just this job extremely well, but without getting in t
 dictating application structure, and without forcing route matching logic into the component
 tree itself, where it never seemed to belong. JARL builds that mapping out of composable atoms
 using [jotai](https://jotai.org/) under the hood: each route is its own atom, with a link to a
-parent atom and so on up to the [`rootAtom`](/api/jarl-atoms#rootatom); each one matching a
-piece of the URL (normally a path segment) and telling you both whether it *currently* matches,
+parent atom and so on up to the [`rootRoute`](/api/jarl-atoms#rootroute); each one matching a
+piece of the URL (normally a path segment) and telling you both whether it _currently_ matches,
 as well as **how to build a URL _to_ that route** based on a given state. Routing decisions in
 your application then decompose to very simple logic based on the current states of these
 atoms; a simple `switch` statement or series of `if`s is enough to decide what components to
-render, and navigation can be performed by *calling the atom setter*. (Convenience components
+render, and navigation can be performed by _calling the atom setter_. (Convenience components
 like [`<Route>`](/api/jarl-react#route) and [`<Switch>`](/api/jarl-react#switch) and of course
 the ubiquitous [`<Link>`](/api/jarl-react#link) are of course provided in the React package, if
 you want to build more compositionally; they all just accept atoms for parameters instead of
 type-unsafe strings.)
 
 Because each route atom is an independent, subscribable unit of jotai state, a component that
-reads one only re-renders when *that atom's* derived value actually changes - it turns out this
+reads one only re-renders when _that atom's_ derived value actually changes - it turns out this
 is incredibly efficient.
 
 ## Features
 
-*   Map URLs directly to state (and back again) - the URL becomes the source of truth
-*   Composable route atoms - build nested/dynamic routes out of small, independent pieces
-*   Framework-agnostic core (`jarl-atoms`) with lightweight React bindings (`jarl-react`)
-*   Full querystring matching support
-*   Resolve promises during routing (via jotai's own async atoms) and redirect if required
-*   SSR/SSG-safe: the resolved location atom is hydratable per-render on the server
-*   And much more...
+- Map URLs directly to state (and back again) - the URL becomes the source of truth
+- Composable route atoms - build nested/dynamic routes out of small, independent pieces
+- Framework-agnostic core (`jarl-atoms`) with lightweight React bindings (`jarl-react`)
+- Full querystring matching support
+- Resolve promises during routing (via jotai's own async atoms) and redirect if required
+- SSR/SSG-safe: the resolved location atom is hydratable per-render on the server
+- And much more...
 
 ## Concrete Example
 
@@ -54,9 +54,9 @@ Declare some route atoms:
 
 ```ts
 // routes.ts
-import { rootAtom, staticRouteAtom, paramRouteAtom } from "jarl-atoms";
+import { rootRoute, staticRouteAtom, paramRouteAtom } from "jarl-atoms";
 
-export const homeRoute = rootAtom;
+export const homeRoute = rootRoute;
 export const aboutRoute = staticRouteAtom("about");
 export const productsRoute = staticRouteAtom("products");
 // The `productId` segment is bound into `values` when this route matches:
@@ -75,7 +75,7 @@ import App from "./App";
 createRoot(document.getElementById("root")!).render(
   <Provider>
     <App />
-  </Provider>
+  </Provider>,
 );
 ```
 
@@ -110,7 +110,9 @@ import { Link } from "jarl-react";
 
 const MainMenu = () => (
   <nav>
-    <Link route={homeRoute} exact>Home</Link>
+    <Link route={homeRoute} exact>
+      Home
+    </Link>
     <Link route={aboutRoute}>About</Link>
     <Link route={productRoute} to={{ productId: "123" }}>
       Our Best Product Ever!
@@ -129,10 +131,10 @@ the `useNavigate` hook instead:
 ```tsx
 import { atom, useAtom } from "jotai";
 import { useNavigate } from "jarl-react";
-import { queryParamAtom } from "jarl-atoms";
+import { queryParamRouteAtom } from "jarl-atoms";
 
 // A single named query-string param is its own composable route atom too:
-const searchQueryRoute = queryParamAtom("q");
+const searchQueryRoute = queryParamRouteAtom("q");
 
 // Controlled search input value also tracked in an atom
 const searchTextAtom = atom("");
@@ -141,7 +143,12 @@ const SearchForm = () => {
   const [searchText, setSearchText] = useAtom(searchTextAtom);
   const navigate = useNavigate(searchQueryRoute);
   return (
-    <form onSubmit={(e) => { e.preventDefault(); navigate({ q: searchText }); }}>
+    <form
+      onSubmit={(e) => {
+        e.preventDefault();
+        navigate({ q: searchText });
+      }}
+    >
       <input
         type="text"
         value={searchText}
diff --git a/e2e/fixture-app/src/App.tsx b/e2e/fixture-app/src/App.tsx
index cca5a65..6871cd2 100644
--- a/e2e/fixture-app/src/App.tsx
+++ b/e2e/fixture-app/src/App.tsx
@@ -1,6 +1,6 @@
 import { useAtomValue } from "jotai";
 import type { ComponentType } from "react";
-import { rootAtom } from "./routes";
+import { rootRoute } from "./routes";
 import Shell from "./pages/Shell";
 import BasicRouting from "./pages/BasicRouting";
 import AdvancedRouting from "./pages/AdvancedRouting";
@@ -10,7 +10,7 @@ import NavigationGuards from "./pages/NavigationGuards";
 
 // Top-level segment -> demo. The v2 route atoms don't have a "first match
 // wins" switch/exclusivity primitive yet, so this dispatch is done in plain
-// component code (reading rootAtom directly) rather than by composing
+// component code (reading rootRoute directly) rather than by composing
 // several independent <Route> elements, which would all render at once
 // since nothing here excludes them from each other.
 const DEMOS: Record<string, ComponentType> = {
@@ -22,7 +22,7 @@ const DEMOS: Record<string, ComponentType> = {
 };
 
 const App = () => {
-  const root = useAtomValue(rootAtom);
+  const root = useAtomValue(rootRoute);
   const section = root.match ? root.rest.path[0] : undefined;
   const Demo = section && DEMOS[section];
   return Demo ? <Demo /> : <Shell />;
diff --git a/e2e/fixture-app/src/pages/Shell.tsx b/e2e/fixture-app/src/pages/Shell.tsx
index 554a774..655121a 100644
--- a/e2e/fixture-app/src/pages/Shell.tsx
+++ b/e2e/fixture-app/src/pages/Shell.tsx
@@ -1,6 +1,6 @@
 import { useAtomValue } from "jotai";
 import { useEffect } from "react";
-import { rootAtom, changelogAtom, shellMissingAtom } from "../routes";
+import { rootRoute, changelogAtom, shellMissingAtom } from "../routes";
 import { Link } from "jarl-react";
 
 const useTitle = (title: string) => {
@@ -43,7 +43,7 @@ const NotFound = ({ missingPath }: { missingPath: string }) => {
 // Top-level "shell" of the fixture app: home/about, changelog, and the
 // catch-all 404. Mirrors demo/cypress/integration/00DemosShell.js.
 const Shell = () => {
-  const root = useAtomValue(rootAtom);
+  const root = useAtomValue(rootRoute);
   const changelog = useAtomValue(changelogAtom);
   const missing = useAtomValue(shellMissingAtom);
 
@@ -63,7 +63,7 @@ const Shell = () => {
   return (
     <div>
       <nav>
-        <Link route={rootAtom} data-test="home-nav-link">
+        <Link route={rootRoute} data-test="home-nav-link">
           Home
         </Link>{" "}
         <Link route={changelogAtom} data-test="changelog-nav-link">
diff --git a/e2e/fixture-app/src/routes.ts b/e2e/fixture-app/src/routes.ts
index 0f5d9bc..83bb0f6 100644
--- a/e2e/fixture-app/src/routes.ts
+++ b/e2e/fixture-app/src/routes.ts
@@ -7,23 +7,23 @@
  * can exercise realistic nested/param routes.
  *
  * NOTE: this file only *composes* the primitives jarl-atoms exports
- * (rootAtom, staticRouteAtom, paramRouteAtom, redirectAtom, asyncRouteAtom). It
+ * (rootRoute, staticRouteAtom, paramRouteAtom, redirectRouteAtom, asyncRouteAtom). It
  * does not add routing features to the library.
  */
 import { atom } from "jotai/vanilla";
 import { loadable } from "jotai/utils";
 import {
-  rootAtom,
+  rootRoute,
   staticRouteAtom,
   paramRouteAtom,
-  redirectAtom,
+  redirectRouteAtom,
   asyncRouteAtom,
   redirect,
   navigationGuardAtom,
 } from "jarl-atoms";
 
 // --- Shell (demo/cypress/integration/00DemosShell.js) ---
-export { rootAtom };
+export { rootRoute };
 export const changelogAtom = staticRouteAtom("changelog");
 // Catches any single unmatched top-level segment, e.g. /asdfghjkl
 export const shellMissingAtom = paramRouteAtom("missingPath");
@@ -74,7 +74,7 @@ export const redirectsContentSlugAtom = paramRouteAtom("slug", {
 // landing page. Read via its `match`, not `followRedirects` - see the
 // comment on `reasonSearchParams` in Redirects.tsx for why the actual
 // navigation is handled there instead.
-export const redirectsMovedRedirectAtom = redirectAtom("/redirects", {
+export const redirectsMovedRedirectAtom = redirectRouteAtom("/redirects", {
   parent: redirectsMovedAtom,
 });
 
diff --git a/packages/docs/src/content/guides/DataLoading.md b/packages/docs/src/content/guides/DataLoading.md
index d866786..d90a6ab 100644
--- a/packages/docs/src/content/guides/DataLoading.md
+++ b/packages/docs/src/content/guides/DataLoading.md
@@ -162,14 +162,14 @@ the current location with its target (`history.replaceState`, so the abandoned U
 linger in the back-button history).
 
 If a route should redirect unconditionally - with no data fetch involved at all -
-`redirectAtom`/`followRedirects` do the same job without a loader:
+`redirectRouteAtom`/`followRedirects` do the same job without a loader:
 
 ```ts
-import { redirectAtom, followRedirects } from "jarl-atoms";
+import { redirectRouteAtom, followRedirects } from "jarl-atoms";
 import { staticRouteAtom } from "jarl-atoms";
 
 export const oldAboutRoute = staticRouteAtom("about-us");
-export const oldAboutRedirect = redirectAtom("/about", { parent: oldAboutRoute });
+export const oldAboutRedirect = redirectRouteAtom("/about", { parent: oldAboutRoute });
 
 followRedirects(store, [oldAboutRedirect]);
 ```
diff --git a/packages/docs/src/content/guides/GettingStarted.md b/packages/docs/src/content/guides/GettingStarted.md
index ee1b666..eaac37e 100644
--- a/packages/docs/src/content/guides/GettingStarted.md
+++ b/packages/docs/src/content/guides/GettingStarted.md
@@ -10,15 +10,15 @@ root of your app, and `Link`/`Route` from `jarl-react` to navigate and render.
 routes.ts:
 
 ```ts
-import { rootAtom, staticRouteAtom } from "jarl-atoms";
+import { rootRoute, staticRouteAtom } from "jarl-atoms";
 
-export const homeRoute = rootAtom;
+export const homeRoute = rootRoute;
 export const aboutRoute = staticRouteAtom("about");
 ```
 
 Each of these is a **route atom**: a jotai atom that, when read, tells you whether its path
 currently matches (`match`, `exact`, `values`) and how to build a URL for it (`reverse`); when
-_written_, it navigates there. `rootAtom` matches `/` itself and is the implicit parent every
+_written_, it navigates there. `rootRoute` matches `/` itself and is the implicit parent every
 other route atom builds on unless you give it a different `parent`. `staticRouteAtom("about")`
 matches a single fixed path segment - here, `/about`.
 
diff --git a/packages/docs/src/content/guides/PathVariables.md b/packages/docs/src/content/guides/PathVariables.md
index bddf4a7..cdf1e3d 100644
--- a/packages/docs/src/content/guides/PathVariables.md
+++ b/packages/docs/src/content/guides/PathVariables.md
@@ -4,7 +4,7 @@ Now we've seen how to set up some static routes, let's look at something a bit m
 Routing isn't much use if we have to define every single URL statically!
 
 `paramRouteAtom` binds a single dynamic path segment to a named value, composed on top of a
-parent route atom (any route atom - `rootAtom`, a `staticRouteAtom`, or another
+parent route atom (any route atom - `rootRoute`, a `staticRouteAtom`, or another
 `paramRouteAtom`, for nested dynamic segments):
 
 routes.ts:
@@ -58,15 +58,15 @@ Linking to a dynamic route works the same way as a static one - just pass the pa
 
 ## Query parameters
 
-Dynamic _path_ segments aren't the only way to carry a value in a URL - `queryParamAtom` (from
+Dynamic _path_ segments aren't the only way to carry a value in a URL - `queryParamRouteAtom` (from
 `jarl-atoms`) does the same job for a single named query-string parameter, composed on top of a
 parent route atom exactly like `paramRouteAtom`, except it doesn't consume a path segment:
 
 ```ts
-import { staticRouteAtom, queryParamAtom } from "jarl-atoms";
+import { staticRouteAtom, queryParamRouteAtom } from "jarl-atoms";
 
 export const searchRoute = staticRouteAtom("search");
-export const searchQueryRoute = queryParamAtom("q", { parent: searchRoute });
+export const searchQueryRoute = queryParamRouteAtom("q", { parent: searchRoute });
 ```
 
 `searchQueryRoute` matches whenever `/search` does, with `values.q` set to the current `?q=`
diff --git a/packages/docs/src/content/history.md b/packages/docs/src/content/history.md
index 4a536ab..c9105b2 100644
--- a/packages/docs/src/content/history.md
+++ b/packages/docs/src/content/history.md
@@ -168,7 +168,7 @@ on every navigation regardless of relevance. The v2 atoms
   override under Node - so a location can be seeded server-side for prerendering,
   which is exactly what lets this docs site itself be statically generated.
 - `routeAtom(matchPath, makePath, { parent })` derives a **route atom** from a parent
-  route atom (defaulting to a `rootAtom`), matching one path segment at a time and
+  route atom (defaulting to a `rootRoute`), matching one path segment at a time and
   carrying a `rest.path` of unconsumed segments down to child route atoms - so nested
   routes compose as a chain of atoms instead of a nested-array route table walked by a
   single `RouteMap.match` call.
diff --git a/packages/docs/src/demos/BlogRoutingApp.tsx b/packages/docs/src/demos/BlogRoutingApp.tsx
index a9fd3af..35fdb67 100644
--- a/packages/docs/src/demos/BlogRoutingApp.tsx
+++ b/packages/docs/src/demos/BlogRoutingApp.tsx
@@ -1,4 +1,4 @@
-import { createRootAtom, numericRouteAtom, paramRouteAtom, validateAtom } from "jarl-atoms";
+import { rootRouteAtom, numericRouteAtom, paramRouteAtom, validateRouteAtom } from "jarl-atoms";
 import { Link, Route, Switch } from "jarl-react";
 import {
   BlogPost,
@@ -30,13 +30,13 @@ const MONTH_NAMES = [
 const formatDate = (post: BlogPost) => `${MONTH_NAMES[post.month - 1]} ${post.day}, ${post.year}`;
 
 // The page this demo is mounted on, so its whole tree below is plain module-level atoms.
-const blogRoot = createRootAtom({ basePath: "/demos/blog-routing" });
+const blogRoot = rootRouteAtom({ basePath: "/demos/blog-routing" });
 const yearRoute = numericRouteAtom("year", { parent: blogRoot });
 const monthRoute = numericRouteAtom("month", { parent: yearRoute, min: 1, max: 12 });
 const daySegment = numericRouteAtom("day", { parent: monthRoute });
 // A segment's own min/max only bounds it in isolation; a real calendar date needs all three
 // together, so the whole date is validated as part of matching rather than in a page component.
-const dayRoute = validateAtom(daySegment, ({ year, month, day }) => isValidCalendarDate(year, month, day));
+const dayRoute = validateRouteAtom(daySegment, ({ year, month, day }) => isValidCalendarDate(year, month, day));
 const postRoute = paramRouteAtom("slug", { parent: dayRoute });
 
 const BlogNav = () => (
diff --git a/packages/docs/src/demos/DataGridApp.tsx b/packages/docs/src/demos/DataGridApp.tsx
index bed6f45..4dc5076 100644
--- a/packages/docs/src/demos/DataGridApp.tsx
+++ b/packages/docs/src/demos/DataGridApp.tsx
@@ -1,6 +1,6 @@
 import { useEffect } from "react";
 import { atom, useAtom, useAtomValue, useSetAtom } from "jotai";
-import { createRootAtom, queryParamAtom, requireMatch, transformRouteAtom } from "jarl-atoms";
+import { rootRouteAtom, queryParamRouteAtom, requireMatch, transformRouteAtom } from "jarl-atoms";
 import { useRequiredRoute } from "jarl-react";
 import { Table } from "./DataGridTable";
 import { Ware, wares } from "./wares";
@@ -51,23 +51,23 @@ const sortWares = (rows: Ware[], key: SortKey, direction: SortDirection) => {
 };
 
 // The page this demo is mounted on, so everything below it is a plain module-level atom.
-const gridRoot = createRootAtom({ basePath: "/demos/data-grid" });
+const gridRoot = rootRouteAtom({ basePath: "/demos/data-grid" });
 
 // The raw "sort" query segment.
-const sortParam = queryParamAtom("sort", { parent: gridRoot });
+const sortParam = queryParamRouteAtom("sort", { parent: gridRoot });
 
 const sortRoute = transformRouteAtom(
   sortParam,
   // Down: parse the raw query value into the shape the UI actually wants.
   (values) => parseSort(values.sort),
-  // Up: serialize back to the raw string queryParamAtom expects to write.
+  // Up: serialize back to the raw string queryParamRouteAtom expects to write.
   (values) => ({ sort: stringifySort(values.key, values.direction) }),
 );
 
 // Chains off sortRoute, not sortParam - so filter's own values carry the already-parsed sort
 // alongside the filter text. Writing here re-composes the whole chain back into a URL, so
 // whichever field didn't change comes along for free via the current match.
-const filterRoute = queryParamAtom("filter", { parent: sortRoute });
+const filterRoute = queryParamRouteAtom("filter", { parent: sortRoute });
 
 // A plain read off the chain's tip - no useMemo in the component needed for this. Only the
 // component below reads it, and the site only mounts that under /demos/data-grid, which is the
diff --git a/packages/docs/src/pages/Changelog.tsx b/packages/docs/src/pages/Changelog.tsx
index 841684d..2cb7dcb 100644
--- a/packages/docs/src/pages/Changelog.tsx
+++ b/packages/docs/src/pages/Changelog.tsx
@@ -1,10 +1,10 @@
-import { createRootAtom, paramRouteAtom } from "jarl-atoms";
+import { rootRouteAtom, paramRouteAtom } from "jarl-atoms";
 import { Link, Route, Switch } from "jarl-react";
 import Markdown from "../lib/Markdown";
 import { changelogEntries, changelogEntryFor, fullChangelog, ChangelogEntry } from "./changelogEntries";
 
 // The page this is mounted on, so its version route below is a plain module-level atom.
-const changelogRoot = createRootAtom({ basePath: "/changelog" });
+const changelogRoot = rootRouteAtom({ basePath: "/changelog" });
 const versionRoute = paramRouteAtom("version", { parent: changelogRoot });
 
 const ChangelogNav = () => (
diff --git a/packages/docs/src/pages/DemosIndex.tsx b/packages/docs/src/pages/DemosIndex.tsx
index 9b16b80..6e87ff8 100644
--- a/packages/docs/src/pages/DemosIndex.tsx
+++ b/packages/docs/src/pages/DemosIndex.tsx
@@ -31,8 +31,8 @@ export const DemosIndex = () => (
         <Link route={dataGridDemoRoute} to={{}}>
           Data grid filter/sort
         </Link>{" "}
-        &mdash; a table whose filter text and sort column live in <code>queryParamAtom</code>s chained off the mount
-        route, so the grid&apos;s state is shareable and moves with back/forward navigation.
+        &mdash; a table whose filter text and sort column live in <code>queryParamRouteAtom</code>s chained off the
+        mount route, so the grid&apos;s state is shareable and moves with back/forward navigation.
       </li>
       <li>
         <Link route={asyncLookupDemoRoute} to={{}}>
diff --git a/packages/docs/src/router/routes.ts b/packages/docs/src/router/routes.ts
index ff232c7..5aee8bc 100644
--- a/packages/docs/src/router/routes.ts
+++ b/packages/docs/src/router/routes.ts
@@ -6,12 +6,12 @@
  * `jarl-atoms`' server-seedable `locationAtom`.
  */
 import { atom } from "jotai";
-import { asyncRouteAtom, notAtom, rootAtom, staticRouteAtom, paramRouteAtom } from "jarl-atoms";
+import { asyncRouteAtom, notAtom, rootRoute, staticRouteAtom, paramRouteAtom } from "jarl-atoms";
 import { blogStaticPaths } from "../demos/blogPosts";
 import { articleSlugs, findArticle } from "../demos/asyncArticles";
 import { changelogStaticPaths } from "../pages/changelogEntries";
 
-export const homeRoute = rootAtom;
+export const homeRoute = rootRoute;
 
 export const docsSectionRoute = staticRouteAtom("docs");
 export const docPageRoute = paramRouteAtom("docName", { parent: docsSectionRoute });
diff --git a/packages/jarl-atoms/DESIGN-NOTES.md b/packages/jarl-atoms/DESIGN-NOTES.md
index bc63b42..3a4d165 100644
--- a/packages/jarl-atoms/DESIGN-NOTES.md
+++ b/packages/jarl-atoms/DESIGN-NOTES.md
@@ -90,7 +90,7 @@ Dead in isolation; only relevant if the pattern-string sketch is revived.
 
 ## Scoping `locationAtom` to a path prefix with a jotai store
 
-Rejected in favour of `createRootAtom({ basePath })`.
+Rejected in favour of `rootRouteAtom({ basePath })`.
 
 The idea was to mount a subtree in its own jotai store whose `locationAtom` reads
 and writes relative to a prefix, so the subtree's route atoms could be declared
@@ -106,7 +106,7 @@ without knowing where they are mounted. Two mechanisms exist and neither works:
   revision-numbered API that `jotai-scope` is built on. Not a dependency a router
   can take on a peer's internals.
 
-`createRootAtom({ basePath })` gets the useful half of the idea in one store: route
+`rootRouteAtom({ basePath })` gets the useful half of the idea in one store: route
 atoms below it are static module-level values, and the prefix is named once, on the
 root, where a `reverse()` can prepend it again.
 
@@ -121,12 +121,12 @@ to the matched branch when `Always` is `true`, and every constructor threading t
 type-surgery dependency — and assignability survives, because `RouteAtom` is covariant in its
 read type. Three things sink it anyway:
 
-- **The provable class is almost empty.** Only `rootAtom` (or `createRootAtom()` with no
+- **The provable class is almost empty.** Only `rootRoute` (or `rootRouteAtom()` with no
   `basePath`) is unconditionally total, and every path route can miss by construction, so a
-  chain qualifies only if it binds nothing off the path at all: optional `queryParamAtom`s and
+  chain qualifies only if it binds nothing off the path at all: optional `queryParamRouteAtom`s and
   total `transformRouteAtom`s, and nothing else.
 - **It doesn't cover the case that motivated it.** The data-grid demo roots on
-  `createRootAtom({ basePath: "/demos/data-grid" })`, which reports `match: false` for any
+  `rootRouteAtom({ basePath: "/demos/data-grid" })`, which reports `match: false` for any
   location outside the prefix. A sound derivation has to call that chain partial. What actually
   guarantees the match is the `<Route>` the demo is mounted under — knowledge that lives above
   the atoms and can't be recovered from them.
@@ -138,3 +138,47 @@ A manual `alwaysMatches: true` opt-in avoids the derivation entirely and was rej
 soundness: it makes the type assert something nothing checks, so a wrong guarantee surfaces as
 `undefined` field access far from the claim. `requireMatch` is the same assertion made by the
 same caller, checked, and thrown at the point it is wrong.
+
+## Naming: `*RouteAtom` vs `*Atom`
+
+The suffix names the return type. An export whose value is a `RouteAtom` — something you can read
+for a `RouteReturn`, write param values to in order to navigate, pass as another route's `parent`,
+or hand to `<Route on={...}>` — ends in `RouteAtom`. An export that is any other kind of atom ends
+in `Atom` alone.
+
+So `routeAtom`, `staticRouteAtom`, `paramRouteAtom`, `numericRouteAtom`, `transformRouteAtom`,
+`validateRouteAtom`, `queryParamRouteAtom`, `redirectRouteAtom`, `asyncRouteAtom`,
+`rootRouteAtom` and `rootRoute` are all routes; `locationAtom` (the location they read
+from), `queryAtom` (the whole query string as state), `notAtom` (`Atom<boolean>`) and
+`navigationGuardAtom` (`Atom<string | null>`) are not. The rule already held at the type level —
+`RouteAtom` and `AsyncRouteAtom` against `NavigationGuardAtom` — before the values were brought
+into line with it.
+
+One export sits outside the return-type rule even though it is a route: `rootRoute`. Every other
+name above is a factory — it takes an argument, even an optional one, and returns an atom
+instance — which already matches jotai core's own convention that a `...Atom`-suffixed export
+is a _factory_ for an atom instance, not the instance itself (`atomFamily`, `atomWithStorage`,
+and every route/guard constructor in this package). `rootRoute` is not a factory; it is the one
+no-arg default instance built by calling its own factory, `rootRouteAtom({ basePath })`. Naming
+that instance `rootRouteAtom` (as first landed) put a value on the factory side of jotai's
+convention; renaming the instance to `rootRoute` and promoting the factory from
+`createRootRouteAtom` to `rootRouteAtom` puts both back on the right side — the bare word names
+the value, the `Atom`-suffixed word names what makes one. This is not a second suffix rule: it
+only bites where a factory and its own ready-made instance share one root word, which happens
+exactly once in this package. `queryAtom` is a singleton with no factory of its own name
+competing for it, and every other `*RouteAtom` is a pure factory with no default instance, so the
+return-type rule above still decides their names outright.
+
+The distinction is worth carrying in the names because the two categories are not
+interchangeable anywhere they appear, and the pairs that read alike are exactly the ones that
+mislead: `rootRoute` and `locationAtom` are both ambient singletons but only one is a route,
+and `queryAtom` and `queryParamRouteAtom` sound like two flavours of query state when only the
+second participates in matching. An options type takes its atom's name minus the `Atom`
+(`RootRouteOptions`, `QueryParamRouteOptions`, `NumericRouteOptions`).
+
+Dropping `Route` from every name instead was rejected: `routeAtom` would collide with jotai's own
+`atom`, and `staticAtom`/`paramAtom` name nothing.
+
+No deprecated aliases were kept for the old names. Two names per export would make the surface
+less consistent rather than more, which is the opposite of the point, and the alias would then
+need its own removal later.
diff --git a/packages/jarl-atoms/README.md b/packages/jarl-atoms/README.md
index dc25cb3..d2066a8 100644
--- a/packages/jarl-atoms/README.md
+++ b/packages/jarl-atoms/README.md
@@ -23,13 +23,13 @@ npm install jarl-atoms jotai
 
 ## Usage
 
-Routes are built up from `rootAtom` (or `createRootAtom()` for a scoped
+Routes are built up from `rootRoute` (or `rootRouteAtom()` for a scoped
 `basePath`) using `staticRouteAtom` and `paramRouteAtom`, each optionally
 nested under a `parent`:
 
 ```ts
 import { createStore } from "jotai/vanilla";
-import { staticRouteAtom, paramRouteAtom, rootAtom } from "jarl-atoms";
+import { staticRouteAtom, paramRouteAtom, rootRoute } from "jarl-atoms";
 
 const docsAtom = staticRouteAtom("docs");
 const docAtom = paramRouteAtom("docName", { parent: docsAtom });
@@ -49,8 +49,8 @@ store.set(docAtom, { docName: "getting-started" });
 const href = store.get(docAtom).reverse({ docName: "getting-started" });
 ```
 
-Other exports: `queryAtom`/`queryParamAtom` (query-string state, composable
-the same way as path atoms), `redirectAtom`, and `asyncRouteAtom` (async data for
+Other exports: `queryAtom`/`queryParamRouteAtom` (query-string state, composable
+the same way as path atoms), `redirectRouteAtom`, and `asyncRouteAtom` (async data for
 a route, read as `.data`; read as a route instead and the route exists only if
 the load found something, with what it found bound to the route's values). See
 the full docs and demos for the complete model:
diff --git a/packages/jarl-atoms/src/__tests__/asyncRouteAtom.test.ts b/packages/jarl-atoms/src/__tests__/asyncRouteAtom.test.ts
index 096feff..5c57b00 100644
--- a/packages/jarl-atoms/src/__tests__/asyncRouteAtom.test.ts
+++ b/packages/jarl-atoms/src/__tests__/asyncRouteAtom.test.ts
@@ -10,7 +10,7 @@ import {
 import { locationAtom } from "../locationAtom";
 import { notAtom } from "../notAtom";
 import { paramRouteAtom } from "../paramRouteAtom";
-import { isRedirect, redirect } from "../redirectAtom";
+import { isRedirect, redirect } from "../redirectRouteAtom";
 import { staticRouteAtom } from "../staticRouteAtom";
 
 type Post = { slug: string; title: string };
diff --git a/packages/jarl-atoms/src/__tests__/notAtom.test.ts b/packages/jarl-atoms/src/__tests__/notAtom.test.ts
index fd2c81e..cf995ac 100644
--- a/packages/jarl-atoms/src/__tests__/notAtom.test.ts
+++ b/packages/jarl-atoms/src/__tests__/notAtom.test.ts
@@ -37,7 +37,7 @@ describe("notAtom", () => {
   });
 
   it("checks exactness rather than a bare match", () => {
-    // rootAtom (and any ancestor) is `match: true` for every path beneath
+    // rootRoute (and any ancestor) is `match: true` for every path beneath
     // it, so notAtom would never fire if it counted match instead of exact.
     const store = createStore();
     const about = staticRouteAtom("about");
diff --git a/packages/jarl-atoms/src/__tests__/queryAtom.test.ts b/packages/jarl-atoms/src/__tests__/queryAtom.test.ts
index 51084a3..fce6d54 100644
--- a/packages/jarl-atoms/src/__tests__/queryAtom.test.ts
+++ b/packages/jarl-atoms/src/__tests__/queryAtom.test.ts
@@ -1,7 +1,7 @@
 import { createStore } from "jotai/vanilla";
 import { beforeEach, describe, expect, it } from "vitest";
 import { locationAtom } from "../locationAtom";
-import { parseQuery, queryAtom, queryParamAtom, stringifyQuery } from "../queryAtom";
+import { parseQuery, queryAtom, queryParamRouteAtom, stringifyQuery } from "../queryAtom";
 import { staticRouteAtom } from "../staticRouteAtom";
 
 const seed = (store: ReturnType<typeof createStore>, pathname: string, search = "") => {
@@ -49,7 +49,7 @@ describe("queryAtom", () => {
   });
 });
 
-describe("queryParamAtom", () => {
+describe("queryParamRouteAtom", () => {
   let store: ReturnType<typeof createStore>;
 
   beforeEach(() => {
@@ -58,14 +58,14 @@ describe("queryParamAtom", () => {
 
   it("does not match when its parent route doesn't match", () => {
     const fooAtom = staticRouteAtom("foo");
-    const pageAtom = queryParamAtom("page", { parent: fooAtom });
+    const pageAtom = queryParamRouteAtom("page", { parent: fooAtom });
     seed(store, "/bar", "page=2");
     expect(store.get(pageAtom).match).toBe(false);
   });
 
   it("matches and captures the query value once the parent matches", () => {
     const fooAtom = staticRouteAtom("foo");
-    const pageAtom = queryParamAtom("page", { parent: fooAtom });
+    const pageAtom = queryParamRouteAtom("page", { parent: fooAtom });
     seed(store, "/foo", "page=2");
     const result = store.get(pageAtom);
     expect(result.match).toBe(true);
@@ -76,7 +76,7 @@ describe("queryParamAtom", () => {
 
   it("value is undefined (not a non-match) when the param is absent and not required", () => {
     const fooAtom = staticRouteAtom("foo");
-    const pageAtom = queryParamAtom("page", { parent: fooAtom });
+    const pageAtom = queryParamRouteAtom("page", { parent: fooAtom });
     seed(store, "/foo");
     const result = store.get(pageAtom);
     expect(result.match).toBe(true);
@@ -87,14 +87,14 @@ describe("queryParamAtom", () => {
 
   it("required: true makes a missing param a non-match", () => {
     const fooAtom = staticRouteAtom("foo");
-    const pageAtom = queryParamAtom("page", { parent: fooAtom, required: true });
+    const pageAtom = queryParamRouteAtom("page", { parent: fooAtom, required: true });
     seed(store, "/foo");
     expect(store.get(pageAtom).match).toBe(false);
   });
 
   it("reverse() combines the parent path with this query param", () => {
     const fooAtom = staticRouteAtom("foo");
-    const pageAtom = queryParamAtom("page", { parent: fooAtom });
+    const pageAtom = queryParamRouteAtom("page", { parent: fooAtom });
     seed(store, "/foo");
     const href = store.get(pageAtom).reverse({ page: "3" });
     expect(href).toBe("/foo?page=3");
@@ -102,7 +102,7 @@ describe("queryParamAtom", () => {
 
   it("writing navigates to the parent path with the query param set", () => {
     const fooAtom = staticRouteAtom("foo");
-    const pageAtom = queryParamAtom("page", { parent: fooAtom });
+    const pageAtom = queryParamRouteAtom("page", { parent: fooAtom });
     seed(store, "/");
     store.set(pageAtom, { page: "5" });
     expect(store.get(locationAtom).pathname).toBe("/foo");
@@ -111,7 +111,7 @@ describe("queryParamAtom", () => {
 
   it("path matching underneath is unaffected by a composed query param", () => {
     const fooAtom = staticRouteAtom("foo");
-    const pageAtom = queryParamAtom("page", { parent: fooAtom });
+    const pageAtom = queryParamRouteAtom("page", { parent: fooAtom });
     seed(store, "/foo", "page=2");
     const result = store.get(pageAtom);
     expect(result.match).toBe(true);
diff --git a/packages/jarl-atoms/src/__tests__/redirectAtom.test.ts b/packages/jarl-atoms/src/__tests__/redirectRouteAtom.test.ts
similarity index 76%
rename from packages/jarl-atoms/src/__tests__/redirectAtom.test.ts
rename to packages/jarl-atoms/src/__tests__/redirectRouteAtom.test.ts
index 9e8ef2f..b96fe39 100644
--- a/packages/jarl-atoms/src/__tests__/redirectAtom.test.ts
+++ b/packages/jarl-atoms/src/__tests__/redirectRouteAtom.test.ts
@@ -1,8 +1,8 @@
 import { createStore } from "jotai/vanilla";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { locationAtom } from "../locationAtom";
-import { queryParamAtom } from "../queryAtom";
-import { Redirect, followRedirects, isRedirect, redirect, redirectAtom } from "../redirectAtom";
+import { queryParamRouteAtom } from "../queryAtom";
+import { Redirect, followRedirects, isRedirect, redirect, redirectRouteAtom } from "../redirectRouteAtom";
 import { staticRouteAtom } from "../staticRouteAtom";
 
 const seed = (store: ReturnType<typeof createStore>, pathname: string, search = "") => {
@@ -24,7 +24,7 @@ describe("redirect / isRedirect", () => {
   });
 });
 
-describe("redirectAtom", () => {
+describe("redirectRouteAtom", () => {
   let store: ReturnType<typeof createStore>;
 
   beforeEach(() => {
@@ -33,21 +33,21 @@ describe("redirectAtom", () => {
 
   it("matches whenever its parent matches, static target", () => {
     const movedAtom = staticRouteAtom("moved");
-    const toHome = redirectAtom("/", { parent: movedAtom });
+    const toHome = redirectRouteAtom("/", { parent: movedAtom });
     seed(store, "/moved");
     expect(store.get(toHome).match).toBe(true);
   });
 
   it("does not match when its parent doesn't match", () => {
     const movedAtom = staticRouteAtom("moved");
-    const toHome = redirectAtom("/", { parent: movedAtom });
+    const toHome = redirectRouteAtom("/", { parent: movedAtom });
     seed(store, "/somewhere-else");
     expect(store.get(toHome).match).toBe(false);
   });
 
   it("swallows any remaining path (exact: true, no children can match beneath it)", () => {
     const movedAtom = staticRouteAtom("moved");
-    const toHome = redirectAtom("/", { parent: movedAtom });
+    const toHome = redirectRouteAtom("/", { parent: movedAtom });
     seed(store, "/moved/some/deep/path");
     const result = store.get(toHome);
     expect(result.match).toBe(true);
@@ -58,9 +58,9 @@ describe("redirectAtom", () => {
   });
 
   it("supports a dynamic target computed from other atoms", () => {
-    const reasonAtom = queryParamAtom("because");
+    const reasonAtom = queryParamRouteAtom("because");
     const movedAtom = staticRouteAtom("moved");
-    const toHomeWithReason = redirectAtom((get) => `/?because=${get(reasonAtom).values?.because ?? "unknown"}`, {
+    const toHomeWithReason = redirectRouteAtom((get) => `/?because=${get(reasonAtom).values?.because ?? "unknown"}`, {
       parent: movedAtom,
     });
     seed(store, "/moved", "because=Permanently%20moved");
@@ -69,7 +69,7 @@ describe("redirectAtom", () => {
 
   it("writing performs a replace navigation to the target", () => {
     const movedAtom = staticRouteAtom("moved");
-    const toHome = redirectAtom("/", { parent: movedAtom });
+    const toHome = redirectRouteAtom("/", { parent: movedAtom });
     seed(store, "/moved");
     const pushSpy = vi.spyOn(window.history, "pushState");
     const replaceSpy = vi.spyOn(window.history, "replaceState");
@@ -93,8 +93,8 @@ describe("followRedirects", () => {
   });
 
   it("follows immediately if the redirect already matches when subscribed", () => {
-    const banned = queryParamAtom("banned", { required: true });
-    const toBannedPage = redirectAtom("/banned-page", { parent: banned });
+    const banned = queryParamRouteAtom("banned", { required: true });
+    const toBannedPage = redirectRouteAtom("/banned-page", { parent: banned });
     seed(store, "/", "banned=1");
 
     const unsubscribe = followRedirects(store, [toBannedPage]);
@@ -103,8 +103,8 @@ describe("followRedirects", () => {
   });
 
   it("does nothing while the redirect doesn't match", () => {
-    const banned = queryParamAtom("banned", { required: true });
-    const toBannedPage = redirectAtom("/banned-page", { parent: banned });
+    const banned = queryParamRouteAtom("banned", { required: true });
+    const toBannedPage = redirectRouteAtom("/banned-page", { parent: banned });
     seed(store, "/");
 
     const unsubscribe = followRedirects(store, [toBannedPage]);
@@ -113,8 +113,8 @@ describe("followRedirects", () => {
   });
 
   it("follows once the condition starts matching later", () => {
-    const banned = queryParamAtom("banned", { required: true });
-    const toBannedPage = redirectAtom("/banned-page", { parent: banned });
+    const banned = queryParamRouteAtom("banned", { required: true });
+    const toBannedPage = redirectRouteAtom("/banned-page", { parent: banned });
     seed(store, "/");
 
     const unsubscribe = followRedirects(store, [toBannedPage]);
@@ -126,8 +126,8 @@ describe("followRedirects", () => {
   });
 
   it("stops reacting once unsubscribed", () => {
-    const banned = queryParamAtom("banned", { required: true });
-    const toBannedPage = redirectAtom("/banned-page", { parent: banned });
+    const banned = queryParamRouteAtom("banned", { required: true });
+    const toBannedPage = redirectRouteAtom("/banned-page", { parent: banned });
     seed(store, "/");
 
     const unsubscribe = followRedirects(store, [toBannedPage]);
diff --git a/packages/jarl-atoms/src/__tests__/requireMatch.test.ts b/packages/jarl-atoms/src/__tests__/requireMatch.test.ts
index 0c9b7a5..04b11cc 100644
--- a/packages/jarl-atoms/src/__tests__/requireMatch.test.ts
+++ b/packages/jarl-atoms/src/__tests__/requireMatch.test.ts
@@ -1,7 +1,7 @@
 import { createStore } from "jotai/vanilla";
 import { describe, expect, expectTypeOf, it } from "vitest";
 import { locationAtom } from "../locationAtom";
-import { queryParamAtom } from "../queryAtom";
+import { queryParamRouteAtom } from "../queryAtom";
 import { requireMatch } from "../requireMatch";
 import { staticRouteAtom } from "../staticRouteAtom";
 import { MatchedRoute, RouteReturn } from "../types";
@@ -15,7 +15,7 @@ const seed = (store: ReturnType<typeof createStore>, pathname: string, search =
 const readSort = (search: string): RouteReturn<SortValues> => {
   const store = createStore();
   seed(store, "/", search);
-  return store.get(queryParamAtom("sort"));
+  return store.get(queryParamRouteAtom("sort"));
 };
 
 describe("requireMatch", () => {
diff --git a/packages/jarl-atoms/src/__tests__/routeAtom.test.ts b/packages/jarl-atoms/src/__tests__/routeAtom.test.ts
index 569cbbc..ad50f2d 100644
--- a/packages/jarl-atoms/src/__tests__/routeAtom.test.ts
+++ b/packages/jarl-atoms/src/__tests__/routeAtom.test.ts
@@ -3,7 +3,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { locationAtom } from "../locationAtom";
 import { numericRouteAtom } from "../numericRouteAtom";
 import { paramRouteAtom } from "../paramRouteAtom";
-import { createRootAtom, rootAtom } from "../rootAtom";
+import { rootRouteAtom, rootRoute } from "../rootRouteAtom";
 import { routeAtom } from "../routeAtom";
 import { staticRouteAtom } from "../staticRouteAtom";
 import { transformRouteAtom } from "../transformRouteAtom";
@@ -24,11 +24,11 @@ const seed = (store: ReturnType<typeof createStore>, pathname: string, search =
   store.set(locationAtom, { pathname, searchParams: new URLSearchParams(search) });
 };
 
-describe("rootAtom", () => {
+describe("rootRoute", () => {
   it("matches the root path exactly by default", () => {
     const store = createStore();
 
-    const result = store.get(rootAtom);
+    const result = store.get(rootRoute);
 
     assertMatch(result);
     expect(result.exact).toBe(true);
@@ -38,7 +38,7 @@ describe("rootAtom", () => {
   it("normalizes a trailing slash the same as no trailing slash", () => {
     const store = createStore();
     // A route whose own segment name embeds the trailing slash, so we can
-    // exercise rootAtom's normalization purely through the atoms' own
+    // exercise rootRoute's normalization purely through the atoms' own
     // setters rather than reaching into window.location directly.
     const trailing = routeAtom(
       (path) => (path === "trailing" ? {} : undefined),
@@ -47,7 +47,7 @@ describe("rootAtom", () => {
 
     store.set(trailing, {});
 
-    const root = store.get(rootAtom);
+    const root = store.get(rootRoute);
     assertMatch(root);
     expect(root.rest.path).toEqual(["trailing"]);
 
@@ -330,7 +330,7 @@ describe("routeAtom", () => {
   });
 });
 
-describe("createRootAtom with basePath", () => {
+describe("rootRouteAtom with basePath", () => {
   let store: ReturnType<typeof createStore>;
 
   beforeEach(() => {
@@ -338,7 +338,7 @@ describe("createRootAtom with basePath", () => {
   });
 
   it("matches at the base path itself", () => {
-    const appRoot = createRootAtom({ basePath: "/app" });
+    const appRoot = rootRouteAtom({ basePath: "/app" });
     seed(store, "/app");
     const result = store.get(appRoot);
     expect(result.match).toBe(true);
@@ -348,27 +348,27 @@ describe("createRootAtom with basePath", () => {
   });
 
   it("strips the base path before matching children", () => {
-    const appRoot = createRootAtom({ basePath: "/app" });
+    const appRoot = rootRouteAtom({ basePath: "/app" });
     const fooAtom = staticRouteAtom("foo", { parent: appRoot });
     seed(store, "/app/foo");
     expect(store.get(fooAtom).match).toBe(true);
   });
 
   it("does not match locations outside of the base path", () => {
-    const appRoot = createRootAtom({ basePath: "/app" });
+    const appRoot = rootRouteAtom({ basePath: "/app" });
     seed(store, "/other");
     expect(store.get(appRoot).match).toBe(false);
   });
 
   it("does not treat a similarly-prefixed path as inside the base path", () => {
     // "/app-other" should NOT be considered inside basePath "/app"
-    const appRoot = createRootAtom({ basePath: "/app" });
+    const appRoot = rootRouteAtom({ basePath: "/app" });
     seed(store, "/app-other");
     expect(store.get(appRoot).match).toBe(false);
   });
 
   it("reverse()/write prepend the base path", () => {
-    const appRoot = createRootAtom({ basePath: "/app" });
+    const appRoot = rootRouteAtom({ basePath: "/app" });
     const fooAtom = staticRouteAtom("foo", { parent: appRoot });
     seed(store, "/app");
     const href = store.get(fooAtom).reverse({});
diff --git a/packages/jarl-atoms/src/__tests__/validateAtom.test.ts b/packages/jarl-atoms/src/__tests__/validateRouteAtom.test.ts
similarity index 91%
rename from packages/jarl-atoms/src/__tests__/validateAtom.test.ts
rename to packages/jarl-atoms/src/__tests__/validateRouteAtom.test.ts
index 3fa7873..d83c166 100644
--- a/packages/jarl-atoms/src/__tests__/validateAtom.test.ts
+++ b/packages/jarl-atoms/src/__tests__/validateRouteAtom.test.ts
@@ -4,7 +4,7 @@ import { locationAtom } from "../locationAtom";
 import { numericRouteAtom } from "../numericRouteAtom";
 import { paramRouteAtom } from "../paramRouteAtom";
 import { staticRouteAtom } from "../staticRouteAtom";
-import { validateAtom } from "../validateAtom";
+import { validateRouteAtom } from "../validateRouteAtom";
 
 const seed = (store: ReturnType<typeof createStore>, pathname: string) => {
   store.set(locationAtom, { pathname, searchParams: new URLSearchParams() });
@@ -20,10 +20,10 @@ const calendarRoute = () => {
   const year = numericRouteAtom("year", { parent: blog });
   const month = numericRouteAtom("month", { parent: year, min: 1, max: 12 });
   const day = numericRouteAtom("day", { parent: month });
-  return validateAtom(day, (values) => isValidCalendarDate(values.year, values.month, values.day));
+  return validateRouteAtom(day, (values) => isValidCalendarDate(values.year, values.month, values.day));
 };
 
-describe("validateAtom", () => {
+describe("validateRouteAtom", () => {
   it("matches, with the wrapped route's values, when the predicate accepts", () => {
     const store = createStore();
     const date = calendarRoute();
@@ -91,7 +91,7 @@ describe("validateAtom", () => {
     const store = createStore();
     const openYears = atom([2024]);
     const year = numericRouteAtom("year", { parent: staticRouteAtom("blog") });
-    const open = validateAtom(year, (values, get) => get(openYears).includes(values.year));
+    const open = validateRouteAtom(year, (values, get) => get(openYears).includes(values.year));
     seed(store, "/blog/2023");
 
     expect(store.get(open).match).toBe(false);
diff --git a/packages/jarl-atoms/src/asyncRouteAtom.ts b/packages/jarl-atoms/src/asyncRouteAtom.ts
index bbda5e3..71abbb4 100644
--- a/packages/jarl-atoms/src/asyncRouteAtom.ts
+++ b/packages/jarl-atoms/src/asyncRouteAtom.ts
@@ -1,7 +1,7 @@
 import { Atom, Getter, WritableAtom, atom } from "jotai/vanilla";
 import { splitHref } from "./href";
 import { locationAtom } from "./locationAtom";
-import { Redirect, Store, isRedirect } from "./redirectAtom";
+import { Redirect, Store, isRedirect } from "./redirectRouteAtom";
 import { transformRouteAtom } from "./transformRouteAtom";
 import { DefaultParams, RouteAtom } from "./types";
 
diff --git a/packages/jarl-atoms/src/index.ts b/packages/jarl-atoms/src/index.ts
index 1d57be4..bb9ac25 100644
--- a/packages/jarl-atoms/src/index.ts
+++ b/packages/jarl-atoms/src/index.ts
@@ -7,16 +7,16 @@ export * from "./types";
 export * from "./requireMatch";
 export * from "./locationAtom";
 export * from "./routeAtom";
-export * from "./rootAtom";
+export * from "./rootRouteAtom";
 export * from "./staticRouteAtom";
 export * from "./paramRouteAtom";
 export * from "./numericRouteAtom";
 export * from "./transformRouteAtom";
-export * from "./validateAtom";
+export * from "./validateRouteAtom";
 export * from "./notAtom";
 export * from "./href";
 export * from "./queryAtom";
-export * from "./redirectAtom";
+export * from "./redirectRouteAtom";
 export * from "./asyncRouteAtom";
 // Named rather than `export *`: the rest of the module is the machinery `locationAtom` calls into.
 export { enforceNavigationGuards, navigationGuardAtom } from "./navigationGuardAtom";
diff --git a/packages/jarl-atoms/src/navigationGuardAtom.ts b/packages/jarl-atoms/src/navigationGuardAtom.ts
index 4330987..ed9788d 100644
--- a/packages/jarl-atoms/src/navigationGuardAtom.ts
+++ b/packages/jarl-atoms/src/navigationGuardAtom.ts
@@ -1,5 +1,5 @@
 import { Atom, Getter, atom } from "jotai/vanilla";
-import type { Store } from "./redirectAtom";
+import type { Store } from "./redirectRouteAtom";
 
 /** A guard's verdict: the message to confirm a navigation with, or `null` to let it through. */
 export type NavigationGuardAtom = Atom<string | null>;
diff --git a/packages/jarl-atoms/src/notAtom.ts b/packages/jarl-atoms/src/notAtom.ts
index 786ffbb..f811225 100644
--- a/packages/jarl-atoms/src/notAtom.ts
+++ b/packages/jarl-atoms/src/notAtom.ts
@@ -4,7 +4,7 @@ import { RouteAtom } from "./types";
 /**
  * Matches when none of the given route atoms are an exact match - the
  * inverse of a router's full route list, for a catch-all/not-found case.
- * Checks `exact` rather than `match`: an ancestor route (or `rootAtom`
+ * Checks `exact` rather than `match`: an ancestor route (or `rootRoute`
  * itself) can be `match: true` without being the leaf that actually
  * rendered, and only the leaf's exactness should count.
  */
diff --git a/packages/jarl-atoms/src/queryAtom.ts b/packages/jarl-atoms/src/queryAtom.ts
index 6d7ec85..92afde0 100644
--- a/packages/jarl-atoms/src/queryAtom.ts
+++ b/packages/jarl-atoms/src/queryAtom.ts
@@ -6,7 +6,7 @@
 // declare a whole map of named query matchers. That's a lot of
 // surface area to port 1:1 into the atomic model in one pass. Instead this
 // implements the common, composable subset: a single named query param as
-// its own RouteAtom-shaped leaf (`queryParamAtom`), plus a raw whole-query
+// its own RouteAtom-shaped leaf (`queryParamRouteAtom`), plus a raw whole-query
 // atom (`queryAtom`) for reading/writing everything at once. Both are built
 // on plain `URLSearchParams`, deliberately not supporting `qs`'s nested/array
 // query syntax - v1 itself flags that as a known limitation
@@ -16,7 +16,7 @@
 import { Getter, atom } from "jotai/vanilla";
 import { appendQueryParam, splitHref } from "./href";
 import { locationAtom } from "./locationAtom";
-import { rootAtom } from "./rootAtom";
+import { rootRoute } from "./rootRouteAtom";
 import { DefaultParams, NavOptions, RouteAtom, RouteOptions } from "./types";
 
 /** Parses a `URLSearchParams` (or query string) into a plain object. Repeated
@@ -70,7 +70,7 @@ export const queryAtom = atom(
 );
 
 /** `RouteOptions` plus whether the param must be present for the route to match. */
-export type QueryParamOptions<Parent extends DefaultParams> = RouteOptions<Parent> & {
+export type QueryParamRouteOptions<Parent extends DefaultParams> = RouteOptions<Parent> & {
   /** Makes a missing query param a non-match; by default it just yields `undefined`. */
   required?: boolean;
 };
@@ -83,11 +83,11 @@ export type QueryParamOptions<Parent extends DefaultParams> = RouteOptions<Paren
  * path matching continues unaffected by however many query params are
  * chained on.
  */
-export const queryParamAtom = <T extends string, Parent extends DefaultParams = DefaultParams>(
+export const queryParamRouteAtom = <T extends string, Parent extends DefaultParams = DefaultParams>(
   name: T,
-  options?: QueryParamOptions<Parent>,
+  options?: QueryParamRouteOptions<Parent>,
 ): RouteAtom<{ readonly [key in T]: string | undefined } & Parent> => {
-  const parentAtom = options?.parent || (rootAtom as RouteAtom<Parent>);
+  const parentAtom = options?.parent || (rootRoute as RouteAtom<Parent>);
   type Values = { readonly [key in T]: string | undefined };
 
   const reverse =
diff --git a/packages/jarl-atoms/src/redirectAtom.ts b/packages/jarl-atoms/src/redirectRouteAtom.ts
similarity index 85%
rename from packages/jarl-atoms/src/redirectAtom.ts
rename to packages/jarl-atoms/src/redirectRouteAtom.ts
index 33315dd..6416cd6 100644
--- a/packages/jarl-atoms/src/redirectAtom.ts
+++ b/packages/jarl-atoms/src/redirectRouteAtom.ts
@@ -8,11 +8,11 @@
 // v1 does this as a side effect inside RoutingProvider.doNavigation, which
 // both matches a route AND performs the navigation as one imperative step.
 // Atoms split that in two, on purpose:
-//   - redirectAtom: a *pure* RouteAtom-shaped leaf - reading it just tells
+//   - redirectRouteAtom: a *pure* RouteAtom-shaped leaf - reading it just tells
 //     you whether the redirect route currently matches, exactly like any
 //     other route. No side effects happen just from reading it.
 //   - followRedirects: the actual effect - given a jotai store and one or
-//     more redirectAtoms, subscribes to them and performs the
+//     more redirectRouteAtoms, subscribes to them and performs the
 //     history.replace-style navigation the moment one starts matching.
 // This keeps the "does this match" question composable/pure (usable in
 // Route/Link like any other RouteAtom) while isolating the "and now actually
@@ -24,7 +24,7 @@
 import { Getter, atom, createStore } from "jotai/vanilla";
 import { Path, splitHref } from "./href";
 import { locationAtom } from "./locationAtom";
-import { rootAtom } from "./rootAtom";
+import { rootRoute } from "./rootRouteAtom";
 import { DefaultParams, NavOptions, RouteAtom, RouteOptions } from "./types";
 
 /** A sentinel object meaning "actually, redirect to this instead". */
@@ -47,12 +47,12 @@ export const isRedirect = (value: unknown): value is Redirect => value instanceo
  *
  * Reading it is pure: matching one navigates nowhere on its own, see `followRedirects`.
  */
-export const redirectAtom = <Parent extends DefaultParams = DefaultParams>(
+export const redirectRouteAtom = <Parent extends DefaultParams = DefaultParams>(
   to: Path | ((get: Getter) => Path),
   options?: RouteOptions<Parent>,
 ): RouteAtom<Parent> => {
   const target = (get: Getter) => (typeof to === "function" ? to(get) : to);
-  const parentAtom = options?.parent || (rootAtom as RouteAtom<Parent>);
+  const parentAtom = options?.parent || (rootRoute as RouteAtom<Parent>);
 
   const reverse = (get: Getter) => () => target(get);
 
@@ -96,15 +96,15 @@ export type Store = ReturnType<typeof createStore>;
  * one starts matching. Call once, near the root of an app, for every redirect atom you want
  * live. Returns an unsubscribe function.
  */
-export const followRedirects = (store: Store, redirectAtoms: ReadonlyArray<RouteAtom<any>>): (() => void) => {
-  const unsubs = redirectAtoms.map((redirectRouteAtom) => {
+export const followRedirects = (store: Store, redirectRouteAtoms: ReadonlyArray<RouteAtom<any>>): (() => void) => {
+  const unsubs = redirectRouteAtoms.map((route) => {
     const check = () => {
-      const result = store.get(redirectRouteAtom);
+      const result = store.get(route);
       if (result.match) {
-        store.set(redirectRouteAtom, {}, { replace: true });
+        store.set(route, {}, { replace: true });
       }
     };
-    const unsub = store.sub(redirectRouteAtom, check);
+    const unsub = store.sub(route, check);
     check();
     return unsub;
   });
diff --git a/packages/jarl-atoms/src/rootAtom.ts b/packages/jarl-atoms/src/rootRouteAtom.ts
similarity index 90%
rename from packages/jarl-atoms/src/rootAtom.ts
rename to packages/jarl-atoms/src/rootRouteAtom.ts
index fe95a13..a4aa2cb 100644
--- a/packages/jarl-atoms/src/rootAtom.ts
+++ b/packages/jarl-atoms/src/rootRouteAtom.ts
@@ -3,8 +3,8 @@ import { Path, normalizePathname } from "./href";
 import { locationAtom } from "./locationAtom";
 import { DefaultParams, RouteAtom } from "./types";
 
-/** Options for `createRootAtom`. */
-export type RootOptions = {
+/** Options for `rootRouteAtom`. */
+export type RootRouteOptions = {
   /**
    * Scopes the router to a subtree of the URL: the prefix is stripped from the pathname before
    * matching begins, and prepended again by `reverse`/write. A location outside `basePath` makes
@@ -23,10 +23,10 @@ const stripBasePath = (pathname: string, basePath: string): string | undefined =
 };
 
 /**
- * Creates a root RouteAtom. Call this instead of using the default `rootAtom` export when the
+ * Creates a root RouteAtom. Call this instead of using the default `rootRoute` export when the
  * app needs to be scoped under a basePath.
  */
-export const createRootAtom = (options?: RootOptions): RouteAtom<DefaultParams> => {
+export const rootRouteAtom = (options?: RootRouteOptions): RouteAtom<DefaultParams> => {
   const basePath = options?.basePath ? normalizePathname(options.basePath) : "";
   return atom(
     (get) => {
@@ -67,4 +67,4 @@ export const createRootAtom = (options?: RootOptions): RouteAtom<DefaultParams>
 };
 
 /** The default root of every route atom chain: matches `/`, and is the implicit `parent`. */
-export const rootAtom = createRootAtom();
+export const rootRoute = rootRouteAtom();
diff --git a/packages/jarl-atoms/src/routeAtom.ts b/packages/jarl-atoms/src/routeAtom.ts
index fd91816..f568138 100644
--- a/packages/jarl-atoms/src/routeAtom.ts
+++ b/packages/jarl-atoms/src/routeAtom.ts
@@ -3,7 +3,7 @@
 import { Getter, atom } from "jotai/vanilla";
 import { splitHref, Path } from "./href";
 import { locationAtom } from "./locationAtom";
-import { rootAtom } from "./rootAtom";
+import { rootRoute } from "./rootRouteAtom";
 import { DefaultParams, RouteAtom, RouteOptions } from "./types";
 
 export type { Path };
@@ -23,7 +23,7 @@ export const routeAtom = <T extends DefaultParams = DefaultParams, Parent extend
   makePath: (values: T, get: Getter) => string,
   options?: RouteOptions<Parent>,
 ): RouteAtom<T & Parent> => {
-  const parentAtom = options?.parent || (rootAtom as RouteAtom<Parent>);
+  const parentAtom = options?.parent || (rootRoute as RouteAtom<Parent>);
   // TODO: To avoid unnecessary recomputes we should be caching a memoization of the unmatched
   // state, this way we won't recalculate all leaves of an unmatched branch
   const reverse = (get: Getter) => (values: T) => {
diff --git a/packages/jarl-atoms/src/types.ts b/packages/jarl-atoms/src/types.ts
index 7b0fb2a..7ef95ad 100644
--- a/packages/jarl-atoms/src/types.ts
+++ b/packages/jarl-atoms/src/types.ts
@@ -64,6 +64,6 @@ export type RouteAtom<T extends DefaultParams> = WritableAtom<RouteReturn<T>, [T
 
 /** Common options for every route atom constructor. */
 export type RouteOptions<Parent extends DefaultParams> = {
-  /** Route this one nests under, matching the segment after its parent's. Defaults to `rootAtom`. */
+  /** Route this one nests under, matching the segment after its parent's. Defaults to `rootRoute`. */
   parent?: RouteAtom<Parent>;
 };
diff --git a/packages/jarl-atoms/src/validateAtom.ts b/packages/jarl-atoms/src/validateRouteAtom.ts
similarity index 89%
rename from packages/jarl-atoms/src/validateAtom.ts
rename to packages/jarl-atoms/src/validateRouteAtom.ts
index f8431cc..b3b0272 100644
--- a/packages/jarl-atoms/src/validateAtom.ts
+++ b/packages/jarl-atoms/src/validateRouteAtom.ts
@@ -3,13 +3,13 @@ import { transformRouteAtom } from "./transformRouteAtom";
 import { DefaultParams, RouteAtom } from "./types";
 
 /**
- * Narrows a route to the values a predicate accepts, leaving the rest unmatched: `validateAtom(day,
+ * Narrows a route to the values a predicate accepts, leaving the rest unmatched: `validateRouteAtom(day,
  * ({ year, month, day }) => isValidCalendarDate(year, month, day))` matches `/:year/:month/:day`
  * only on real dates, so 31 February falls through to whatever handles a non-matching URL. Use it
  * for constraints spanning several segments, which no single segment's own options can express.
  * The predicate also gets a `Getter`, so it can validate against other atoms.
  */
-export const validateAtom = <T extends DefaultParams>(
+export const validateRouteAtom = <T extends DefaultParams>(
   parentAtom: RouteAtom<T>,
   isValid: (values: T, get: Getter) => boolean,
 ): RouteAtom<T> =>
diff --git a/packages/jarl-react/src/__tests__/fixtures.ts b/packages/jarl-react/src/__tests__/fixtures.ts
index 5f7bab6..e9bbeae 100644
--- a/packages/jarl-react/src/__tests__/fixtures.ts
+++ b/packages/jarl-react/src/__tests__/fixtures.ts
@@ -1,7 +1,7 @@
 import { staticRouteAtom, paramRouteAtom } from "jarl-atoms";
 
 // Shared route atom fixtures used across the binding tests:
-//   /               -> rootAtom (imported directly by tests that need it)
+//   /               -> rootRoute (imported directly by tests that need it)
 //   /about          -> aboutAtom
 //   /about/team     -> teamAtom
 //   /users          -> usersAtom
diff --git a/packages/jarl-react/src/__tests__/hooks.test.tsx b/packages/jarl-react/src/__tests__/hooks.test.tsx
index 8346890..5833330 100644
--- a/packages/jarl-react/src/__tests__/hooks.test.tsx
+++ b/packages/jarl-react/src/__tests__/hooks.test.tsx
@@ -2,7 +2,7 @@ import { ReactElement } from "react";
 import { describe, it, expect, beforeEach, expectTypeOf, vi } from "vitest";
 import { render, screen, fireEvent } from "@testing-library/react";
 import { Provider, createStore } from "jotai";
-import { locationAtom, rootAtom } from "jarl-atoms";
+import { locationAtom, rootRoute } from "jarl-atoms";
 import { useRoute, useRequiredRoute, useNavigate, useIsActive, useHref, useLink } from "../hooks";
 import { aboutAtom, teamAtom, userAtom, usersAtom } from "./fixtures";
 
@@ -114,7 +114,7 @@ describe("useIsActive", () => {
   it("treats root as active only at '/'", () => {
     goTo("/about");
     const Probe = () => {
-      const active = useIsActive(rootAtom, { exact: true });
+      const active = useIsActive(rootRoute, { exact: true });
       return <div data-testid="root">{String(active)}</div>;
     };
     render(<Probe />);