fix: return 404 (not 500) for catch-all paths with no content file

Paths that match a section catch-all but have no backing .md file (e.g.
/learn/state, a sidebar header) were 500ing. The fs read threw inside
readMarkdownPage's 'use cache' scope, which surfaces as a render error
instead of falling through to notFound().

readMarkdownPage now returns PageData | null for a missing file instead
of throwing; callers decide notFound(). Removes the now-redundant
safeReadPage try/catch wrapper.

Author: aurorascharff

src/app/page.tsx

@@ -6,6 +6,7 @@
  */
 
 import type {Metadata} from 'next';
+import {notFound} from 'next/navigation';
 import sidebarHome from '../sidebarHome.json';
 import type {RouteItem} from 'components/Layout/getRouteMeta';
 import {readMarkdownPage} from 'lib/readMarkdownPage';
@@ -14,11 +15,13 @@ import {DocsPage} from './DocsPage';
 
 export async function generateMetadata(): Promise<Metadata> {
   const data = await readMarkdownPage([]);
+  if (!data) return {};
   return buildPageMetadata({data, pathname: '/', section: 'home'});
 }
 
 export default async function HomePage() {
   const data = await readMarkdownPage([]);
+  if (!data) notFound();
   return (
     <DocsPage
       data={data}

src/app/renderSectionPage.tsx

@@ -25,7 +25,7 @@ export async function renderSectionPage({
   section,
   routeTree,
 }: RenderArgs) {
-  const data = await safeReadPage(segments);
+  const data = await readMarkdownPage(segments);
   if (!data) notFound();
   const pathname = '/' + segments.join('/');
   return (
@@ -47,21 +47,8 @@ export async function sectionPageMetadata({
   section: PageSection;
   routeTree?: RouteItem;
 }): Promise<Metadata> {
-  const data = await safeReadPage(segments);
+  const data = await readMarkdownPage(segments);
   if (!data) return {};
   const pathname = '/' + segments.join('/');
   return buildPageMetadata({data, pathname, section, routeTree});
 }
-
-async function safeReadPage(segments: string[]) {
-  try {
-    return await readMarkdownPage(segments);
-  } catch (err) {
-    console.error(
-      '[renderSectionPage] readMarkdownPage failed for',
-      segments,
-      err
-    );
-    return null;
-  }
-}

src/lib/readMarkdownPage.ts

@@ -22,22 +22,35 @@ const ROOT = path.join(process.cwd(), 'src/content');
 
 /**
  * Read and compile an MDX page from src/content. Resolves either
- * `<segments>.md` or `<segments>/index.md`. Throws if neither exists.
+ * `<segments>.md` or `<segments>/index.md`. Returns null when neither exists.
  *
  * Cached at this layer (keyed on `segments`) so the page render and its
  * `generateMetadata` share one compile, and so callers don't each need
  * their own `'use cache'`. Content only changes on deploy, so `'max'`.
+ *
+ * Returns null (rather than throwing) for a missing file: throwing inside a
+ * `'use cache'` scope surfaces as a render error instead of letting callers
+ * fall through to `notFound()`.
  */
-export async function readMarkdownPage(segments: string[]): Promise<PageData> {
+export async function readMarkdownPage(
+  segments: string[]
+): Promise<PageData | null> {
   'use cache';
   cacheLife('max');
   const routePath = segments.join('/') || 'index';
-  let mdx: string;
-  try {
-    mdx = await fs.readFile(path.join(ROOT, routePath + '.md'), 'utf8');
-  } catch {
-    mdx = await fs.readFile(path.join(ROOT, routePath, 'index.md'), 'utf8');
+  let mdx: string | null = null;
+  for (const candidate of [
+    path.join(ROOT, routePath + '.md'),
+    path.join(ROOT, routePath, 'index.md'),
+  ]) {
+    try {
+      mdx = await fs.readFile(candidate, 'utf8');
+      break;
+    } catch {
+      // Try next candidate.
+    }
   }
+  if (mdx == null) return null;
   const {toc, content, meta, languages} = await compileMDX(mdx, routePath, {});
   return {toc, content, meta, languages};
 }