From 04c84fc2fbcdb4b6b7de8d628f7a2c2b2e995500 Mon Sep 17 00:00:00 2001
From: Rishabh <me@rsbh.dev>
Date: Wed, 19 Aug 2026 15:02:50 +0530
Subject: [PATCH 1/6] feat: add author pages listing everything an author wrote

Adds an optional `authors` registry to chronicle.yaml holding each
author's name, bio, avatar, url, and email. A frontmatter string that
matches a registry key picks up that profile; anything else still reads
as a plain name, so occasional contributors need no config.

/authors lists everyone found in the content, and /authors/<slug> shows
one author's profile followed by their pages grouped by content dir. The
index is served from /api/authors, written to /data/authors.json for
static builds, and embedded in the SSR payload so both routes render
without JavaScript. A content dir named `authors` keeps its own pages.

Bylines now use the registry avatar and profile link when present.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/content/docs/configuration.mdx           |  33 ++++
 docs/content/docs/frontmatter.mdx             |  14 +-
 examples/basic/chronicle.yaml                 |   7 +
 examples/basic/content/docs/components.mdx    |   1 +
 .../basic/content/docs/getting-started.mdx    |   2 +-
 .../src/cli/commands/static-generate.ts       |  23 ++-
 .../src/components/common/author-byline.tsx   |  18 +-
 .../chronicle/src/lib/author-index.test.ts    | 108 ++++++++++++
 packages/chronicle/src/lib/author-index.ts    |  86 +++++++++
 packages/chronicle/src/lib/authors.test.ts    |  87 ++++++++-
 packages/chronicle/src/lib/authors.ts         |  50 +++++-
 packages/chronicle/src/lib/data-urls.ts       |   4 +
 packages/chronicle/src/lib/page-context.tsx   |   9 +-
 .../chronicle/src/lib/route-resolver.test.ts  |  52 ++++++
 packages/chronicle/src/lib/route-resolver.ts  |  20 +++
 .../src/pages/AuthorsPage.module.css          | 155 ++++++++++++++++
 packages/chronicle/src/pages/AuthorsPage.tsx  | 165 ++++++++++++++++++
 packages/chronicle/src/pages/DocsPage.tsx     |   4 +-
 packages/chronicle/src/server/App.tsx         |  12 ++
 packages/chronicle/src/server/api/authors.ts  |  16 ++
 .../chronicle/src/server/entry-client.tsx     |   4 +
 .../chronicle/src/server/entry-server.tsx     |  23 ++-
 packages/chronicle/src/types/config.ts        |  10 ++
 packages/chronicle/src/types/content.ts       |  10 +-
 24 files changed, 878 insertions(+), 35 deletions(-)
 create mode 100644 packages/chronicle/src/lib/author-index.test.ts
 create mode 100644 packages/chronicle/src/lib/author-index.ts
 create mode 100644 packages/chronicle/src/pages/AuthorsPage.module.css
 create mode 100644 packages/chronicle/src/pages/AuthorsPage.tsx
 create mode 100644 packages/chronicle/src/server/api/authors.ts

diff --git a/docs/content/docs/configuration.mdx b/docs/content/docs/configuration.mdx
index 7b5352d9..cf580974 100644
--- a/docs/content/docs/configuration.mdx
+++ b/docs/content/docs/configuration.mdx
@@ -363,6 +363,39 @@ analytics:
 | `enabled` | `boolean` | Enable/disable analytics | `false` |
 | `googleAnalytics.measurementId` | `string` | Google Analytics measurement ID | — |
 
+### authors
+
+Optional registry of the people who write your docs. Pages reference an entry by
+its key in their `authors` frontmatter, so the details live in one place.
+
+```yaml
+authors:
+  jane:
+    name: Jane Doe
+    bio: Writes about distributed systems.
+    avatar: /team/jane.png
+    url: https://github.com/jane
+    email: jane@example.com
+```
+
+| Field | Type | Description | Default |
+|-------|------|-------------|---------|
+| `name` | `string` | **Required.** Display name | — |
+| `bio` | `string` | Short description shown on the author's page | — |
+| `avatar` | `string` | Image path for the avatar; initials are used without it | — |
+| `url` | `string` | Profile link — the byline links here in preference to the email | — |
+| `email` | `string` | Contact address, linked with `mailto:` | — |
+
+```yaml
+# page.mdx frontmatter
+authors: [jane]
+```
+
+A frontmatter string that matches no key is still valid — it renders as a plain
+name, so occasional contributors need no registry entry. See
+[Frontmatter](/docs/frontmatter) for the field itself, and browse the people
+writing a site at `/authors`.
+
 ### telemetry
 
 Prometheus metrics export via OpenTelemetry. Served on a separate port.
diff --git a/docs/content/docs/frontmatter.mdx b/docs/content/docs/frontmatter.mdx
index 2b7e029d..66073b2a 100644
--- a/docs/content/docs/frontmatter.mdx
+++ b/docs/content/docs/frontmatter.mdx
@@ -106,9 +106,19 @@ authors: Jane Doe <jane@example.com>
 ```
 
 Authors appear as a byline under the page title, in the page's `Article`
-structured data, and on the generated social card. When an email is given, the
+structured data, and on the generated social card. Every author also gets a page
+at `/authors/<slug>` listing everything they wrote, linked from the `/authors`
+index. When an email is given, the
 byline links to it with `mailto:`. The avatar beside each name is drawn from the
-author's initials — no image is fetched.
+author's initials unless the author has an `avatar` in the
+[authors registry](/docs/configuration).
+
+Registry keys work here too, and bring the author's bio, avatar, and profile
+link along with them:
+
+```yaml
+authors: [jane]
+```
 
 ## Navigation Ordering
 
diff --git a/examples/basic/chronicle.yaml b/examples/basic/chronicle.yaml
index b56727ea..be890c65 100644
--- a/examples/basic/chronicle.yaml
+++ b/examples/basic/chronicle.yaml
@@ -13,6 +13,13 @@ content:
     label: Docs
     icon: /icons/docs.svg
 
+authors:
+  jane:
+    name: Jane Doe
+    bio: Writes about the parts of the system nobody else wants to document.
+    url: https://github.com/jane
+    email: jane@example.com
+
 theme:
   name: default
 
diff --git a/examples/basic/content/docs/components.mdx b/examples/basic/content/docs/components.mdx
index cfa63945..94d62759 100644
--- a/examples/basic/content/docs/components.mdx
+++ b/examples/basic/content/docs/components.mdx
@@ -2,6 +2,7 @@
 title: Components
 description: Live demo of Chronicle's built-in MDX components
 order: 3
+authors: [jane]
 ---
 
 # Components
diff --git a/examples/basic/content/docs/getting-started.mdx b/examples/basic/content/docs/getting-started.mdx
index 5da77c9e..69f16e5a 100644
--- a/examples/basic/content/docs/getting-started.mdx
+++ b/examples/basic/content/docs/getting-started.mdx
@@ -3,7 +3,7 @@ title: Getting Started
 description: Quick start guide for Chronicle
 order: 1
 authors:
-  - Jane Doe <jane@example.com>
+  - jane
   - Sam Patel
 ---
 
diff --git a/packages/chronicle/src/cli/commands/static-generate.ts b/packages/chronicle/src/cli/commands/static-generate.ts
index 09d20a99..10760b2b 100644
--- a/packages/chronicle/src/cli/commands/static-generate.ts
+++ b/packages/chronicle/src/cli/commands/static-generate.ts
@@ -24,7 +24,8 @@ import { isAnimatedImage } from '@/lib/image-animation';
 import { getAssetVersion } from '@/lib/asset-version';
 import type { VersionContext } from '@/lib/version-source';
 import type { Frontmatter, PageNavLink } from '@/types';
-import { normalizeAuthorList, parseAuthors } from '@/lib/authors';
+import { buildAuthorIndex } from '@/lib/author-index';
+import { normalizeAuthorList, resolveAuthors } from '@/lib/authors';
 
 export interface StaticGenerateOptions {
   projectRoot: string;
@@ -439,6 +440,21 @@ async function generatePageDataFiles(
   }
 }
 
+/** `/data/authors.json` — what `/api/authors` serves in server mode. */
+async function generateAuthorsData(
+  pages: ScannedPage[],
+  config: ChronicleConfig,
+  outputDir: string,
+): Promise<void> {
+  const index = buildAuthorIndex(
+    pages.map(page => ({ url: page.url, frontmatter: page.frontmatter })),
+    config,
+  );
+  const dataDir = path.join(outputDir, 'data');
+  await fs.mkdir(dataDir, { recursive: true });
+  await fs.writeFile(path.join(dataDir, 'authors.json'), JSON.stringify(index));
+}
+
 async function generateSearchIndex(
   pages: ScannedPage[],
   config: ChronicleConfig,
@@ -633,7 +649,7 @@ async function generateOgImages(
   for (const page of pages) {
     const title = page.frontmatter.title;
     const description = page.frontmatter.description ?? '';
-    const authors = parseAuthors(page.frontmatter.authors)
+    const authors = resolveAuthors(page.frontmatter.authors, config)
       .map(author => author.name)
       .join(', ');
     const slugKey = page.slugs.join(',') || 'index';
@@ -1054,6 +1070,9 @@ export async function generateStaticSite(options: StaticGenerateOptions): Promis
   console.log(chalk.gray('  Generating page data files...'));
   await generatePageDataFiles(pages, navMap, outputDir);
 
+  console.log(chalk.gray('  Generating authors data...'));
+  await generateAuthorsData(pages, config, outputDir);
+
   console.log(chalk.gray('  Generating search index...'));
   await generateSearchIndex(pages, config, outputDir, projectRoot);
 
diff --git a/packages/chronicle/src/components/common/author-byline.tsx b/packages/chronicle/src/components/common/author-byline.tsx
index 64d73105..edd82dd4 100644
--- a/packages/chronicle/src/components/common/author-byline.tsx
+++ b/packages/chronicle/src/components/common/author-byline.tsx
@@ -1,7 +1,8 @@
 'use client'
 
 import { Avatar, getAvatarColor } from '@raystack/apsara'
-import { authorInitials, parseAuthors } from '@/lib/authors'
+import { authorInitials, resolveAuthors } from '@/lib/authors'
+import { usePageContext } from '@/lib/page-context'
 import styles from './author-byline.module.css'
 
 interface AuthorBylineProps {
@@ -12,20 +13,27 @@ interface AuthorBylineProps {
 
 /** Avatar-and-name byline for the authors declared in a page's frontmatter. */
 export function AuthorByline({ authors, className }: AuthorBylineProps) {
-  const parsed = parseAuthors(authors)
+  const { config } = usePageContext()
+  const parsed = resolveAuthors(authors, config)
   if (parsed.length === 0) return null
 
   return (
     <div className={className ? `${styles.byline} ${className}` : styles.byline}>
       {parsed.map((author, index) => (
-        <span className={styles.author} key={`${author.name}-${index}`}>
+        <span className={styles.author} key={`${author.slug}-${index}`}>
           <Avatar
             size={2}
+            src={author.avatar}
+            alt={author.avatar ? author.name : undefined}
             fallback={authorInitials(author.name)}
             color={getAvatarColor(author.name)}
-            aria-hidden='true'
+            aria-hidden={author.avatar ? undefined : 'true'}
           />
-          {author.email ? (
+          {author.url ? (
+            <a className={styles.name} href={author.url} rel='noreferrer' target='_blank'>
+              {author.name}
+            </a>
+          ) : author.email ? (
             <a className={styles.name} href={`mailto:${author.email}`}>
               {author.name}
             </a>
diff --git a/packages/chronicle/src/lib/author-index.test.ts b/packages/chronicle/src/lib/author-index.test.ts
new file mode 100644
index 00000000..1cc21391
--- /dev/null
+++ b/packages/chronicle/src/lib/author-index.test.ts
@@ -0,0 +1,108 @@
+import { describe, expect, test } from 'bun:test';
+import type { ChronicleConfig, Frontmatter } from '@/types';
+import { buildAuthorIndex, findAuthor } from './author-index';
+
+const config = {
+  content: [
+    { dir: 'docs', label: 'Docs' },
+    { dir: 'guides', label: 'Guides' },
+  ],
+  authors: {
+    jane: { name: 'Jane Doe', bio: 'Writes about systems.', avatar: '/team/jane.png' },
+  },
+} as unknown as ChronicleConfig;
+
+function page(url: string, frontmatter: Partial<Frontmatter> & { title: string }) {
+  return { url, frontmatter: frontmatter as Frontmatter }
+}
+
+describe('buildAuthorIndex', () => {
+  test('groups pages under each author', () => {
+    const index = buildAuthorIndex(
+      [
+        page('/docs/a', { title: 'A', authors: ['jane'] }),
+        page('/docs/b', { title: 'B', authors: ['jane', 'Sam Patel'] }),
+      ],
+      config,
+    )
+
+    expect(index.authors.map(a => [a.slug, a.pages.length])).toEqual([
+      ['jane', 2],
+      ['sam-patel', 1],
+    ])
+  })
+
+  test('carries the registry profile onto the summary', () => {
+    const index = buildAuthorIndex([page('/docs/a', { title: 'A', authors: ['jane'] })], config)
+    expect(index.authors[0]).toMatchObject({
+      slug: 'jane',
+      name: 'Jane Doe',
+      bio: 'Writes about systems.',
+      avatar: '/team/jane.png',
+    })
+  })
+
+  test('labels each page with its content dir', () => {
+    const index = buildAuthorIndex(
+      [
+        page('/docs/a', { title: 'A', authors: ['jane'] }),
+        page('/guides/b', { title: 'B', authors: ['jane'] }),
+      ],
+      config,
+    )
+    expect(index.authors[0].pages.map(p => [p.dir, p.dirLabel])).toEqual([
+      ['docs', 'Docs'],
+      ['guides', 'Guides'],
+    ])
+  })
+
+  test('falls back to the dir name when it has no configured label', () => {
+    const index = buildAuthorIndex([page('/blog/a', { title: 'A', authors: ['jane'] })], config)
+    expect(index.authors[0].pages[0].dirLabel).toBe('blog')
+  })
+
+  test('sorts pages newest first, undated last, then by title', () => {
+    const index = buildAuthorIndex(
+      [
+        page('/docs/old', { title: 'Old', authors: ['jane'], lastModified: '2026-01-01' }),
+        page('/docs/zeta', { title: 'Zeta', authors: ['jane'] }),
+        page('/docs/new', { title: 'New', authors: ['jane'], lastModified: '2026-06-01' }),
+        page('/docs/alpha', { title: 'Alpha', authors: ['jane'] }),
+      ],
+      config,
+    )
+    expect(index.authors[0].pages.map(p => p.title)).toEqual(['New', 'Old', 'Alpha', 'Zeta'])
+  })
+
+  test('sorts authors by name', () => {
+    const index = buildAuthorIndex(
+      [page('/docs/a', { title: 'A', authors: ['Zoe Adams', 'Adam Zeal'] })],
+      config,
+    )
+    expect(index.authors.map(a => a.name)).toEqual(['Adam Zeal', 'Zoe Adams'])
+  })
+
+  test('skips pages that declare no authors', () => {
+    const index = buildAuthorIndex([page('/docs/a', { title: 'A' })], config)
+    expect(index.authors).toEqual([])
+  })
+
+  test('keeps a registry key and a same-named literal separate', () => {
+    const index = buildAuthorIndex(
+      [
+        page('/docs/a', { title: 'A', authors: ['jane'] }),
+        page('/docs/b', { title: 'B', authors: ['Jane Doe'] }),
+      ],
+      config,
+    )
+    expect(index.authors.map(a => a.slug)).toEqual(['jane', 'jane-doe'])
+  })
+})
+
+describe('findAuthor', () => {
+  test('looks an author up by slug', () => {
+    const index = buildAuthorIndex([page('/docs/a', { title: 'A', authors: ['jane'] })], config)
+    expect(findAuthor(index, 'jane')?.name).toBe('Jane Doe')
+    expect(findAuthor(index, 'nobody')).toBeUndefined()
+  })
+})
diff --git a/packages/chronicle/src/lib/author-index.ts b/packages/chronicle/src/lib/author-index.ts
new file mode 100644
index 00000000..938260b8
--- /dev/null
+++ b/packages/chronicle/src/lib/author-index.ts
@@ -0,0 +1,86 @@
+import { resolveAuthors } from './authors'
+import type { Author, ChronicleConfig, Frontmatter } from '@/types'
+
+/** One page written by an author, as listed on that author's page. */
+export interface AuthorPageEntry {
+  url: string
+  title: string
+  description?: string
+  /** Content dir the page lives in, so listings can group by section. */
+  dir: string
+  /** `label` of the matching content entry, falling back to the dir name. */
+  dirLabel: string
+  lastModified?: string
+}
+
+export interface AuthorSummary extends Author {
+  pages: AuthorPageEntry[]
+}
+
+/** The shape served by `/api/authors` and `/data/authors.json`. */
+export interface AuthorIndex {
+  authors: AuthorSummary[]
+}
+
+interface IndexablePage {
+  url: string
+  frontmatter: Frontmatter
+}
+
+function contentDirOf(url: string): string {
+  return url.replace(/^\//, '').split('/')[0] ?? ''
+}
+
+/** Newest first; pages without a date sort after dated ones, then by title. */
+function byRecency(a: AuthorPageEntry, b: AuthorPageEntry): number {
+  if (a.lastModified && b.lastModified) {
+    const diff = new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime()
+    if (diff !== 0) return diff
+  } else if (a.lastModified) {
+    return -1
+  } else if (b.lastModified) {
+    return 1
+  }
+  return a.title.localeCompare(b.title)
+}
+
+/**
+ * Groups pages by the authors declared in their frontmatter. Authors are keyed by
+ * slug, so a registry key and a bare name never collide, and the first page that
+ * names an author supplies the profile shown for them.
+ */
+export function buildAuthorIndex(pages: IndexablePage[], config: ChronicleConfig): AuthorIndex {
+  const dirLabels = new Map((config.content ?? []).map(entry => [entry.dir, entry.label]))
+  const summaries = new Map<string, AuthorSummary>()
+
+  for (const page of pages) {
+    const authors = resolveAuthors(page.frontmatter.authors, config)
+    if (authors.length === 0) continue
+
+    const dir = contentDirOf(page.url)
+    const entry: AuthorPageEntry = {
+      url: page.url,
+      title: page.frontmatter.title,
+      ...(page.frontmatter.description && { description: page.frontmatter.description }),
+      dir,
+      dirLabel: dirLabels.get(dir) ?? dir,
+      ...(page.frontmatter.lastModified && { lastModified: page.frontmatter.lastModified }),
+    }
+
+    for (const author of authors) {
+      const existing = summaries.get(author.slug)
+      if (existing) existing.pages.push(entry)
+      else summaries.set(author.slug, { ...author, pages: [entry] })
+    }
+  }
+
+  const authors = [...summaries.values()]
+    .map(author => ({ ...author, pages: author.pages.sort(byRecency) }))
+    .sort((a, b) => a.name.localeCompare(b.name))
+
+  return { authors }
+}
+
+export function findAuthor(index: AuthorIndex, slug: string): AuthorSummary | undefined {
+  return index.authors.find(author => author.slug === slug)
+}
diff --git a/packages/chronicle/src/lib/authors.test.ts b/packages/chronicle/src/lib/authors.test.ts
index c3ecb568..da6e0e9b 100644
--- a/packages/chronicle/src/lib/authors.test.ts
+++ b/packages/chronicle/src/lib/authors.test.ts
@@ -1,28 +1,37 @@
 import { describe, expect, test } from 'bun:test';
-import { authorInitials, parseAuthor, parseAuthors } from './authors';
+import type { ChronicleConfig } from '@/types';
+import {
+  authorInitials,
+  parseAuthor,
+  parseAuthors,
+  resolveAuthor,
+  resolveAuthors,
+  slugifyAuthorName,
+} from './authors';
 
 describe('parseAuthor', () => {
   test('splits the shorthand into name and email', () => {
-    expect(parseAuthor('Jane Doe <jane@example.com>')).toEqual({ name: 'Jane Doe', email: 'jane@example.com' })
+    expect(parseAuthor('Jane Doe <jane@example.com>')).toEqual({ slug: 'jane-doe', name: 'Jane Doe', email: 'jane@example.com' })
   })
 
   test('accepts a bare name', () => {
-    expect(parseAuthor('Jane Doe')).toEqual({ name: 'Jane Doe' })
+    expect(parseAuthor('Jane Doe')).toEqual({ slug: 'jane-doe', name: 'Jane Doe' })
   })
 
   test('trims surrounding and inner whitespace', () => {
     expect(parseAuthor('  Jane Doe   <  jane@example.com  >  ')).toEqual({
+      slug: 'jane-doe',
       name: 'Jane Doe',
       email: 'jane@example.com',
     })
   })
 
   test('keeps angle brackets that do not hold an email in the name', () => {
-    expect(parseAuthor('Jane Doe <not an email>')).toEqual({ name: 'Jane Doe <not an email>' })
+    expect(parseAuthor('Jane Doe <not an email>')).toEqual({ slug: 'jane-doe-not-an-email', name: 'Jane Doe <not an email>' })
   })
 
   test('falls back to the address when only an email is given', () => {
-    expect(parseAuthor('<jane@example.com>')).toEqual({ name: 'jane@example.com', email: 'jane@example.com' })
+    expect(parseAuthor('<jane@example.com>')).toEqual({ slug: 'jane-example-com', name: 'jane@example.com', email: 'jane@example.com' })
   })
 
   test('returns null for an empty string', () => {
@@ -33,17 +42,17 @@ describe('parseAuthor', () => {
 describe('parseAuthors', () => {
   test('parses a list', () => {
     expect(parseAuthors(['Jane Doe <jane@example.com>', 'Sam Patel'])).toEqual([
-      { name: 'Jane Doe', email: 'jane@example.com' },
-      { name: 'Sam Patel' },
+      { slug: 'jane-doe', name: 'Jane Doe', email: 'jane@example.com' },
+      { slug: 'sam-patel', name: 'Sam Patel' },
     ])
   })
 
   test('accepts a lone string', () => {
-    expect(parseAuthors('Jane Doe')).toEqual([{ name: 'Jane Doe' }])
+    expect(parseAuthors('Jane Doe')).toEqual([{ slug: 'jane-doe', name: 'Jane Doe' }])
   })
 
   test('drops empty and non-string entries', () => {
-    expect(parseAuthors(['Jane Doe', '', 42, null, { name: 'Nope' }])).toEqual([{ name: 'Jane Doe' }])
+    expect(parseAuthors(['Jane Doe', '', 42, null, { name: 'Nope' }])).toEqual([{ slug: 'jane-doe', name: 'Jane Doe' }])
   })
 
   test('returns an empty list when the field is missing', () => {
@@ -68,3 +77,63 @@ describe('authorInitials', () => {
     expect(authorInitials('   ')).toBe('')
   })
 })
+
+const configWithRegistry = {
+  authors: {
+    jane: {
+      name: 'Jane Doe',
+      bio: 'Writes about distributed systems.',
+      avatar: '/team/jane.png',
+      url: 'https://github.com/jane',
+    },
+  },
+} as unknown as ChronicleConfig;
+
+describe('slugifyAuthorName', () => {
+  test('lowercases and joins words with dashes', () => {
+    expect(slugifyAuthorName('Jane Doe')).toBe('jane-doe')
+  })
+
+  test('collapses punctuation and trims stray dashes', () => {
+    expect(slugifyAuthorName("  Ana-María O'Brien, Jr.  ")).toBe('ana-mar-a-o-brien-jr')
+  })
+})
+
+describe('resolveAuthor', () => {
+  test('expands a registry key into its profile', () => {
+    expect(resolveAuthor('jane', configWithRegistry)).toEqual({
+      slug: 'jane',
+      name: 'Jane Doe',
+      bio: 'Writes about distributed systems.',
+      avatar: '/team/jane.png',
+      url: 'https://github.com/jane',
+    })
+  })
+
+  test('falls back to the shorthand for a name that is not a key', () => {
+    expect(resolveAuthor('Sam Patel <sam@example.com>', configWithRegistry)).toEqual({
+      slug: 'sam-patel',
+      name: 'Sam Patel',
+      email: 'sam@example.com',
+    })
+  })
+
+  test('works without a registry', () => {
+    expect(resolveAuthor('jane')).toEqual({ slug: 'jane', name: 'jane' })
+  })
+})
+
+describe('resolveAuthors', () => {
+  test('mixes registry keys and literal names', () => {
+    expect(resolveAuthors(['jane', 'Sam Patel'], configWithRegistry)).toEqual([
+      {
+        slug: 'jane',
+        name: 'Jane Doe',
+        bio: 'Writes about distributed systems.',
+        avatar: '/team/jane.png',
+        url: 'https://github.com/jane',
+      },
+      { slug: 'sam-patel', name: 'Sam Patel' },
+    ])
+  })
+})
diff --git a/packages/chronicle/src/lib/authors.ts b/packages/chronicle/src/lib/authors.ts
index ecef11f5..134ea035 100644
--- a/packages/chronicle/src/lib/authors.ts
+++ b/packages/chronicle/src/lib/authors.ts
@@ -1,8 +1,16 @@
-import type { Author } from '@/types'
+import type { Author, ChronicleConfig } from '@/types'
 
 /** `Name <email>` — the second half only counts as an email when it looks like one. */
 const SHORTHAND = /^(.*?)\s*<([^<>]*)>$/
 
+/** URL-safe identifier for an author who has no registry entry. */
+export function slugifyAuthorName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+}
+
 /**
  * Parses one frontmatter author string. `Jane Doe <jane@example.com>` splits into
  * name and email; anything else is taken literally as a name, so a contributor can
@@ -13,15 +21,38 @@ export function parseAuthor(value: string): Author | null {
   if (!trimmed) return null
 
   const match = SHORTHAND.exec(trimmed)
-  if (!match) return { name: trimmed }
+  if (!match) return withSlug({ name: trimmed })
 
   const name = match[1].trim()
   const email = match[2].trim()
   // `<not an email>` isn't an address — keep the whole string as the name.
-  if (!email.includes('@')) return { name: trimmed }
+  if (!email.includes('@')) return withSlug({ name: trimmed })
   // `<jane@example.com>` alone has no name to show, so the address stands in.
-  if (!name) return { name: email, email }
-  return { name, email }
+  if (!name) return withSlug({ name: email, email })
+  return withSlug({ name, email })
+}
+
+function withSlug(author: Omit<Author, 'slug'>): Author {
+  return { slug: slugifyAuthorName(author.name), ...author }
+}
+
+/**
+ * Resolves one frontmatter author string against the config registry. A string that
+ * names a registry key carries that entry's full profile — bio, avatar, links —
+ * while anything else falls back to the `Name <email>` shorthand.
+ */
+export function resolveAuthor(value: string, config?: ChronicleConfig): Author | null {
+  const key = value.trim()
+  const entry = key ? config?.authors?.[key] : undefined
+  if (!entry) return parseAuthor(value)
+  return { ...entry, slug: key }
+}
+
+/** Resolves the whole `authors` frontmatter field against the registry. */
+export function resolveAuthors(value: unknown, config?: ChronicleConfig): Author[] {
+  return toAuthorStrings(value)
+    .map(entry => resolveAuthor(entry, config))
+    .filter((author): author is Author => author !== null)
 }
 
 /**
@@ -29,13 +60,16 @@ export function parseAuthor(value: string): Author | null {
  * strings, or a lone string for the common single-author case.
  */
 export function parseAuthors(value: unknown): Author[] {
-  const list = typeof value === 'string' ? [value] : Array.isArray(value) ? value : []
-  return list
-    .filter((entry): entry is string => typeof entry === 'string')
+  return toAuthorStrings(value)
     .map(parseAuthor)
     .filter((author): author is Author => author !== null)
 }
 
+function toAuthorStrings(value: unknown): string[] {
+  const list = typeof value === 'string' ? [value] : Array.isArray(value) ? value : []
+  return list.filter((entry): entry is string => typeof entry === 'string')
+}
+
 /**
  * Keeps the `authors` frontmatter field as written, accepting a lone string for the
  * single-author case. Use `parseAuthors` when you need the parsed form.
diff --git a/packages/chronicle/src/lib/data-urls.ts b/packages/chronicle/src/lib/data-urls.ts
index 6584b844..fff6d28e 100644
--- a/packages/chronicle/src/lib/data-urls.ts
+++ b/packages/chronicle/src/lib/data-urls.ts
@@ -18,6 +18,10 @@ export function specsUrl(versionDir: string | null): string {
     : '/api/specs';
 }
 
+export function authorsUrl(): string {
+  return isStaticMode() ? '/data/authors.json' : '/api/authors';
+}
+
 export function searchIndexUrl(): string {
   return '/data/search.json';
 }
diff --git a/packages/chronicle/src/lib/page-context.tsx b/packages/chronicle/src/lib/page-context.tsx
index bb11a508..e1109af6 100644
--- a/packages/chronicle/src/lib/page-context.tsx
+++ b/packages/chronicle/src/lib/page-context.tsx
@@ -11,6 +11,7 @@ import { useLocation, useNavigate } from 'react-router';
 import type { ApiSpec } from '@/lib/openapi';
 import { resolveRoute, resolveContentRootRedirect, RouteType } from '@/lib/route-resolver';
 import { isStaticMode } from '@/lib/static-mode';
+import type { AuthorIndex } from '@/lib/author-index';
 import { pageDataUrl, specsUrl } from '@/lib/data-urls';
 import type { VersionContext } from '@/lib/version-source';
 import { LATEST_CONTEXT } from '@/lib/version-source';
@@ -21,6 +22,8 @@ import { isLocalImage, isSvg, buildOptimizedUrl, splitVersion, webpUrl, DEFAULT_
 export type MdxLoader = (relativePath: string) => Promise<{ content: ReactNode; toc: TableOfContents }>;
 
 interface PageContextValue {
+  /** Author index embedded by the server for /authors routes; null elsewhere. */
+  authorIndex: AuthorIndex | null;
   config: ChronicleConfig;
   tree: Root;
   page: Page | null;
@@ -45,6 +48,7 @@ export function usePageContext(): PageContextValue {
       },
       tree: { name: 'root', children: [] } as Root,
       page: null,
+      authorIndex: null,
       isLoading: false,
       errorStatus: null,
       errorMessage: null,
@@ -60,6 +64,7 @@ interface PageProviderProps {
   initialTree: Root;
   initialPage: Page | null;
   initialApiSpecs: ApiSpec[];
+  initialAuthorIndex?: AuthorIndex | null;
   initialVersion: VersionContext;
   loadMdx: MdxLoader;
   children: ReactNode;
@@ -71,6 +76,7 @@ function getInitialErrorStatus(page: Page | null, config: ChronicleConfig, pathn
   if (route.type === RouteType.ApiIndex || route.type === RouteType.ApiPage) return null;
   if (route.type === RouteType.Redirect) return null;
   if (route.type === RouteType.DocsIndex) return null;
+  if (route.type === RouteType.AuthorIndex || route.type === RouteType.AuthorPage) return null;
   return 404;
 }
 
@@ -79,6 +85,7 @@ export function PageProvider({
   initialTree,
   initialPage,
   initialApiSpecs,
+  initialAuthorIndex = null,
   initialVersion,
   loadMdx,
   children
@@ -229,7 +236,7 @@ export function PageProvider({
 
   return (
     <PageContext.Provider
-      value={{ config: initialConfig, tree, page, isLoading, errorStatus, errorMessage, apiSpecs, version }}
+      value={{ config: initialConfig, tree, page, authorIndex: initialAuthorIndex, isLoading, errorStatus, errorMessage, apiSpecs, version }}
     >
       {children}
     </PageContext.Provider>
diff --git a/packages/chronicle/src/lib/route-resolver.test.ts b/packages/chronicle/src/lib/route-resolver.test.ts
index d1bc9d57..6aba86b0 100644
--- a/packages/chronicle/src/lib/route-resolver.test.ts
+++ b/packages/chronicle/src/lib/route-resolver.test.ts
@@ -171,3 +171,55 @@ describe('resolveRoute — edge cases', () => {
     })
   })
 })
+
+function authorsAsContentDir(): ChronicleConfig {
+  return chronicleConfigSchema.parse({
+    site: { title: 'x' },
+    content: [{ dir: 'authors', label: 'Authors' }],
+  })
+}
+
+describe('resolveRoute — authors', () => {
+  test('/authors is the author index', () => {
+    expect(resolveRoute('/authors', singleContent())).toEqual({
+      type: RouteType.AuthorIndex,
+      version: LATEST_CONTEXT,
+    })
+  })
+
+  test('/authors/<slug> is one author', () => {
+    expect(resolveRoute('/authors/jane', singleContent())).toEqual({
+      type: RouteType.AuthorPage,
+      version: LATEST_CONTEXT,
+      authorSlug: 'jane',
+    })
+  })
+
+  test('a deeper path under /authors falls through to docs', () => {
+    expect(resolveRoute('/authors/jane/extra', singleContent())).toEqual({
+      type: RouteType.DocsPage,
+      version: LATEST_CONTEXT,
+      slug: ['authors', 'jane', 'extra'],
+    })
+  })
+
+  test('resolves under a version prefix', () => {
+    expect(resolveRoute('/v1/authors', versioned())).toEqual({
+      type: RouteType.AuthorIndex,
+      version: { dir: 'v1', urlPrefix: '/v1' },
+    })
+  })
+
+  test('a content dir named authors keeps serving its own pages', () => {
+    expect(resolveRoute('/authors', authorsAsContentDir())).toEqual({
+      type: RouteType.DocsPage,
+      version: LATEST_CONTEXT,
+      slug: ['authors'],
+    })
+    expect(resolveRoute('/authors/jane', authorsAsContentDir())).toEqual({
+      type: RouteType.DocsPage,
+      version: LATEST_CONTEXT,
+      slug: ['authors', 'jane'],
+    })
+  })
+})
diff --git a/packages/chronicle/src/lib/route-resolver.ts b/packages/chronicle/src/lib/route-resolver.ts
index 882fb998..2fab7f86 100644
--- a/packages/chronicle/src/lib/route-resolver.ts
+++ b/packages/chronicle/src/lib/route-resolver.ts
@@ -9,6 +9,8 @@ export const RouteType = {
   DocsPage: 'docs-page',
   ApiIndex: 'api-index',
   ApiPage: 'api-page',
+  AuthorIndex: 'author-index',
+  AuthorPage: 'author-page',
 } as const
 
 export type RouteType = (typeof RouteType)[keyof typeof RouteType]
@@ -19,6 +21,8 @@ export type Route =
   | { type: typeof RouteType.DocsPage; version: VersionContext; slug: string[] }
   | { type: typeof RouteType.ApiIndex; version: VersionContext }
   | { type: typeof RouteType.ApiPage; version: VersionContext; slug: string[] }
+  | { type: typeof RouteType.AuthorIndex; version: VersionContext }
+  | { type: typeof RouteType.AuthorPage; version: VersionContext; authorSlug: string }
 
 function contentDirsFor(
   config: ChronicleConfig,
@@ -32,6 +36,16 @@ function contentDirsFor(
   )
 }
 
+const AUTHORS_SEGMENT = 'authors'
+
+/**
+ * Author routes are skipped when a content dir is literally named `authors`, so a
+ * site that already publishes pages there keeps serving them.
+ */
+function hasAuthorRoutes(config: ChronicleConfig, version: VersionContext): boolean {
+  return !contentDirsFor(config, version).includes(AUTHORS_SEGMENT)
+}
+
 function isLandingEnabled(
   config: ChronicleConfig,
   version: VersionContext,
@@ -66,6 +80,12 @@ export function resolveRoute(
     return { type: RouteType.ApiPage, version, slug }
   }
 
+  if (remainder[0] === AUTHORS_SEGMENT && hasAuthorRoutes(config, version)) {
+    const rest = remainder.slice(1)
+    if (rest.length === 0) return { type: RouteType.AuthorIndex, version }
+    if (rest.length === 1) return { type: RouteType.AuthorPage, version, authorSlug: rest[0] }
+  }
+
   if (remainder.length === 0) {
     if (isLandingEnabled(config, version)) {
       return { type: RouteType.DocsIndex, version }
diff --git a/packages/chronicle/src/pages/AuthorsPage.module.css b/packages/chronicle/src/pages/AuthorsPage.module.css
new file mode 100644
index 00000000..cc5716e8
--- /dev/null
+++ b/packages/chronicle/src/pages/AuthorsPage.module.css
@@ -0,0 +1,155 @@
+.root {
+  width: 100%;
+  max-width: 760px;
+  margin: 0 auto;
+  padding: var(--rs-space-9) var(--rs-space-7);
+  display: flex;
+  flex-direction: column;
+  gap: var(--rs-space-9);
+}
+
+.title {
+  font-size: var(--rs-font-size-t4);
+  font-weight: var(--rs-font-weight-medium);
+  color: var(--rs-color-foreground-base-primary);
+  margin: 0;
+}
+
+.empty {
+  color: var(--rs-color-foreground-base-tertiary);
+  font-size: var(--rs-font-size-regular);
+}
+
+.authorList,
+.pageList {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: var(--rs-space-3);
+}
+
+.authorCard {
+  display: flex;
+  align-items: center;
+  gap: var(--rs-space-5);
+  padding: var(--rs-space-5);
+  border: 1px solid var(--rs-color-border-base-primary);
+  border-radius: var(--rs-radius-3);
+  text-decoration: none;
+  color: inherit;
+}
+
+.authorCard:hover {
+  background-color: var(--rs-color-background-base-primary-hover);
+}
+
+.authorText {
+  display: flex;
+  flex-direction: column;
+  gap: var(--rs-space-1);
+  flex: 1;
+  min-width: 0;
+}
+
+.authorName {
+  font-size: var(--rs-font-size-regular);
+  color: var(--rs-color-foreground-base-primary);
+}
+
+.authorBio {
+  font-size: var(--rs-font-size-small);
+  color: var(--rs-color-foreground-base-tertiary);
+}
+
+.count {
+  font-size: var(--rs-font-size-small);
+  color: var(--rs-color-foreground-base-tertiary);
+  white-space: nowrap;
+}
+
+.profile {
+  display: flex;
+  align-items: flex-start;
+  gap: var(--rs-space-7);
+}
+
+.profileText {
+  display: flex;
+  flex-direction: column;
+  gap: var(--rs-space-3);
+}
+
+.bio {
+  margin: 0;
+  font-size: var(--rs-font-size-regular);
+  color: var(--rs-color-foreground-base-secondary);
+}
+
+.links {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--rs-space-5);
+}
+
+.link {
+  font-size: var(--rs-font-size-small);
+  color: var(--rs-color-foreground-accent-primary);
+  text-decoration: none;
+}
+
+.link:hover {
+  text-decoration: underline;
+}
+
+.group {
+  display: flex;
+  flex-direction: column;
+  gap: var(--rs-space-5);
+}
+
+.groupTitle {
+  font-size: var(--rs-font-size-small);
+  font-weight: var(--rs-font-weight-medium);
+  letter-spacing: var(--rs-letter-spacing-t1);
+  text-transform: uppercase;
+  color: var(--rs-color-foreground-base-tertiary);
+  margin: 0;
+}
+
+.pageCard {
+  display: flex;
+  flex-direction: column;
+  gap: var(--rs-space-2);
+  padding: var(--rs-space-5);
+  border: 1px solid var(--rs-color-border-base-primary);
+  border-radius: var(--rs-radius-3);
+  text-decoration: none;
+  color: inherit;
+}
+
+.pageCard:hover {
+  background-color: var(--rs-color-background-base-primary-hover);
+}
+
+.pageTitle {
+  font-size: var(--rs-font-size-regular);
+  color: var(--rs-color-foreground-base-primary);
+}
+
+.pageDescription {
+  font-size: var(--rs-font-size-small);
+  color: var(--rs-color-foreground-base-tertiary);
+}
+
+.pageDate {
+  font-size: var(--rs-font-size-mini);
+  color: var(--rs-color-foreground-base-tertiary);
+}
+
+@media (max-width: 640px) {
+  .profile {
+    flex-direction: column;
+  }
+}
diff --git a/packages/chronicle/src/pages/AuthorsPage.tsx b/packages/chronicle/src/pages/AuthorsPage.tsx
new file mode 100644
index 00000000..aab7896d
--- /dev/null
+++ b/packages/chronicle/src/pages/AuthorsPage.tsx
@@ -0,0 +1,165 @@
+import { Avatar } from '@raystack/apsara';
+import { useEffect, useState } from 'react';
+import { Link as RouterLink } from 'react-router';
+import type { AuthorIndex, AuthorSummary } from '@/lib/author-index';
+import { authorInitials } from '@/lib/authors';
+import { authorsUrl } from '@/lib/data-urls';
+import { Head } from '@/lib/head';
+import { usePageContext } from '@/lib/page-context';
+import { NotFound } from '@/pages/NotFound';
+import styles from './AuthorsPage.module.css';
+
+/**
+ * Loads the author index once per mount. The index covers every page in the site,
+ * so it is fetched rather than embedded in each page's data.
+ */
+function useAuthorIndex(): { index: AuthorIndex | null; isLoading: boolean } {
+  // Present when the server rendered this route, so the first paint needs no fetch.
+  const { authorIndex } = usePageContext();
+  const [index, setIndex] = useState<AuthorIndex | null>(authorIndex);
+  const [isLoading, setIsLoading] = useState(authorIndex === null);
+
+  useEffect(() => {
+    if (authorIndex) return;
+    let cancelled = false;
+    fetch(authorsUrl())
+      .then(res => (res.ok ? res.json() : { authors: [] }))
+      .then(data => {
+        if (!cancelled) setIndex(data as AuthorIndex);
+      })
+      .catch(() => {
+        if (!cancelled) setIndex({ authors: [] });
+      })
+      .finally(() => {
+        if (!cancelled) setIsLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [authorIndex]);
+
+  return { index, isLoading };
+}
+
+function AuthorAvatar({ author, size }: { author: AuthorSummary; size: 3 | 6 }) {
+  return (
+    <Avatar
+      size={size}
+      src={author.avatar}
+      alt={author.name}
+      fallback={authorInitials(author.name)}
+    />
+  );
+}
+
+function pageCountLabel(count: number): string {
+  return count === 1 ? '1 page' : `${count} pages`;
+}
+
+/** `/authors` — every author found in the content. */
+export function AuthorsPage() {
+  const { config } = usePageContext();
+  const { index, isLoading } = useAuthorIndex();
+  const authors = index?.authors ?? [];
+
+  return (
+    <>
+      <Head title='Authors' description={`People writing ${config.site.title}`} config={config} />
+      <div className={styles.root}>
+        <h1 className={styles.title}>Authors</h1>
+        {isLoading ? null : authors.length === 0 ? (
+          <p className={styles.empty}>No pages declare an author yet.</p>
+        ) : (
+          <ul className={styles.authorList}>
+            {authors.map(author => (
+              <li key={author.slug}>
+                <RouterLink to={`/authors/${author.slug}`} className={styles.authorCard}>
+                  <AuthorAvatar author={author} size={3} />
+                  <span className={styles.authorText}>
+                    <span className={styles.authorName}>{author.name}</span>
+                    {author.bio && <span className={styles.authorBio}>{author.bio}</span>}
+                  </span>
+                  <span className={styles.count}>{pageCountLabel(author.pages.length)}</span>
+                </RouterLink>
+              </li>
+            ))}
+          </ul>
+        )}
+      </div>
+    </>
+  );
+}
+
+interface AuthorDetailPageProps {
+  authorSlug: string;
+}
+
+/** `/authors/<slug>` — one author's profile and everything they wrote. */
+export function AuthorDetailPage({ authorSlug }: AuthorDetailPageProps) {
+  const { config } = usePageContext();
+  const { index, isLoading } = useAuthorIndex();
+
+  if (isLoading) return null;
+
+  const author = index?.authors.find(entry => entry.slug === authorSlug);
+  if (!author) return <NotFound />;
+
+  const groups = new Map<string, typeof author.pages>();
+  for (const page of author.pages) {
+    const existing = groups.get(page.dirLabel);
+    if (existing) existing.push(page);
+    else groups.set(page.dirLabel, [page]);
+  }
+
+  return (
+    <>
+      <Head
+        title={author.name}
+        description={author.bio ?? `Pages written by ${author.name}`}
+        config={config}
+      />
+      <div className={styles.root}>
+        <header className={styles.profile}>
+          <AuthorAvatar author={author} size={6} />
+          <div className={styles.profileText}>
+            <h1 className={styles.title}>{author.name}</h1>
+            {author.bio && <p className={styles.bio}>{author.bio}</p>}
+            <div className={styles.links}>
+              {author.url && (
+                <a className={styles.link} href={author.url} rel='noreferrer' target='_blank'>
+                  {author.url.replace(/^https?:\/\//, '')}
+                </a>
+              )}
+              {author.email && (
+                <a className={styles.link} href={`mailto:${author.email}`}>
+                  {author.email}
+                </a>
+              )}
+            </div>
+          </div>
+        </header>
+
+        {[...groups.entries()].map(([dirLabel, pages]) => (
+          <section className={styles.group} key={dirLabel}>
+            <h2 className={styles.groupTitle}>{dirLabel}</h2>
+            <ul className={styles.pageList}>
+              {pages.map(page => (
+                <li key={page.url}>
+                  <RouterLink to={page.url} className={styles.pageCard}>
+                    <span className={styles.pageTitle}>{page.title}</span>
+                    {page.description && <span className={styles.pageDescription}>{page.description}</span>}
+                    {page.lastModified && (
+                      <time className={styles.pageDate} dateTime={page.lastModified}>
+                        {page.lastModified}
+                      </time>
+                    )}
+                  </RouterLink>
+                </li>
+              ))}
+            </ul>
+          </section>
+        ))}
+      </div>
+    </>
+  );
+}
diff --git a/packages/chronicle/src/pages/DocsPage.tsx b/packages/chronicle/src/pages/DocsPage.tsx
index 81fe6680..5636f205 100644
--- a/packages/chronicle/src/pages/DocsPage.tsx
+++ b/packages/chronicle/src/pages/DocsPage.tsx
@@ -1,6 +1,6 @@
 import { Navigate } from 'react-router';
 import { StatusCodes } from 'http-status-codes';
-import { parseAuthors } from '@/lib/authors';
+import { resolveAuthors } from '@/lib/authors';
 import { Head } from '@/lib/head';
 import { usePageContext } from '@/lib/page-context';
 import { resolveDocsRedirect } from '@/lib/tree-utils';
@@ -27,7 +27,7 @@ export function DocsPage({ slug }: DocsPageProps) {
   if (isLoading || !page) return <Skeleton />;
   const pageUrl = config.url ? `${config.url}/${slug.join('/')}` : undefined;
   const markdownHref = `/${slug.join('/')}.md`;
-  const authors = parseAuthors(page.frontmatter.authors);
+  const authors = resolveAuthors(page.frontmatter.authors, config);
 
   return (
     <>
diff --git a/packages/chronicle/src/server/App.tsx b/packages/chronicle/src/server/App.tsx
index 4531c072..288da04e 100644
--- a/packages/chronicle/src/server/App.tsx
+++ b/packages/chronicle/src/server/App.tsx
@@ -14,6 +14,8 @@ const ApiPage = lazy(() => import('@/pages/ApiPage').then(m => ({ default: m.Api
 const DocsLayout = lazy(() => import('@/pages/DocsLayout').then(m => ({ default: m.DocsLayout })));
 const DocsPage = lazy(() => import('@/pages/DocsPage').then(m => ({ default: m.DocsPage })));
 const LandingPage = lazy(() => import('@/pages/LandingPage').then(m => ({ default: m.LandingPage })));
+const AuthorsPage = lazy(() => import('@/pages/AuthorsPage').then(m => ({ default: m.AuthorsPage })));
+const AuthorDetailPage = lazy(() => import('@/pages/AuthorsPage').then(m => ({ default: m.AuthorDetailPage })));
 
 export function App() {
   const { pathname } = useLocation();
@@ -30,6 +32,8 @@ export function App() {
   const apiSlug = route.type === RouteType.ApiPage ? route.slug : [];
   const docsSlug = route.type === RouteType.DocsPage ? route.slug : [];
   const isLanding = route.type === RouteType.DocsIndex;
+  const isAuthors =
+    route.type === RouteType.AuthorIndex || route.type === RouteType.AuthorPage;
 
   return (
     <ThemeProvider
@@ -45,6 +49,14 @@ export function App() {
               <ApiLayout>
                 <ApiPage slug={apiSlug} />
               </ApiLayout>
+            ) : isAuthors ? (
+              <DocsLayout hideSidebar>
+                {route.type === RouteType.AuthorPage ? (
+                  <AuthorDetailPage authorSlug={route.authorSlug} />
+                ) : (
+                  <AuthorsPage />
+                )}
+              </DocsLayout>
             ) : (
               <DocsLayout hideSidebar={isLanding}>
                 {isLanding ? <LandingPage /> : <DocsPage slug={docsSlug} />}
diff --git a/packages/chronicle/src/server/api/authors.ts b/packages/chronicle/src/server/api/authors.ts
new file mode 100644
index 00000000..751c9632
--- /dev/null
+++ b/packages/chronicle/src/server/api/authors.ts
@@ -0,0 +1,16 @@
+import { defineHandler } from 'nitro';
+import { buildAuthorIndex } from '@/lib/author-index';
+import { loadConfig } from '@/lib/config';
+import { extractFrontmatter, getPages } from '@/lib/source';
+
+export default defineHandler(async () => {
+  const config = loadConfig();
+  const pages = await getPages();
+
+  return Response.json(
+    buildAuthorIndex(
+      pages.map(page => ({ url: page.url, frontmatter: extractFrontmatter(page) })),
+      config,
+    ),
+  );
+});
diff --git a/packages/chronicle/src/server/entry-client.tsx b/packages/chronicle/src/server/entry-client.tsx
index 73a89dc1..c5982a45 100644
--- a/packages/chronicle/src/server/entry-client.tsx
+++ b/packages/chronicle/src/server/entry-client.tsx
@@ -14,6 +14,7 @@ import { mdxComponents } from '@/components/mdx';
 import { getApiConfigsForVersion } from '@/lib/config';
 import { PageProvider } from '@/lib/page-context';
 import { prefetchSearchSuggestions, queryClient } from '@/lib/preload';
+import type { AuthorIndex } from '@/lib/author-index';
 import { resolveRoute, RouteType } from '@/lib/route-resolver';
 import { resolveVersionFromUrl, type VersionContext } from '@/lib/version-source';
 import type { ChronicleConfig, Frontmatter, PageNavLink, Root, TableOfContents } from '@/types';
@@ -31,6 +32,8 @@ interface EmbeddedData {
   originalPath: string | null;
   prev: PageNavLink | null;
   next: PageNavLink | null;
+  /** Only embedded for /authors routes. */
+  authorIndex?: AuthorIndex | null;
 }
 
 const defaultConfig: ChronicleConfig = {
@@ -110,6 +113,7 @@ async function hydrate() {
               initialTree={tree}
               initialPage={page}
               initialApiSpecs={apiSpecs}
+              initialAuthorIndex={embedded?.authorIndex ?? null}
               initialVersion={version}
               loadMdx={loadMdxModule}
             >
diff --git a/packages/chronicle/src/server/entry-server.tsx b/packages/chronicle/src/server/entry-server.tsx
index 0d6bf5a0..6bcc0ed3 100644
--- a/packages/chronicle/src/server/entry-server.tsx
+++ b/packages/chronicle/src/server/entry-server.tsx
@@ -6,10 +6,11 @@ import { StaticRouter } from 'react-router';
 import { ReactRouterProvider } from 'fumadocs-core/framework/react-router';
 import { mdxComponents } from '@/components/mdx';
 import { getApiConfigsForVersion, loadConfig } from '@/lib/config';
+import { buildAuthorIndex } from '@/lib/author-index';
 import { loadApiSpecs } from '@/lib/openapi';
 import { PageProvider } from '@/lib/page-context';
 import { resolveRoute, RouteType } from '@/lib/route-resolver';
-import { getPage, getPageTree, isDraft, getPageNav, loadPageModule, extractFrontmatter, getRelativePath, getOriginalPath, getPageImages } from '@/lib/source';
+import { getPage, getPageTree, isDraft, getPageNav, loadPageModule, extractFrontmatter, getRelativePath, getOriginalPath, getPageImages, getPages } from '@/lib/source';
 import { getFirstApiUrl } from '@/lib/api-routes';
 import { StatusCodes } from 'http-status-codes';
 import { resolvePageAndSlug, resolveDocsRedirect, compactTree } from '@/lib/tree-utils';
@@ -29,6 +30,7 @@ import serverAssets from './entry-server?assets=ssr';
 import docsLayoutAssets from '@/pages/DocsLayout?assets=client';
 import docsPageAssets from '@/pages/DocsPage?assets=client';
 import landingPageAssets from '@/pages/LandingPage?assets=client';
+import authorsPageAssets from '@/pages/AuthorsPage?assets=client';
 import apiLayoutAssets from '@/pages/ApiLayout?assets=client';
 import apiPageAssets from '@/pages/ApiPage?assets=client';
 
@@ -110,6 +112,8 @@ export default {
       });
     }
 
+    const isAuthorRoute =
+      route.type === RouteType.AuthorIndex || route.type === RouteType.AuthorPage;
     const nav = page ? await getPageNav(resolvedSlug) : { prev: null, next: null };
 
     const relativePath = page ? getRelativePath(page) : null;
@@ -133,8 +137,16 @@ export default {
         }
       : null;
 
+    const authorIndex = isAuthorRoute
+      ? buildAuthorIndex(
+          (await getPages()).map(p => ({ url: p.url, frontmatter: extractFrontmatter(p) })),
+          config,
+        )
+      : null;
+
     const embeddedData = {
       config,
+      ...(authorIndex && { authorIndex }),
       tree,
       slug: resolvedSlug,
       version: route.version,
@@ -148,9 +160,11 @@ export default {
 
     const routeAssets = isApiRoute
       ? [apiLayoutAssets, apiPageAssets]
-      : route.type === RouteType.DocsIndex
-        ? [docsLayoutAssets, landingPageAssets]
-        : [docsLayoutAssets, docsPageAssets];
+      : isAuthorRoute
+        ? [docsLayoutAssets, authorsPageAssets]
+        : route.type === RouteType.DocsIndex
+          ? [docsLayoutAssets, landingPageAssets]
+          : [docsLayoutAssets, docsPageAssets];
     // Dev needs serverAssets: client CSS is collected per-module there. In
     // production the client build is a single stylesheet (cssCodeSplit:
     // false) that already contains everything in import order — the SSR
@@ -208,6 +222,7 @@ export default {
                     initialTree={tree}
                     initialPage={pageData}
                     initialApiSpecs={apiSpecs}
+                    initialAuthorIndex={authorIndex}
                     initialVersion={route.version}
                     loadMdx={async () => ({ content: null, toc: [] })}
                   >
diff --git a/packages/chronicle/src/types/config.ts b/packages/chronicle/src/types/config.ts
index 1c7b6136..cb5371c5 100644
--- a/packages/chronicle/src/types/config.ts
+++ b/packages/chronicle/src/types/config.ts
@@ -119,6 +119,15 @@ const versionSchema = z.object({
   api: z.array(apiSchema).optional(),
 })
 
+/** Profile details for an author referenced by key from a page's frontmatter. */
+const authorSchema = z.object({
+  name: z.string().min(1),
+  bio: z.string().optional(),
+  avatar: z.string().optional(),
+  url: z.string().optional(),
+  email: z.string().optional(),
+})
+
 const allUnique = <T>(items: T[], key: (item: T) => string): boolean =>
   uniqBy(items, key).length === items.length
 
@@ -148,6 +157,7 @@ export const chronicleConfigSchema = z
     logo: logoSchema.optional(),
     theme: themeSchema.optional(),
     navigation: navigationSchema.optional(),
+    authors: z.record(z.string().min(1), authorSchema).optional(),
     search: searchSchema.optional(),
     api: z.array(apiSchema).optional(),
     redirects: z.array(redirectSchema).optional(),
diff --git a/packages/chronicle/src/types/content.ts b/packages/chronicle/src/types/content.ts
index 541f51c1..90819b0f 100644
--- a/packages/chronicle/src/types/content.ts
+++ b/packages/chronicle/src/types/content.ts
@@ -4,10 +4,18 @@ import type { TableOfContents } from 'fumadocs-core/toc'
 export type { Root, Node, Item, Folder, Separator } from 'fumadocs-core/page-tree'
 export type { TOCItemType, TableOfContents } from 'fumadocs-core/toc'
 
-/** A page author, parsed from an `authors` frontmatter string. */
+/**
+ * A page author. Built either from an `authors` frontmatter string or, when that
+ * string names a key in the config registry, from that entry's full profile.
+ */
 export interface Author {
+  /** Stable identifier: the registry key, or the name slugified. */
+  slug: string
   name: string
   email?: string
+  bio?: string
+  avatar?: string
+  url?: string
 }
 
 export interface Frontmatter {

From 5b2c831d86f30883e0c54f954fc3f1feab14f7e6 Mon Sep 17 00:00:00 2001
From: Rishabh <me@rsbh.dev>
Date: Wed, 19 Aug 2026 15:36:00 +0530
Subject: [PATCH 2/6] fix: add breathing room above author page content

Also gives the paper-theme example an authors registry entry, so both
themes demonstrate a full profile.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 examples/versioned/chronicle.yaml                   | 7 +++++++
 examples/versioned/content/dev/api.mdx              | 1 +
 examples/versioned/content/docs/guide.mdx           | 2 +-
 packages/chronicle/src/pages/AuthorsPage.module.css | 2 +-
 4 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/examples/versioned/chronicle.yaml b/examples/versioned/chronicle.yaml
index 2a1c054a..c529ff53 100644
--- a/examples/versioned/chronicle.yaml
+++ b/examples/versioned/chronicle.yaml
@@ -2,6 +2,13 @@ site:
   title: Versioned Example
   description: Multi-content + multi-version sample
 
+authors:
+  jane:
+    name: Jane Doe
+    bio: Writes about the parts of the system nobody else wants to document.
+    url: https://github.com/jane
+    email: jane@example.com
+
 theme:
   name: paper
 
diff --git a/examples/versioned/content/dev/api.mdx b/examples/versioned/content/dev/api.mdx
index 82668e13..bf69a752 100644
--- a/examples/versioned/content/dev/api.mdx
+++ b/examples/versioned/content/dev/api.mdx
@@ -1,6 +1,7 @@
 ---
 title: API notes
 order: 2
+authors: [jane, Sam Patel]
 ---
 
 # Dev API notes — latest
diff --git a/examples/versioned/content/docs/guide.mdx b/examples/versioned/content/docs/guide.mdx
index cac0c8e7..30d3ba21 100644
--- a/examples/versioned/content/docs/guide.mdx
+++ b/examples/versioned/content/docs/guide.mdx
@@ -1,7 +1,7 @@
 ---
 title: Guide
 order: 2
-authors: Jane Doe <jane@example.com>
+authors: [jane]
 ---
 
 # Guide — latest docs
diff --git a/packages/chronicle/src/pages/AuthorsPage.module.css b/packages/chronicle/src/pages/AuthorsPage.module.css
index cc5716e8..0b669e2c 100644
--- a/packages/chronicle/src/pages/AuthorsPage.module.css
+++ b/packages/chronicle/src/pages/AuthorsPage.module.css
@@ -2,7 +2,7 @@
   width: 100%;
   max-width: 760px;
   margin: 0 auto;
-  padding: var(--rs-space-9) var(--rs-space-7);
+  padding: var(--rs-space-13) var(--rs-space-7) var(--rs-space-9);
   display: flex;
   flex-direction: column;
   gap: var(--rs-space-9);

From 359134d7295539a983b765da8545c142cf65b561 Mon Sep 17 00:00:00 2001
From: Rishabh <me@rsbh.dev>
Date: Wed, 19 Aug 2026 15:42:45 +0530
Subject: [PATCH 3/6] feat: give author pages the paper theme's sheet and fonts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Author pages bypass each theme's Page component, so in paper they sat
flat on the neutral backdrop while every other page rendered on a sheet.
Tag the page root with the active theme and, for paper, apply the same
sheet treatment its content uses — base background, side borders, soft
shadow — with the theme's Hanuman body face and Departure Mono for the
meta text.

The profile header now stacks as avatar and name on one line, the bio
below it, then the links.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../src/pages/AuthorsPage.module.css          | 48 +++++++++++++++----
 packages/chronicle/src/pages/AuthorsPage.tsx  | 14 +++---
 2 files changed, 47 insertions(+), 15 deletions(-)

diff --git a/packages/chronicle/src/pages/AuthorsPage.module.css b/packages/chronicle/src/pages/AuthorsPage.module.css
index 0b669e2c..56529db5 100644
--- a/packages/chronicle/src/pages/AuthorsPage.module.css
+++ b/packages/chronicle/src/pages/AuthorsPage.module.css
@@ -9,8 +9,11 @@
 }
 
 .title {
+  font-family: var(--rs-font-title);
   font-size: var(--rs-font-size-t4);
   font-weight: var(--rs-font-weight-medium);
+  line-height: var(--rs-line-height-t4);
+  letter-spacing: var(--rs-letter-spacing-t1);
   color: var(--rs-color-foreground-base-primary);
   margin: 0;
 }
@@ -71,14 +74,14 @@
 
 .profile {
   display: flex;
-  align-items: flex-start;
-  gap: var(--rs-space-7);
+  flex-direction: column;
+  gap: var(--rs-space-4);
 }
 
-.profileText {
+.identity {
   display: flex;
-  flex-direction: column;
-  gap: var(--rs-space-3);
+  align-items: center;
+  gap: var(--rs-space-5);
 }
 
 .bio {
@@ -148,8 +151,35 @@
   color: var(--rs-color-foreground-base-tertiary);
 }
 
-@media (max-width: 640px) {
-  .profile {
-    flex-direction: column;
-  }
+/*
+ * Paper renders its pages on a sheet over the neutral backdrop (see
+ * themes/paper/Page.module.css .content). Author pages bypass that theme's Page,
+ * so they take the same treatment here.
+ */
+.root[data-page-theme='paper'] {
+  font-family: var(--paper-font-body);
+  background: var(--rs-color-background-base-primary);
+  border-left: 1px solid var(--rs-color-border-base-primary);
+  border-right: 1px solid var(--rs-color-border-base-primary);
+  box-shadow:
+    0 1px 3px rgba(0, 0, 0, 0.08),
+    0 4px 12px rgba(0, 0, 0, 0.04);
+  min-height: calc(100vh - var(--rs-space-12));
+  margin: var(--rs-space-12) auto var(--rs-space-9);
+  padding: var(--rs-space-13) var(--rs-space-9) var(--rs-space-9);
+}
+
+.root[data-page-theme='paper'] .title,
+.root[data-page-theme='paper'] .bio,
+.root[data-page-theme='paper'] .authorName,
+.root[data-page-theme='paper'] .pageTitle {
+  font-family: var(--paper-font-body);
+}
+
+.root[data-page-theme='paper'] .groupTitle,
+.root[data-page-theme='paper'] .count,
+.root[data-page-theme='paper'] .pageDate,
+.root[data-page-theme='paper'] .link {
+  font-family: var(--paper-font-mono);
+  letter-spacing: var(--rs-letter-spacing-t1);
 }
diff --git a/packages/chronicle/src/pages/AuthorsPage.tsx b/packages/chronicle/src/pages/AuthorsPage.tsx
index aab7896d..47b853ed 100644
--- a/packages/chronicle/src/pages/AuthorsPage.tsx
+++ b/packages/chronicle/src/pages/AuthorsPage.tsx
@@ -65,7 +65,7 @@ export function AuthorsPage() {
   return (
     <>
       <Head title='Authors' description={`People writing ${config.site.title}`} config={config} />
-      <div className={styles.root}>
+      <div className={styles.root} data-page-theme={config.theme?.name ?? 'default'}>
         <h1 className={styles.title}>Authors</h1>
         {isLoading ? null : authors.length === 0 ? (
           <p className={styles.empty}>No pages declare an author yet.</p>
@@ -118,12 +118,14 @@ export function AuthorDetailPage({ authorSlug }: AuthorDetailPageProps) {
         description={author.bio ?? `Pages written by ${author.name}`}
         config={config}
       />
-      <div className={styles.root}>
+      <div className={styles.root} data-page-theme={config.theme?.name ?? 'default'}>
         <header className={styles.profile}>
-          <AuthorAvatar author={author} size={6} />
-          <div className={styles.profileText}>
+          <div className={styles.identity}>
+            <AuthorAvatar author={author} size={6} />
             <h1 className={styles.title}>{author.name}</h1>
-            {author.bio && <p className={styles.bio}>{author.bio}</p>}
+          </div>
+          {author.bio && <p className={styles.bio}>{author.bio}</p>}
+          {(author.url || author.email) && (
             <div className={styles.links}>
               {author.url && (
                 <a className={styles.link} href={author.url} rel='noreferrer' target='_blank'>
@@ -136,7 +138,7 @@ export function AuthorDetailPage({ authorSlug }: AuthorDetailPageProps) {
                 </a>
               )}
             </div>
-          </div>
+          )}
         </header>
 
         {[...groups.entries()].map(([dirLabel, pages]) => (

From 9b3d596d63c4879c2222d75b03756f8c318cff58 Mon Sep 17 00:00:00 2001
From: Rishabh <me@rsbh.dev>
Date: Wed, 19 Aug 2026 15:46:18 +0530
Subject: [PATCH 4/6] feat: put the paper byline in the meta line beside
 reading time

Paper stacked the avatar byline under the page description. Move the
authors up into the meta line as `1min Read | JANE DOE`, inheriting that
line's mono face and tertiary color, with round avatars.

Bylines now show two authors at most and collapse the rest into a `+N`
counter that names them on hover.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 examples/versioned/content/dev/api.mdx        |  2 +-
 .../common/author-byline.module.css           | 31 +++++++++-
 .../src/components/common/author-byline.tsx   | 60 ++++++++++++++-----
 .../src/themes/paper/Page.module.css          | 34 +++++++++--
 packages/chronicle/src/themes/paper/Page.tsx  | 13 +++-
 5 files changed, 114 insertions(+), 26 deletions(-)

diff --git a/examples/versioned/content/dev/api.mdx b/examples/versioned/content/dev/api.mdx
index bf69a752..ec45b23a 100644
--- a/examples/versioned/content/dev/api.mdx
+++ b/examples/versioned/content/dev/api.mdx
@@ -1,7 +1,7 @@
 ---
 title: API notes
 order: 2
-authors: [jane, Sam Patel]
+authors: [jane, Sam Patel, Ana Ruiz <ana@example.com>]
 ---
 
 # Dev API notes — latest
diff --git a/packages/chronicle/src/components/common/author-byline.module.css b/packages/chronicle/src/components/common/author-byline.module.css
index 16148679..4405cdf0 100644
--- a/packages/chronicle/src/components/common/author-byline.module.css
+++ b/packages/chronicle/src/components/common/author-byline.module.css
@@ -1,5 +1,5 @@
 .byline {
-  display: flex;
+  display: inline-flex;
   flex-wrap: wrap;
   align-items: center;
   gap: var(--rs-space-4);
@@ -21,3 +21,32 @@ a.name:hover {
   color: var(--rs-color-foreground-base-primary);
   text-decoration: underline;
 }
+
+.more {
+  font-size: var(--rs-font-size-small);
+  color: var(--rs-color-foreground-base-tertiary);
+  cursor: default;
+}
+
+/* Inherits the surrounding meta line's font, size, and color. */
+.inlineByline {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--rs-space-4);
+  font: inherit;
+  letter-spacing: inherit;
+  color: inherit;
+}
+
+.inlineByline .more {
+  font: inherit;
+  letter-spacing: inherit;
+  color: inherit;
+}
+
+.inlineByline .name {
+  font: inherit;
+  letter-spacing: inherit;
+  color: inherit;
+  text-transform: uppercase;
+}
diff --git a/packages/chronicle/src/components/common/author-byline.tsx b/packages/chronicle/src/components/common/author-byline.tsx
index edd82dd4..eb80ceba 100644
--- a/packages/chronicle/src/components/common/author-byline.tsx
+++ b/packages/chronicle/src/components/common/author-byline.tsx
@@ -1,47 +1,75 @@
 'use client'
 
 import { Avatar, getAvatarColor } from '@raystack/apsara'
+import type { Author } from '@/types'
 import { authorInitials, resolveAuthors } from '@/lib/authors'
 import { usePageContext } from '@/lib/page-context'
 import styles from './author-byline.module.css'
 
+/** Beyond this, the remainder is collapsed into a `+N` counter. */
+const MAX_VISIBLE = 2
+
 interface AuthorBylineProps {
   /** Raw `authors` frontmatter entries — `Name <email>` or a bare name. */
   authors?: string[]
+  /**
+   * `block` stands on its own under a page title; `inline` sits in a meta line
+   * beside other text and inherits its typography.
+   */
+  variant?: 'block' | 'inline'
   className?: string
 }
 
-/** Avatar-and-name byline for the authors declared in a page's frontmatter. */
-export function AuthorByline({ authors, className }: AuthorBylineProps) {
+/** The name, linked to a profile url or email when the author has one. */
+function AuthorName({ author }: { author: Author }) {
+  if (author.url) {
+    return (
+      <a className={styles.name} href={author.url} rel='noreferrer' target='_blank'>
+        {author.name}
+      </a>
+    )
+  }
+  if (author.email) {
+    return (
+      <a className={styles.name} href={`mailto:${author.email}`}>
+        {author.name}
+      </a>
+    )
+  }
+  return <span className={styles.name}>{author.name}</span>
+}
+
+/** Byline for the authors declared in a page's frontmatter. */
+export function AuthorByline({ authors, variant = 'block', className }: AuthorBylineProps) {
   const { config } = usePageContext()
   const parsed = resolveAuthors(authors, config)
   if (parsed.length === 0) return null
 
+  const wrapper = variant === 'inline' ? styles.inlineByline : styles.byline
+  const shown = parsed.slice(0, MAX_VISIBLE)
+  const hidden = parsed.slice(MAX_VISIBLE)
+
   return (
-    <div className={className ? `${styles.byline} ${className}` : styles.byline}>
-      {parsed.map((author, index) => (
+    <span className={className ? `${wrapper} ${className}` : wrapper}>
+      {shown.map((author, index) => (
         <span className={styles.author} key={`${author.slug}-${index}`}>
           <Avatar
             size={2}
+            radius='full'
             src={author.avatar}
             alt={author.avatar ? author.name : undefined}
             fallback={authorInitials(author.name)}
             color={getAvatarColor(author.name)}
             aria-hidden={author.avatar ? undefined : 'true'}
           />
-          {author.url ? (
-            <a className={styles.name} href={author.url} rel='noreferrer' target='_blank'>
-              {author.name}
-            </a>
-          ) : author.email ? (
-            <a className={styles.name} href={`mailto:${author.email}`}>
-              {author.name}
-            </a>
-          ) : (
-            <span className={styles.name}>{author.name}</span>
-          )}
+          <AuthorName author={author} />
         </span>
       ))}
-    </div>
+      {hidden.length > 0 && (
+        <span className={styles.more} title={hidden.map(author => author.name).join(', ')}>
+          {`+${hidden.length}`}
+        </span>
+      )}
+    </span>
   )
 }
diff --git a/packages/chronicle/src/themes/paper/Page.module.css b/packages/chronicle/src/themes/paper/Page.module.css
index 47603dfa..f3295321 100644
--- a/packages/chronicle/src/themes/paper/Page.module.css
+++ b/packages/chronicle/src/themes/paper/Page.module.css
@@ -81,6 +81,35 @@
   margin: 0 auto;
 }
 
+.articleMeta {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: var(--rs-space-3);
+  font-family: var(--paper-font-mono);
+  font-size: var(--rs-font-size-small);
+  font-weight: var(--rs-font-weight-regular);
+  line-height: 1.67;
+  letter-spacing: var(--rs-letter-spacing-t1);
+  color: var(--rs-color-foreground-base-tertiary);
+  margin-bottom: var(--rs-space-5);
+}
+
+.metaDivider {
+  color: var(--rs-color-border-base-primary);
+}
+
+/* Inherit the meta line's face rather than the byline's own sizing. */
+.articleMeta a {
+  font: inherit;
+  letter-spacing: inherit;
+  color: inherit;
+}
+
+.articleMeta a:hover {
+  color: var(--rs-color-foreground-base-primary);
+}
+
 .readingTime {
   display: block;
   font-family: var(--paper-font-mono);
@@ -260,8 +289,3 @@
 .navbarLoaderWrapper {
     width: 30%;
 }
-
-.byline {
-  justify-content: center;
-  margin-top: var(--rs-space-5);
-}
diff --git a/packages/chronicle/src/themes/paper/Page.tsx b/packages/chronicle/src/themes/paper/Page.tsx
index 3b1b30a2..d04811cd 100644
--- a/packages/chronicle/src/themes/paper/Page.tsx
+++ b/packages/chronicle/src/themes/paper/Page.tsx
@@ -98,14 +98,21 @@ export function Page({ page, tree }: ThemePageProps) {
         </div>
         <div className={styles.content}>
           <header className={styles.articleHeader}>
-            {page.frontmatter._readingTime && (
-              <span className={styles.readingTime}>{page.frontmatter._readingTime}min Read</span>
+            {(page.frontmatter._readingTime || page.frontmatter.authors?.length) && (
+              <div className={styles.articleMeta}>
+                {page.frontmatter._readingTime && (
+                  <span>{page.frontmatter._readingTime}min Read</span>
+                )}
+                {page.frontmatter._readingTime && page.frontmatter.authors?.length ? (
+                  <span className={styles.metaDivider} aria-hidden='true'>|</span>
+                ) : null}
+                <AuthorByline authors={page.frontmatter.authors} variant='inline' />
+              </div>
             )}
             <h1 className={styles.articleTitle}>{page.frontmatter.title}</h1>
             {page.frontmatter.description && (
               <p className={styles.articleDescription}>{page.frontmatter.description}</p>
             )}
-            <AuthorByline authors={page.frontmatter.authors} className={styles.byline} />
             <hr className={styles.articleSeparator} />
           </header>
           <article className={styles.article} data-article-content>

From f20737e5a89ab9a24998fff9fb261e4c5e4547f6 Mon Sep 17 00:00:00 2001
From: Rishabh <me@rsbh.dev>
Date: Wed, 19 Aug 2026 15:50:19 +0530
Subject: [PATCH 5/6] feat: link byline names to the author's page

The byline linked out to an author's `url`, or their email, which sent
readers off-site while the author page it should reach went unlinked.
Names now always go to `/authors/<slug>`, keeping the version prefix and
falling back to plain text when a content dir owns that segment. An
author's url and email stay on their page.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/content/docs/configuration.mdx           |  4 +--
 docs/content/docs/frontmatter.mdx             | 14 ++++----
 .../src/components/common/author-byline.tsx   | 34 ++++++++-----------
 .../chronicle/src/lib/route-resolver.test.ts  | 20 ++++++++++-
 packages/chronicle/src/lib/route-resolver.ts  | 13 +++++++
 5 files changed, 57 insertions(+), 28 deletions(-)

diff --git a/docs/content/docs/configuration.mdx b/docs/content/docs/configuration.mdx
index cf580974..fd04a40c 100644
--- a/docs/content/docs/configuration.mdx
+++ b/docs/content/docs/configuration.mdx
@@ -383,8 +383,8 @@ authors:
 | `name` | `string` | **Required.** Display name | — |
 | `bio` | `string` | Short description shown on the author's page | — |
 | `avatar` | `string` | Image path for the avatar; initials are used without it | — |
-| `url` | `string` | Profile link — the byline links here in preference to the email | — |
-| `email` | `string` | Contact address, linked with `mailto:` | — |
+| `url` | `string` | Profile link, shown on the author's page | — |
+| `email` | `string` | Contact address, shown on the author's page with `mailto:` | — |
 
 ```yaml
 # page.mdx frontmatter
diff --git a/docs/content/docs/frontmatter.mdx b/docs/content/docs/frontmatter.mdx
index 66073b2a..28c47f02 100644
--- a/docs/content/docs/frontmatter.mdx
+++ b/docs/content/docs/frontmatter.mdx
@@ -105,12 +105,14 @@ A single author can be written without the list:
 authors: Jane Doe <jane@example.com>
 ```
 
-Authors appear as a byline under the page title, in the page's `Article`
-structured data, and on the generated social card. Every author also gets a page
-at `/authors/<slug>` listing everything they wrote, linked from the `/authors`
-index. When an email is given, the
-byline links to it with `mailto:`. The avatar beside each name is drawn from the
-author's initials unless the author has an `avatar` in the
+Authors appear as a byline on the page, in the page's `Article` structured data,
+and on the generated social card. Every author also gets a page at
+`/authors/<slug>` listing everything they wrote, and byline names link there. Any
+`url` or `email` an author has is shown on that page rather than in the byline.
+
+A byline shows two authors at most, collapsing the rest into a `+N` counter that
+names them on hover. The avatar beside each name is drawn from the author's
+initials unless the author has an `avatar` in the
 [authors registry](/docs/configuration).
 
 Registry keys work here too, and bring the author's bio, avatar, and profile
diff --git a/packages/chronicle/src/components/common/author-byline.tsx b/packages/chronicle/src/components/common/author-byline.tsx
index eb80ceba..4c145bc2 100644
--- a/packages/chronicle/src/components/common/author-byline.tsx
+++ b/packages/chronicle/src/components/common/author-byline.tsx
@@ -1,9 +1,11 @@
 'use client'
 
 import { Avatar, getAvatarColor } from '@raystack/apsara'
+import { Link } from 'react-router'
 import type { Author } from '@/types'
 import { authorInitials, resolveAuthors } from '@/lib/authors'
 import { usePageContext } from '@/lib/page-context'
+import { authorPageUrl } from '@/lib/route-resolver'
 import styles from './author-byline.module.css'
 
 /** Beyond this, the remainder is collapsed into a `+N` counter. */
@@ -20,28 +22,22 @@ interface AuthorBylineProps {
   className?: string
 }
 
-/** The name, linked to a profile url or email when the author has one. */
-function AuthorName({ author }: { author: Author }) {
-  if (author.url) {
-    return (
-      <a className={styles.name} href={author.url} rel='noreferrer' target='_blank'>
-        {author.name}
-      </a>
-    )
-  }
-  if (author.email) {
-    return (
-      <a className={styles.name} href={`mailto:${author.email}`}>
-        {author.name}
-      </a>
-    )
-  }
-  return <span className={styles.name}>{author.name}</span>
+/**
+ * The name, linked to the author's page. Their `url` and `email` are left to that
+ * page rather than competing with it here.
+ */
+function AuthorName({ author, href }: { author: Author; href: string | null }) {
+  if (!href) return <span className={styles.name}>{author.name}</span>
+  return (
+    <Link className={styles.name} to={href}>
+      {author.name}
+    </Link>
+  )
 }
 
 /** Byline for the authors declared in a page's frontmatter. */
 export function AuthorByline({ authors, variant = 'block', className }: AuthorBylineProps) {
-  const { config } = usePageContext()
+  const { config, version } = usePageContext()
   const parsed = resolveAuthors(authors, config)
   if (parsed.length === 0) return null
 
@@ -62,7 +58,7 @@ export function AuthorByline({ authors, variant = 'block', className }: AuthorBy
             color={getAvatarColor(author.name)}
             aria-hidden={author.avatar ? undefined : 'true'}
           />
-          <AuthorName author={author} />
+          <AuthorName author={author} href={authorPageUrl(author.slug, config, version)} />
         </span>
       ))}
       {hidden.length > 0 && (
diff --git a/packages/chronicle/src/lib/route-resolver.test.ts b/packages/chronicle/src/lib/route-resolver.test.ts
index 6aba86b0..1c80cd49 100644
--- a/packages/chronicle/src/lib/route-resolver.test.ts
+++ b/packages/chronicle/src/lib/route-resolver.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test'
 import { type ChronicleConfig, chronicleConfigSchema } from '@/types'
-import { resolveRoute, RouteType } from './route-resolver'
+import { authorPageUrl, resolveRoute, RouteType } from './route-resolver'
 import { LATEST_CONTEXT } from './version-source'
 
 function singleContent(): ChronicleConfig {
@@ -223,3 +223,21 @@ describe('resolveRoute — authors', () => {
     })
   })
 })
+
+describe('authorPageUrl', () => {
+  test('points at the author page', () => {
+    expect(authorPageUrl('jane', singleContent(), LATEST_CONTEXT)).toBe('/authors/jane')
+  })
+
+  test('keeps the version prefix', () => {
+    expect(authorPageUrl('jane', versioned(), { dir: 'v1', urlPrefix: '/v1' })).toBe('/v1/authors/jane')
+  })
+
+  test('encodes the slug', () => {
+    expect(authorPageUrl('ana ruiz', singleContent(), LATEST_CONTEXT)).toBe('/authors/ana%20ruiz')
+  })
+
+  test('is null when a content dir owns the authors segment', () => {
+    expect(authorPageUrl('jane', authorsAsContentDir(), LATEST_CONTEXT)).toBeNull()
+  })
+})
diff --git a/packages/chronicle/src/lib/route-resolver.ts b/packages/chronicle/src/lib/route-resolver.ts
index 2fab7f86..7b9f55ef 100644
--- a/packages/chronicle/src/lib/route-resolver.ts
+++ b/packages/chronicle/src/lib/route-resolver.ts
@@ -46,6 +46,19 @@ function hasAuthorRoutes(config: ChronicleConfig, version: VersionContext): bool
   return !contentDirsFor(config, version).includes(AUTHORS_SEGMENT)
 }
 
+/**
+ * Url of an author's page, or null when author routes are unavailable because a
+ * content dir owns the `authors` segment.
+ */
+export function authorPageUrl(
+  slug: string,
+  config: ChronicleConfig,
+  version: VersionContext,
+): string | null {
+  if (!hasAuthorRoutes(config, version)) return null
+  return `${version.urlPrefix}/${AUTHORS_SEGMENT}/${encodeURIComponent(slug)}`
+}
+
 function isLandingEnabled(
   config: ChronicleConfig,
   version: VersionContext,

From 403ef9e8c90797ce5b19312228a3c0464a3af96a Mon Sep 17 00:00:00 2001
From: Rishabh <me@rsbh.dev>
Date: Wed, 19 Aug 2026 16:10:45 +0530
Subject: [PATCH 6/6] fix: hide the AI menu on author pages
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Author pages aren't MDX, so `/authors/jane.md` 404s and every item in the
menu — copy, view, and both hand-offs — fails silently. Hide it there.

Adds an isAuthorRoute predicate and uses it at the four places that were
each spelling the check out.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 packages/chronicle/src/lib/page-context.tsx      | 2 +-
 packages/chronicle/src/lib/route-resolver.ts     | 5 +++++
 packages/chronicle/src/server/App.tsx            | 5 ++---
 packages/chronicle/src/server/entry-server.tsx   | 9 ++++-----
 packages/chronicle/src/themes/default/Layout.tsx | 5 ++++-
 5 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/packages/chronicle/src/lib/page-context.tsx b/packages/chronicle/src/lib/page-context.tsx
index e1109af6..d1c3b7f9 100644
--- a/packages/chronicle/src/lib/page-context.tsx
+++ b/packages/chronicle/src/lib/page-context.tsx
@@ -76,7 +76,7 @@ function getInitialErrorStatus(page: Page | null, config: ChronicleConfig, pathn
   if (route.type === RouteType.ApiIndex || route.type === RouteType.ApiPage) return null;
   if (route.type === RouteType.Redirect) return null;
   if (route.type === RouteType.DocsIndex) return null;
-  if (route.type === RouteType.AuthorIndex || route.type === RouteType.AuthorPage) return null;
+  if (isAuthorRoute(route)) return null;
   return 404;
 }
 
diff --git a/packages/chronicle/src/lib/route-resolver.ts b/packages/chronicle/src/lib/route-resolver.ts
index 7b9f55ef..df034d0c 100644
--- a/packages/chronicle/src/lib/route-resolver.ts
+++ b/packages/chronicle/src/lib/route-resolver.ts
@@ -24,6 +24,11 @@ export type Route =
   | { type: typeof RouteType.AuthorIndex; version: VersionContext }
   | { type: typeof RouteType.AuthorPage; version: VersionContext; authorSlug: string }
 
+/** True for `/authors` and `/authors/<slug>`. */
+export function isAuthorRoute(route: Route): boolean {
+  return route.type === RouteType.AuthorIndex || route.type === RouteType.AuthorPage
+}
+
 function contentDirsFor(
   config: ChronicleConfig,
   version: VersionContext,
diff --git a/packages/chronicle/src/server/App.tsx b/packages/chronicle/src/server/App.tsx
index 288da04e..fd8b7e14 100644
--- a/packages/chronicle/src/server/App.tsx
+++ b/packages/chronicle/src/server/App.tsx
@@ -4,7 +4,7 @@ import { Navigate, useLocation } from 'react-router';
 import { AnalyticsProvider } from '@/components/analytics/AnalyticsProvider';
 import { SearchDialog, SearchProvider } from '@/components/ui/search';
 import { usePageContext } from '@/lib/page-context';
-import { resolveRoute, RouteType } from '@/lib/route-resolver';
+import { isAuthorRoute, resolveRoute, RouteType } from '@/lib/route-resolver';
 import type { ChronicleConfig } from '@/types';
 import { getThemeConfig } from '@/themes/registry';
 import styles from './App.module.css';
@@ -32,8 +32,7 @@ export function App() {
   const apiSlug = route.type === RouteType.ApiPage ? route.slug : [];
   const docsSlug = route.type === RouteType.DocsPage ? route.slug : [];
   const isLanding = route.type === RouteType.DocsIndex;
-  const isAuthors =
-    route.type === RouteType.AuthorIndex || route.type === RouteType.AuthorPage;
+  const isAuthors = isAuthorRoute(route);
 
   return (
     <ThemeProvider
diff --git a/packages/chronicle/src/server/entry-server.tsx b/packages/chronicle/src/server/entry-server.tsx
index 6bcc0ed3..dd6fd460 100644
--- a/packages/chronicle/src/server/entry-server.tsx
+++ b/packages/chronicle/src/server/entry-server.tsx
@@ -9,7 +9,7 @@ import { getApiConfigsForVersion, loadConfig } from '@/lib/config';
 import { buildAuthorIndex } from '@/lib/author-index';
 import { loadApiSpecs } from '@/lib/openapi';
 import { PageProvider } from '@/lib/page-context';
-import { resolveRoute, RouteType } from '@/lib/route-resolver';
+import { isAuthorRoute, resolveRoute, RouteType } from '@/lib/route-resolver';
 import { getPage, getPageTree, isDraft, getPageNav, loadPageModule, extractFrontmatter, getRelativePath, getOriginalPath, getPageImages, getPages } from '@/lib/source';
 import { getFirstApiUrl } from '@/lib/api-routes';
 import { StatusCodes } from 'http-status-codes';
@@ -112,8 +112,7 @@ export default {
       });
     }
 
-    const isAuthorRoute =
-      route.type === RouteType.AuthorIndex || route.type === RouteType.AuthorPage;
+    const isAuthorsRoute = isAuthorRoute(route);
     const nav = page ? await getPageNav(resolvedSlug) : { prev: null, next: null };
 
     const relativePath = page ? getRelativePath(page) : null;
@@ -137,7 +136,7 @@ export default {
         }
       : null;
 
-    const authorIndex = isAuthorRoute
+    const authorIndex = isAuthorsRoute
       ? buildAuthorIndex(
           (await getPages()).map(p => ({ url: p.url, frontmatter: extractFrontmatter(p) })),
           config,
@@ -160,7 +159,7 @@ export default {
 
     const routeAssets = isApiRoute
       ? [apiLayoutAssets, apiPageAssets]
-      : isAuthorRoute
+      : isAuthorsRoute
         ? [docsLayoutAssets, authorsPageAssets]
         : route.type === RouteType.DocsIndex
           ? [docsLayoutAssets, landingPageAssets]
diff --git a/packages/chronicle/src/themes/default/Layout.tsx b/packages/chronicle/src/themes/default/Layout.tsx
index ca84daf6..42784b24 100644
--- a/packages/chronicle/src/themes/default/Layout.tsx
+++ b/packages/chronicle/src/themes/default/Layout.tsx
@@ -24,6 +24,7 @@ import { Breadcrumbs } from '@/components/ui/breadcrumbs';
 import { getLandingEntries } from '@/lib/config';
 import { getActiveContentDir } from '@/lib/navigation';
 import { usePageContext } from '@/lib/page-context';
+import { isAuthorRoute, resolveRoute } from '@/lib/route-resolver';
 import type { Node, Root } from 'fumadocs-core/page-tree';
 import { NodeType } from '@/lib/tree-utils';
 import type { ThemeLayoutProps } from '@/types';
@@ -75,6 +76,8 @@ export function Layout({
   const scrollRef = useRef<HTMLDivElement>(null);
   const [mobileSidebarOpen, setMobileSidebarOpen] = useState(false);
   const isApiRoute = pathname === '/apis' || pathname.startsWith('/apis/');
+  // Author pages aren't MDX, so they have no `.md` for the AI menu to hand over.
+  const isAuthorsRoute = isAuthorRoute(resolveRoute(pathname, config));
   const isApiBase = (basePath: string) =>
     pathname === basePath || pathname.startsWith(`${basePath}/`);
   const docNav = page ?? { prev: null, next: null };
@@ -286,7 +289,7 @@ export function Layout({
                 <Flex align='center' gap={3}>
                   {isApiRoute && <TestRequestButton />}
                   {isApiRoute && <ViewDocsButton />}
-                  <OpenInAI />
+                  {!isAuthorsRoute && <OpenInAI />}
                 </Flex>
               </nav>
               <main className={cx(styles.content, classNames?.content)}>