@hutusi/amytis 1.13.0 → 1.15.0

package/scripts/run-with-rst-python.ts

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const [command, ...args] = Bun.argv.slice(2);
+
+if (!command) {
+  console.error('Missing command to run.');
+  process.exit(1);
+}
+
+const env = { ...process.env };
+if (!env.AMYTIS_RST_PYTHON) {
+  const localPython = path.join(
+    process.cwd(),
+    '.venv-rst',
+    process.platform === 'win32' ? 'Scripts' : 'bin',
+    process.platform === 'win32' ? 'python.exe' : 'python',
+  );
+  if (fs.existsSync(localPython)) {
+    env.AMYTIS_RST_PYTHON = localPython;
+  }
+}
+
+const child = spawn(command, args, {
+  stdio: 'inherit',
+  env,
+  shell: process.platform === 'win32',
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 1);
+});
+
+child.on('error', (error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/src/app/[slug]/[postSlug]/page.tsx

@@ -67,17 +67,26 @@ export async function generateStaticParams() {
     }
   }
 
-  // Work around Next dev static-param checks for percent-encoded Unicode postSlugs
-  // under `output: "export"` — dev server may receive percent-encoded forms of Unicode paths.
+  // Work around Next dev static-param checks for percent-encoded Unicode slugs
+  // under `output: "export"` — dev server may receive encoded forms of either segment.
   // Include encoded variants in development only; production export keeps raw segment values.
   if (process.env.NODE_ENV !== 'production') {
     const existing = new Set(params.map(p => `${p.slug}/${p.postSlug}`));
     for (const p of [...params]) {
+      const encodedSlug = encodeURIComponent(p.slug);
       const encodedPostSlug = encodeURIComponent(p.postSlug);
-      const key = `${p.slug}/${encodedPostSlug}`;
-      if (!existing.has(key)) {
-        existing.add(key);
-        params.push({ slug: p.slug, postSlug: encodedPostSlug });
+      const variants = [
+        { slug: p.slug, postSlug: encodedPostSlug },
+        { slug: encodedSlug, postSlug: p.postSlug },
+        { slug: encodedSlug, postSlug: encodedPostSlug },
+      ];
+
+      for (const variant of variants) {
+        const key = `${variant.slug}/${variant.postSlug}`;
+        if (!existing.has(key)) {
+          existing.add(key);
+          params.push(variant);
+        }
       }
     }
   }
@@ -154,7 +163,8 @@ export default async function PrefixPostPage({
   params: Promise<{ slug: string; postSlug: string }>;
 }) {
   const { slug: prefix, postSlug: rawPostSlug } = await params;
-  const currentPath = `/${safeDecodeParam(prefix)}/${safeDecodeParam(rawPostSlug)}`;
+  const decodedPrefix = safeDecodeParam(prefix);
+  const currentPath = `/${decodedPrefix}/${safeDecodeParam(rawPostSlug)}`;
 
   // Resolve the post: first by slug, then fall back to redirectFrom lookup for renamed slugs.
   const post =
@@ -168,9 +178,9 @@ export default async function PrefixPostPage({
   // or a legacy redirectFrom path declared on the resolved post.
   const basePath = getPostsBasePath();
   const customPaths = getSeriesCustomPaths();
-  const isValidBasePath = prefix === basePath && basePath !== 'posts';
-  const matchedSeriesSlug = Object.entries(customPaths).find(([, path]) => path === prefix)?.[0];
-  const isAutoSeriesPath = getSeriesAutoPaths() && !Object.hasOwn(customPaths, prefix) && getSeriesData(prefix) !== null;
+  const isValidBasePath = decodedPrefix === basePath && basePath !== 'posts';
+  const matchedSeriesSlug = Object.entries(customPaths).find(([, path]) => path === decodedPrefix)?.[0];
+  const isAutoSeriesPath = getSeriesAutoPaths() && !Object.hasOwn(customPaths, decodedPrefix) && getSeriesData(decodedPrefix) !== null;
   const isLegacyRedirect = post.redirectFrom?.includes(currentPath) ?? false;
 
   if (!isValidBasePath && !matchedSeriesSlug && !isAutoSeriesPath && !isLegacyRedirect) {

package/src/app/[slug]/page/[page]/page.tsx

@@ -57,6 +57,21 @@ export async function generateStaticParams() {
     }
   }
 
+  // Work around Next dev static-param checks for percent-encoded Unicode slugs
+  // under `output: "export"` — dev server may receive encoded forms of the
+  // prefix segment for paginated listings.
+  if (process.env.NODE_ENV !== 'production') {
+    const existing = new Set(params.map(p => `${p.slug}/${p.page}`));
+    for (const p of [...params]) {
+      const encodedSlug = encodeURIComponent(p.slug);
+      const key = `${encodedSlug}/${p.page}`;
+      if (!existing.has(key)) {
+        existing.add(key);
+        params.push({ slug: encodedSlug, page: p.page });
+      }
+    }
+  }
+
   // Placeholder keeps Next.js happy with output: export when no custom paths configured.
   // dynamicParams = false ensures any unrecognised slug/page combo returns 404.
   return params.length > 0 ? params : [{ slug: '_', page: '2' }];

package/src/app/all.atom/route.ts

@@ -0,0 +1,7 @@
+import { generateAtomFeed } from '@/lib/feed-utils';
+
+export const dynamic = 'force-static';
+
+export async function GET() {
+  return generateAtomFeed('all', '/all.atom');
+}

package/src/app/all.xml/route.ts

@@ -0,0 +1,7 @@
+import { generateRssFeed } from '@/lib/feed-utils';
+
+export const dynamic = 'force-static';
+
+export async function GET() {
+  return generateRssFeed('all', '/all.xml');
+}

package/src/app/archive/page.tsx

@@ -128,12 +128,12 @@ export default function ArchivePage() {
                               <li key={post.slug} className="group">
                                 <Link href={getPostUrl(post)} className="block no-underline">
                                   <div className="flex flex-col sm:flex-row sm:items-baseline justify-between gap-2 sm:gap-6">
-                                    <div className="flex items-baseline gap-6">
+                                    <div className="flex items-baseline gap-6 min-w-0 flex-1">
                                       <span className="font-mono text-base text-muted shrink-0 w-8">
                                         {day}
                                       </span>
-                                      <div className="flex items-baseline gap-2">
-                                        <h4 className="text-xl font-serif font-medium text-heading/80 group-hover:text-accent transition-colors duration-200">
+                                      <div className="flex items-baseline gap-2 min-w-0 flex-1">
+                                        <h4 className="text-xl font-serif font-medium text-heading/80 group-hover:text-accent transition-colors duration-200 truncate">
                                           {post.title}
                                         </h4>
                                         {post.series && (
@@ -147,7 +147,10 @@ export default function ArchivePage() {
                                       </div>
                                     </div>
                                     {showAuthors && post.authors.length > 0 && (
-                                      <span className="text-sm font-sans italic text-muted/60 shrink-0 hidden sm:block">
+                                      <span 
+                                        title={post.authors.join(', ')}
+                                        className="text-sm font-sans italic text-muted/60 hidden sm:block max-w-[12rem] md:max-w-[16rem] lg:max-w-[20rem] truncate text-right shrink-0"
+                                      >
                                         {post.authors.join(', ')}
                                       </span>
                                     )}

package/src/app/feed.atom/route.ts

@@ -1,62 +1,7 @@
-import { siteConfig } from '../../../site.config';
-import { resolveLocale } from '@/lib/i18n';
-import { getFeedItems } from '@/lib/feed-utils';
+import { generateAtomFeed } from '@/lib/feed-utils';
 
 export const dynamic = 'force-static';
 
-const escapeXml = (v: string) =>
-  v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
-   .replace(/"/g, '&quot;').replace(/'/g, '&apos;');
-
-const escapeCdata = (v: string) => v.replace(/]]>/g, ']]]]><![CDATA[>');
-
 export async function GET() {
-  const { format, content: contentMode } = siteConfig.feed;
-  if (format === 'rss') {
-    return new Response('Not Found', { status: 404 });
-  }
-
-  const baseUrl = siteConfig.baseUrl.replace(/\/+$/, '');
-  const items = getFeedItems();
-  const useFullContent = contentMode === 'full';
-  const feedUpdated = items[0]?.date.toISOString() ?? new Date().toISOString();
-
-  const entriesXml = items
-    .map((item) => {
-      const contentXml = useFullContent
-        ? `<content type="html"><![CDATA[${escapeCdata(item.content)}]]></content>\n    <summary><![CDATA[${escapeCdata(item.excerpt)}]]></summary>`
-        : `<summary><![CDATA[${escapeCdata(item.excerpt)}]]></summary>`;
-      const authorsXml = item.authors?.map((a) => `<author><name>${escapeXml(a)}</name></author>`).join('') ?? '';
-      const categoriesXml = item.tags.map((tag) => `<category term="${escapeXml(tag)}" />`).join('');
-      return `
-  <entry>
-    <title><![CDATA[${escapeCdata(item.title)}]]></title>
-    <link href="${escapeXml(item.url)}" />
-    <id>${escapeXml(item.url)}</id>
-    <published>${item.date.toISOString()}</published>
-    <updated>${item.date.toISOString()}</updated>
-    ${contentXml}
-    ${authorsXml}
-    ${categoriesXml}
-  </entry>`;
-    })
-    .join('');
-
-  const atomXml = `<?xml version="1.0" encoding="UTF-8" ?>
-<feed xmlns="http://www.w3.org/2005/Atom">
-  <title><![CDATA[${escapeCdata(resolveLocale(siteConfig.title))}]]></title>
-  <link href="${escapeXml(baseUrl)}" />
-  <link href="${escapeXml(baseUrl)}/feed.atom" rel="self" type="application/atom+xml" />
-  <id>${escapeXml(baseUrl)}/feed.atom</id>
-  <updated>${feedUpdated}</updated>
-  <subtitle><![CDATA[${escapeCdata(resolveLocale(siteConfig.description))}]]></subtitle>
-${entriesXml}
-</feed>`;
-
-  return new Response(atomXml, {
-    headers: {
-      'Content-Type': 'application/atom+xml; charset=utf-8',
-      'Cache-Control': 'public, max-age=3600',
-    },
-  });
+  return generateAtomFeed('main', '/feed.atom');
 }

package/src/app/feed.xml/route.ts

@@ -1,69 +1,7 @@
-import { siteConfig } from '../../../site.config';
-import { resolveLocale } from '@/lib/i18n';
-import { getFeedItems } from '@/lib/feed-utils';
+import { generateRssFeed } from '@/lib/feed-utils';
 
 export const dynamic = 'force-static';
 
-const escapeXml = (v: string) =>
-  v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
-   .replace(/"/g, '&quot;').replace(/'/g, '&apos;');
-
-const escapeCdata = (v: string) => v.replace(/]]>/g, ']]]]><![CDATA[>');
-
 export async function GET() {
-  const { format, content: contentMode } = siteConfig.feed;
-  if (format === 'atom') {
-    return new Response('Not Found', { status: 404 });
-  }
-
-  const baseUrl = siteConfig.baseUrl.replace(/\/+$/, '');
-  const items = getFeedItems();
-  const useFullContent = contentMode === 'full';
-  const contentNs = useFullContent ? ' xmlns:content="http://purl.org/rss/modules/content/"' : '';
-  const siteTitle = resolveLocale(siteConfig.title);
-  const lastBuildDate = items[0]?.date.toUTCString() ?? new Date().toUTCString();
-
-  const imageXml = siteConfig.ogImage
-    ? `\n    <image>\n      <url>${escapeXml(baseUrl + siteConfig.ogImage)}</url>\n      <title>${escapeXml(siteTitle)}</title>\n      <link>${escapeXml(baseUrl)}</link>\n    </image>`
-    : '';
-
-  const rssItemsXml = items
-    .map((item) => {
-      const fullContentXml = useFullContent
-        ? `\n          <content:encoded><![CDATA[${escapeCdata(item.content)}]]></content:encoded>`
-        : '';
-      const authorsXml = item.authors?.length
-        ? item.authors.map((a) => `\n          <dc:creator><![CDATA[${escapeCdata(a)}]]></dc:creator>`).join('')
-        : '';
-      return `
-        <item>
-          <title><![CDATA[${escapeCdata(item.title)}]]></title>
-          <link>${escapeXml(item.url)}</link>
-          <guid isPermaLink="true">${escapeXml(item.url)}</guid>
-          <pubDate>${item.date.toUTCString()}</pubDate>
-          <description><![CDATA[${escapeCdata(item.excerpt)}]]></description>${fullContentXml}${authorsXml}
-          ${item.tags.map((tag) => `<category><![CDATA[${escapeCdata(tag)}]]></category>`).join('')}
-        </item>`;
-    })
-    .join('');
-
-  const rssXml = `<?xml version="1.0" encoding="UTF-8" ?>
-<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/"${contentNs}>
-  <channel>
-    <title><![CDATA[${escapeCdata(siteTitle)}]]></title>
-    <link>${escapeXml(baseUrl)}</link>
-    <description><![CDATA[${escapeCdata(resolveLocale(siteConfig.description))}]]></description>
-    <language>${siteConfig.i18n.defaultLocale}</language>
-    <lastBuildDate>${lastBuildDate}</lastBuildDate>
-    <atom:link href="${escapeXml(baseUrl)}/feed.xml" rel="self" type="application/rss+xml" />${imageXml}
-    ${rssItemsXml}
-  </channel>
-</rss>`;
-
-  return new Response(rssXml, {
-    headers: {
-      'Content-Type': 'application/rss+xml; charset=utf-8',
-      'Cache-Control': 'public, max-age=3600',
-    },
-  });
+  return generateRssFeed('main', '/feed.xml');
 }

package/src/app/flows/[year]/[month]/[day]/page.tsx

@@ -88,6 +88,9 @@ export default async function FlowPage({ params }: { params: Promise<{ year: str
           {/* Header */}
           <header className="mb-8">
             <time className="text-base font-mono text-accent" data-pagefind-meta="date[content]">{flow.date}</time>
+            {flow.title !== flow.date && (
+              <h1 className="mt-2 text-xl sm:text-2xl font-serif font-bold text-heading">{flow.title}</h1>
+            )}
             {flow.tags.length > 0 && (
               <div className="mt-3 flex flex-wrap gap-2">
                 {flow.tags.map(tag => (
@@ -121,6 +124,11 @@ export default async function FlowPage({ params }: { params: Promise<{ year: str
                 <div className="text-sm font-mono text-heading group-hover:text-accent transition-colors">
                   {prev.date}
                 </div>
+                {prev.title !== prev.date && (
+                  <div className="text-sm text-muted group-hover:text-accent/80 transition-colors truncate">
+                    {prev.title}
+                  </div>
+                )}
               </Link>
             ) : <div />}
             {next ? (
@@ -132,6 +140,11 @@ export default async function FlowPage({ params }: { params: Promise<{ year: str
                 <div className="text-sm font-mono text-heading group-hover:text-accent transition-colors">
                   {next.date}
                 </div>
+                {next.title !== next.date && (
+                  <div className="text-sm text-muted group-hover:text-accent/80 transition-colors truncate">
+                    {next.title}
+                  </div>
+                )}
               </Link>
             ) : <div />}
           </nav>

package/src/app/flows/feed.atom/route.ts

@@ -0,0 +1,7 @@
+import { generateAtomFeed } from '@/lib/feed-utils';
+
+export const dynamic = 'force-static';
+
+export async function GET() {
+  return generateAtomFeed('flows', '/flows/feed.atom');
+}

package/src/app/flows/feed.xml/route.ts

@@ -0,0 +1,7 @@
+import { generateRssFeed } from '@/lib/feed-utils';
+
+export const dynamic = 'force-static';
+
+export async function GET() {
+  return generateRssFeed('flows', '/flows/feed.xml');
+}

package/src/app/globals.css

@@ -451,3 +451,168 @@ body {
 [id] {
   scroll-margin-top: 5rem;
 }
+
+.rst-rendered figure {
+  margin: 2rem 0;
+}
+
+.rst-rendered figure > img {
+  display: block;
+  width: 100%;
+  height: auto;
+  border-radius: 0.75rem;
+}
+
+.rst-rendered figcaption {
+  margin-top: 0.75rem;
+  text-align: center;
+  font-size: 0.95rem;
+  line-height: 1.6;
+  color: var(--muted);
+  font-style: italic;
+}
+
+.rst-rendered aside.admonition {
+  margin: 2rem 0;
+  border-left: 4px solid var(--accent);
+  border-radius: 0.75rem;
+  padding: 1rem 1.25rem;
+  background: color-mix(in srgb, var(--accent) 8%, var(--background));
+}
+
+.rst-rendered aside.admonition > :first-child {
+  margin-top: 0;
+}
+
+.rst-rendered aside.admonition > :last-child {
+  margin-bottom: 0;
+}
+
+.rst-rendered .admonition-title {
+  margin-bottom: 0.5rem;
+  font-family: var(--font-inter), ui-sans-serif, system-ui, sans-serif;
+  font-size: 0.8rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--heading);
+}
+
+.rst-rendered .docutils.literal {
+  border: 1px solid color-mix(in srgb, var(--muted) 24%, transparent);
+  border-radius: 0.375rem;
+  background: color-mix(in srgb, var(--muted) 10%, var(--background));
+  padding: 0.1rem 0.35rem;
+  font-size: 0.9em;
+  color: var(--heading);
+}
+
+.rst-rendered .dtag {
+  display: inline-block;
+  border: 1px solid color-mix(in srgb, var(--accent) 28%, transparent);
+  border-radius: 999px;
+  background: color-mix(in srgb, var(--accent) 10%, var(--background));
+  padding: 0.1rem 0.55rem;
+  font-size: 0.78rem;
+  font-weight: 600;
+  color: var(--accent);
+}
+
+.rst-rendered a[href]:not([role="doc-noteref"]) {
+  color: var(--accent);
+  text-decoration: none;
+  transition: color 160ms ease, text-decoration-color 160ms ease;
+}
+
+.rst-rendered a[href]:not([role="doc-noteref"]):hover,
+.rst-rendered a[href]:not([role="doc-noteref"]):focus-visible {
+  color: var(--accent);
+  text-decoration: underline;
+}
+
+.rst-rendered .numref {
+  color: inherit;
+  font-weight: inherit;
+}
+
+.rst-rendered .rst-table-wrapper {
+  overflow-x: auto;
+  margin: 2rem 0;
+  border: 1px solid color-mix(in srgb, var(--muted) 20%, transparent);
+  border-radius: 0.5rem;
+}
+
+.rst-rendered .rst-table-wrapper > table {
+  min-width: 100%;
+  margin: 0;
+  font-size: 0.875rem;
+}
+
+.rst-rendered math {
+  display: inline-block;
+  max-width: 100%;
+  overflow-x: auto;
+  vertical-align: middle;
+}
+
+.rst-rendered pre.literal-block,
+.rst-rendered pre.code.literal-block {
+  overflow-x: auto;
+  border: 1px solid color-mix(in srgb, var(--muted) 28%, transparent);
+  border-radius: 0.875rem;
+  background: color-mix(in srgb, var(--heading) 7%, var(--background));
+  padding: 1rem 1.25rem;
+  color: var(--heading);
+  font-size: 0.95rem;
+  line-height: 1.7;
+  box-shadow: inset 0 1px 0 color-mix(in srgb, white 60%, transparent);
+}
+
+.dark .rst-rendered pre.literal-block,
+.dark .rst-rendered pre.code.literal-block {
+  border-color: color-mix(in srgb, var(--muted) 22%, transparent);
+  background: color-mix(in srgb, var(--foreground) 9%, var(--background));
+  color: var(--foreground);
+  box-shadow: inset 0 1px 0 color-mix(in srgb, white 5%, transparent);
+}
+
+.rst-rendered pre.code.literal-block code {
+  border: 0;
+  background: transparent;
+  padding: 0;
+  color: inherit;
+}
+
+.rst-rendered pre.code.literal-block .keyword,
+.rst-rendered pre.code.literal-block .name.function {
+  color: var(--accent);
+  font-weight: 600;
+}
+
+.rst-rendered pre.code.literal-block .literal.string,
+.rst-rendered pre.code.literal-block .literal.string.double {
+  color: color-mix(in srgb, var(--accent) 68%, var(--foreground));
+}
+
+.rst-rendered a[role="doc-noteref"] {
+  font-size: 0.82em;
+  vertical-align: super;
+}
+
+.rst-rendered .footnote-list {
+  margin: 1.5rem 0 2rem;
+  border-top: 1px solid color-mix(in srgb, var(--muted) 24%, transparent);
+  padding-top: 1rem;
+}
+
+.rst-rendered .footnote {
+  margin: 0.75rem 0;
+  color: var(--muted);
+  font-size: 0.95rem;
+}
+
+.rst-rendered .footnote .label {
+  margin-right: 0.4rem;
+  font-weight: 600;
+  color: var(--heading);
+}

package/src/app/page.tsx

@@ -96,6 +96,7 @@ export default function Home() {
     ? recentFlows.map(f => ({
         slug: f.slug,
         date: f.date,
+        title: f.title,
         excerpt: f.excerpt,
       }))
     : [];

package/src/app/posts/feed.atom/route.ts

@@ -0,0 +1,9 @@
+import { generateAtomFeed } from '@/lib/feed-utils';
+import { getPostsBasePath } from '@/lib/urls';
+
+export const dynamic = 'force-static';
+
+export async function GET() {
+  const basePath = getPostsBasePath();
+  return generateAtomFeed('posts', `/${basePath}/feed.atom`);
+}

package/src/app/posts/feed.xml/route.ts

@@ -0,0 +1,9 @@
+import { generateRssFeed } from '@/lib/feed-utils';
+import { getPostsBasePath } from '@/lib/urls';
+
+export const dynamic = 'force-static';
+
+export async function GET() {
+  const basePath = getPostsBasePath();
+  return generateRssFeed('posts', `/${basePath}/feed.xml`);
+}

package/src/app/series/[slug]/page/[page]/page.tsx

@@ -7,22 +7,74 @@ import { siteConfig } from '../../../../../../site.config';
 import CoverImage from '@/components/CoverImage';
 import Link from 'next/link';
 import { t, resolveLocale, tWith } from '@/lib/i18n';
+import { getSeriesListUrl } from '@/lib/urls';
+import RedirectPage from '@/components/RedirectPage';
+import { findSeriesByRedirectFrom, safeDecodeParam } from '@/lib/series-redirects';
 
 const PAGE_SIZE = siteConfig.pagination.series;
 
 export async function generateStaticParams() {
   const allSeries = getAllSeries();
+  const seriesBasePath = getSeriesListUrl();
+  const seen = new Set<string>();
+  const reservedSlugs = new Set(Object.keys(allSeries));
+  const claimedAliases = new Map<string, string>();
   const params: { slug: string; page: string }[] = [];
-  
+  const pushParam = (slug: string, page: string) => {
+    const key = `${slug}:${page}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    params.push({ slug, page });
+  };
+
   Object.keys(allSeries).forEach(slug => {
     const posts = allSeries[slug];
     const totalPages = Math.ceil(posts.length / PAGE_SIZE);
     if (totalPages > 1) {
-        for (let i = 2; i <= totalPages; i++) {
-            params.push({ slug, page: i.toString() });
-        }
+      for (let i = 2; i <= totalPages; i++) {
+        pushParam(slug, i.toString());
+      }
+    }
+
+    const data = getSeriesData(slug);
+    for (const from of data?.redirectFrom ?? []) {
+      const segments = from.split('/').filter(Boolean);
+      const expectedBase = seriesBasePath.replace(/^\/+|\/+$/g, '');
+      if (segments.length !== 2 || segments[0] !== expectedBase) continue;
+      const aliasSlug = segments[1];
+      if (aliasSlug === slug || totalPages <= 1) continue;
+      const claimedBy = claimedAliases.get(aliasSlug);
+      if (claimedBy && claimedBy !== slug) {
+        throw new Error(
+          `[amytis] series redirectFrom alias "${from}" is claimed by both "${claimedBy}" and "${slug}".`
+        );
+      }
+      if (!claimedBy && reservedSlugs.has(aliasSlug)) {
+        throw new Error(
+          `[amytis] series redirectFrom alias "${from}" for "${slug}" conflicts with an existing series slug.`
+        );
+      }
+      claimedAliases.set(aliasSlug, slug);
+      reservedSlugs.add(aliasSlug);
+      for (let i = 2; i <= totalPages; i++) {
+        pushParam(aliasSlug, i.toString());
+      }
     }
   });
+
+  if (process.env.NODE_ENV !== 'production') {
+    const encodedParams = params
+      .filter(param => encodeURIComponent(param.slug) !== param.slug)
+      .map(param => ({ ...param, slug: encodeURIComponent(param.slug) }))
+      .filter(param => {
+        const key = `${param.slug}:${param.page}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      });
+    params.push(...encodedParams);
+  }
+
   if (params.length === 0) return [{ slug: '_', page: '2' }];
   return params;
 }
@@ -31,7 +83,17 @@ export const dynamicParams = false;
 
 export async function generateMetadata({ params }: { params: Promise<{ slug: string; page: string }> }): Promise<Metadata> {
   const { slug: rawSlug, page } = await params;
-  const slug = decodeURIComponent(rawSlug);
+  const slug = safeDecodeParam(rawSlug);
+  const currentPath = `${getSeriesListUrl()}/${slug}`;
+  const redirect = findSeriesByRedirectFrom(currentPath);
+  if (redirect) {
+    const siteUrl = siteConfig.baseUrl.replace(/\/+$/, '');
+    return {
+      title: redirect.data.title,
+      alternates: { canonical: `${siteUrl}${getSeriesListUrl()}/${redirect.slug}/page/${page}` },
+    };
+  }
+
   const seriesData = getSeriesData(slug);
   const title = seriesData?.title || slug;
   const allPosts = seriesData?.type === 'collection' ? getCollectionPosts(slug) : getSeriesPosts(slug);
@@ -43,8 +105,14 @@ export async function generateMetadata({ params }: { params: Promise<{ slug: str
 
 export default async function SeriesPage({ params }: { params: Promise<{ slug: string; page: string }> }) {
   const { slug: rawSlug, page: pageStr } = await params;
-  const slug = decodeURIComponent(rawSlug);
+  const slug = safeDecodeParam(rawSlug);
   const page = parseInt(pageStr);
+  const currentPath = `${getSeriesListUrl()}/${slug}`;
+  const redirect = findSeriesByRedirectFrom(currentPath);
+  if (redirect) {
+    return <RedirectPage to={`${getSeriesListUrl()}/${redirect.slug}/page/${page}`} />;
+  }
+
   const seriesData = getSeriesData(slug);
   const isCollection = seriesData?.type === 'collection';
   const allPosts = isCollection ? getCollectionPosts(slug) : getSeriesPosts(slug);