ADDED - Admin SEO page, robots/sitemap hardening and media/maintenance security fixes

SEO - New Settings > SEO admin page (seo_settings in app_config): indexing switch, Google/Bing verification, X handle, JSON-LD identity (Person/Organization, sameAs), per-locale keywords, readiness checklist and open links for sitemap.xml / robots.txt / manifest. - robots.txt is now dynamic: disallows admin, api, success and coming-soon paths; blocks everything while indexing is off or maintenance is on. - sitemap.xml carries hreflang alternates per URL, lists only categories with published projects, and is empty while hidden. - Metadata: robots + verification meta, og:locale in de_DE/en_US/ar_AR form, alternateLocale, twitter site/creator, project cover as OG image with article type, noindex on /success and /coming-soon. - JSON-LD: WebSite + publisher graph on all public pages, CreativeWork per project (view-mode independent). Security - Maintenance bypass now requires a correctly signed admin cookie; the middleware previously only checked the cookie existed. Token helpers moved to lib/admin-session-token.ts (shared by proxy.ts and lib/admin-auth.ts). - Media uploads: magic-byte validation against the declared type, SVG sanitization (script/handlers/foreignObject/javascript: rejected), upload folder sanitized, kind inferred from the real file. - Media route: fixed prefix-based path check that accepted sibling directories, unknown extensions return 404, nosniff header, CSP sandbox on SVG, gif content type added. - External media URLs: protocol-relative (//host) URLs rejected. Portfolio - Project and category slugs share /portfolio/[slug]; saving now rejects a slug already used on the other side instead of silently shadowing it. Tooling/docs - Lint: ignore scripts/legacy-prisma-seed.cjs, drop unused import. - New docs/SEO.md; FEATURES, ARCHITECTURE (Drizzle instead of Prisma), admin spec and CLAUDE.md updated. - Tests for all of the above (unit + integration); suite green.
2026-09-20 21:36:16 +02:00
parent 0b513551ca
commit dc21c33867
47 changed files with 1854 additions and 131 deletions
@@ -8,9 +8,11 @@ import { PageTransition } from "@/components/layout/page-transition";
 import { SiteDock } from "@/components/layout/site-dock";
 import { SiteFooter } from "@/components/layout/site-footer";
 import { ScrollSmootherProvider } from "@/components/scroll-smoother-provider";
+import { JsonLd } from "@/components/seo/json-ld";
 import { isSuperAdmin } from "@/lib/admin-auth";
-import { getMaintenanceMode, getSiteSettings } from "@/lib/app-config";
+import { getMaintenanceMode, getSeoSettings, getSiteSettings, getSiteSettingsMediaBindings } from "@/lib/app-config";
 import { getLocalizedPath, resolveLocale } from "@/lib/locale";
+import { buildSiteJsonLd } from "@/lib/metadata";

 type SiteLayoutProps = {
  children: ReactNode;
@@ -25,9 +27,11 @@ export const revalidate = 0;
 export default async function SiteLayout({ children, params }: SiteLayoutProps) {
  noStore();
  await params;
-  const [maintenanceEnabled, siteSettings] = await Promise.all([
+  const [maintenanceEnabled, siteSettings, seo, mediaBindings] = await Promise.all([
    getMaintenanceMode(),
    getSiteSettings(),
+    getSeoSettings(),
+    getSiteSettingsMediaBindings(),
  ]);
  const localeKey = resolveLocale(await getLocale().catch(() => siteSettings.defaultLocale), siteSettings.defaultLocale);
  // Server-side decision only. The dock receives just this boolean and uses
@@ -42,6 +46,7 @@ export default async function SiteLayout({ children, params }: SiteLayoutProps)

  return (
    <>
+      <JsonLd data={buildSiteJsonLd({ settings: siteSettings, seo, bindings: mediaBindings, locale: localeKey })} />
      <ScrollSmootherProvider />
      <SiteAmbientBackdrop />
      <SiteDock defaultLocale={siteSettings.defaultLocale} isSuperAdmin={authenticated} />
@@ -7,8 +7,9 @@ import { PageHero } from "@/components/layout/page-hero";
 import { PortfolioCategoryFilter } from "@/components/site/portfolio-category-filter";
 import { PortfolioProjectDetail } from "@/components/site/portfolio-project-detail";
 import { PortfolioProjectGrid } from "@/components/site/portfolio-project-grid";
-import { getSiteSettings } from "@/lib/app-config";
-import { buildLocalizedMetadata } from "@/lib/metadata";
+import { JsonLd } from "@/components/seo/json-ld";
+import { getSeoSettings, getSiteSettings } from "@/lib/app-config";
+import { buildLocalizedMetadata, buildProjectJsonLd } from "@/lib/metadata";
 import { resolveLocale } from "@/lib/locale";
 import {
  getActivePortfolioCategories,
@@ -57,6 +58,9 @@ export async function generateMetadata({ params }: PortfolioSlugPageProps): Prom
    pathname: `/portfolio/${slug}`,
    title: getLocalizedValue(resolved.project.title, localeKey),
    description: getLocalizedValue(resolved.project.summary, localeKey),
+    image: resolved.project.coverImagePath,
+    type: "article",
+    publishedTime: resolved.project.publishedAt,
  });
 }

@@ -108,13 +112,30 @@ export default async function PortfolioSlugPage({ params }: PortfolioSlugPagePro
  }

  const { project: item } = resolved;
-  const t = await getTranslations({ locale: localeKey, namespace: "portfolioDetail" });
+  const [t, seo] = await Promise.all([
+    getTranslations({ locale: localeKey, namespace: "portfolioDetail" }),
+    getSeoSettings(),
+  ]);
  const title = getLocalizedValue(item.title, localeKey);
  const category = getLocalizedValue(item.category.name, localeKey);
  const summary = getLocalizedValue(item.summary, localeKey);
+  const jsonLd = buildProjectJsonLd({
+    settings: siteSettings,
+    seo,
+    locale: localeKey,
+    pathname: `/portfolio/${slug}`,
+    title,
+    description: summary,
+    image: item.coverImagePath,
+    datePublished: item.publishedAt,
+    genre: category,
+    keywords: [getLocalizedValue(item.serviceLabel, localeKey), String(item.projectYear)].filter(Boolean),
+    clientName: item.clientName,
+  });

  return (
    <>
+      <JsonLd data={jsonLd} />
      <PageHero
        locale={localeKey}
        badge={category}
@@ -30,6 +30,7 @@ export async function generateMetadata({ params }: SuccessPageProps): Promise<Me
    pathname: "/success",
    title: t("title"),
    description: t("text"),
+    noIndex: true,
  });
 }

@@ -34,6 +34,7 @@ export async function generateMetadata({ params }: ComingSoonPageProps): Promise
    title: siteSettings.locales[localeKey].siteName,
    description: t("description"),
    applyTitleTemplate: false,
+    noIndex: true,
  });
 }

@@ -1,6 +1,6 @@
 "use server";

-import { and, eq, inArray } from "drizzle-orm";
+import { eq, inArray } from "drizzle-orm";
 import { revalidatePath } from "next/cache";
 import { redirect } from "next/navigation";
 import { isRedirectError } from "next/dist/client/components/redirect-error";
@@ -154,6 +154,19 @@ export async function upsertCategoryAction(formData: FormData) {
      isActive: normalizeCheckboxValue(formData, "isActive"),
    });

+    // Categories and projects share the public `/portfolio/[slug]` route, so a
+    // slug may only exist on one side. Categories win at resolve time, which
+    // would silently hide a project with the same slug.
+    const [projectWithSlug] = await db
+      .select({ id: portfolioProject.id })
+      .from(portfolioProject)
+      .where(eq(portfolioProject.slug, parsed.slug))
+      .limit(1);
+
+    if (projectWithSlug) {
+      throw new Error("Kategorie Slug ist bereits als Projekt Slug vergeben.");
+    }
+
    if (parsed.id) {
      await db.update(category).set(parsed).where(eq(category.id, parsed.id));
    } else {
@@ -172,7 +185,9 @@ export async function upsertCategoryAction(formData: FormData) {
        ? parseZodError(error)
        : isUniqueViolation(error)
          ? "Kategorie Slug muss eindeutig sein."
-          : "Kategorie konnte nicht gespeichert werden.";
+          : error instanceof Error && error.message.includes("Slug")
+            ? error.message
+            : "Kategorie konnte nicht gespeichert werden.";

    redirect(withFlash(redirectPath, { error: message }));
  }
@@ -298,6 +313,16 @@ export async function saveProjectAction(formData: FormData) {
      assets,
    });

+    const [categoryWithSlug] = await db
+      .select({ id: category.id })
+      .from(category)
+      .where(eq(category.slug, parsed.slug))
+      .limit(1);
+
+    if (categoryWithSlug) {
+      throw new Error("Projekt Slug ist bereits als Kategorie Slug vergeben.");
+    }
+
    const existingProject = parsed.id
      ? (
          await db
@@ -12,7 +12,9 @@ import {
  SITE_SETTINGS_FAVICON_FIELD_KEY,
  SITE_SETTINGS_LOGO_DARK_FIELD_KEY,
  SITE_SETTINGS_LOGO_LIGHT_FIELD_KEY,
+  getSeoSettings,
  getSiteSettings,
+  updateSeoSettings,
  updateSiteSettings,
 } from "@/lib/app-config";
 import { getAdminAppPath, toInternalAdminPath } from "@/lib/admin-routing";
@@ -24,6 +26,15 @@ import {
  type SiteSettings,
 } from "@/lib/site-settings";
 import { clearAdminSessionCookie, isAdminAuthenticated } from "@/lib/admin-auth";
+import {
+  normalizeKeywords,
+  normalizeSameAs,
+  normalizeStructuredDataType,
+  normalizeTwitterHandle,
+  normalizeVerificationToken,
+  type SeoSettings,
+} from "@/lib/seo-settings";
+import { isCheckedFormValue } from "@/lib/form-data";
 import { replaceEntityMediaUsages } from "@/lib/media";
 import { resolveMediaSelection } from "@/lib/media-service";
 import { routing } from "@/i18n/routing";
@@ -329,3 +340,63 @@ export async function saveSiteLocalizationSettingsAction(formData: FormData) {
    redirect(withFlash(getAdminAppPath("/site-settings/localization"), { error: message }));
  }
 }
+
+export async function saveSeoSettingsAction(formData: FormData) {
+  await ensureAdmin();
+
+  try {
+    const currentSettings = await getSeoSettings();
+    const googleRaw = String(formData.get("googleSiteVerification") ?? "").trim();
+    const bingRaw = String(formData.get("bingSiteVerification") ?? "").trim();
+    const twitterRaw = String(formData.get("twitterHandle") ?? "").trim();
+    const googleSiteVerification = normalizeVerificationToken(googleRaw);
+    const bingSiteVerification = normalizeVerificationToken(bingRaw);
+    const twitterHandle = normalizeTwitterHandle(twitterRaw);
+
+    if (googleRaw && !googleSiteVerification) {
+      throw new Error("Google Verification Code darf nur Buchstaben, Zahlen, - und _ enthalten.");
+    }
+
+    if (bingRaw && !bingSiteVerification) {
+      throw new Error("Bing Verification Code darf nur Buchstaben, Zahlen, - und _ enthalten.");
+    }
+
+    if (twitterRaw && !twitterHandle) {
+      throw new Error("X/Twitter Handle ist ungueltig (max. 15 Zeichen, Buchstaben/Zahlen/_).");
+    }
+
+    const parsedSettings: SeoSettings = {
+      ...currentSettings,
+      allowIndexing: isCheckedFormValue(formData.get("allowIndexing")),
+      googleSiteVerification,
+      bingSiteVerification,
+      twitterHandle,
+      structuredDataType: normalizeStructuredDataType(formData.get("structuredDataType")),
+      structuredDataName: String(formData.get("structuredDataName") ?? "").trim().slice(0, 120),
+      structuredDataJobTitle: String(formData.get("structuredDataJobTitle") ?? "").trim().slice(0, 160),
+      sameAs: normalizeSameAs(formData.get("sameAs")),
+      locales: {
+        ar: { keywords: normalizeKeywords(formData.get("keywordsAr")) },
+        en: { keywords: normalizeKeywords(formData.get("keywordsEn")) },
+        de: { keywords: normalizeKeywords(formData.get("keywordsDe")) },
+      },
+    };
+
+    await updateSeoSettings(parsedSettings);
+    const siteSettings = await getSiteSettings();
+    await revalidateSiteSettingsPages(siteSettings.defaultLocale);
+    revalidatePath("/sitemap.xml");
+    revalidatePath("/robots.txt");
+    revalidatePath(toInternalAdminPath("/site-settings/seo"));
+    redirect(withFlash(getAdminAppPath("/site-settings/seo"), { success: "SEO Einstellungen gespeichert." }));
+  } catch (error) {
+    if (isRedirectError(error)) {
+      throw error;
+    }
+
+    const message =
+      error instanceof Error ? error.message : "SEO Einstellungen konnten nicht gespeichert werden.";
+
+    redirect(withFlash(getAdminAppPath("/site-settings/seo"), { error: message }));
+  }
+}
@@ -0,0 +1,104 @@
+import { redirect } from "next/navigation";
+
+import { MotionFade } from "@/components/motion-fade";
+import { SeoSettingsForm } from "@/components/admin/seo-settings-form";
+import { AdminDashboardShell } from "@/components/admin/admin-dashboard-shell";
+import { readFlash } from "@/lib/admin-feedback";
+import { clearAdminSessionCookie, isAdminAuthenticated } from "@/lib/admin-auth";
+import { buildSiteUrl, getAdminAppPath } from "@/lib/admin-routing";
+import {
+  getMaintenanceMode,
+  getSeoSettings,
+  getSiteSettings,
+  getSiteSettingsMediaBindings,
+} from "@/lib/app-config";
+import { getSiteUrl } from "@/lib/metadata";
+import { INTERNAL_MANIFEST_PATH } from "@/lib/site-icons";
+import { getPublishedPortfolioProjects } from "@/lib/portfolio";
+import { buildSeoChecklist } from "@/lib/seo-report";
+import buildSitemap from "@/app/sitemap";
+
+import { saveSeoSettingsAction } from "../actions";
+
+export const dynamic = "force-dynamic";
+
+const copy = {
+  title: "SEO",
+  subtitle: "Indexierung, Verifizierung, strukturierte Daten, Sitemap und robots.txt.",
+  overview: "Uebersicht",
+  maintenance: "Wartungsmodus",
+  uiKit: "UI Kit",
+  media: "Media",
+  siteSettings: "Settings",
+  brandSettings: "Brand",
+  localizationSettings: "Localization",
+  seoSettings: "SEO",
+  smtp: "SMTP",
+  portfolio: "Portfolio",
+  logout: "Ausloggen",
+  backToSite: "Zur Website",
+};
+
+export default async function AdminSeoSettingsPage({
+  searchParams,
+}: {
+  searchParams?: Promise<{ success?: string; error?: string }>;
+}) {
+  const flash = readFlash(await searchParams);
+
+  if (!(await isAdminAuthenticated())) {
+    redirect(getAdminAppPath("/"));
+  }
+
+  async function logoutAction() {
+    "use server";
+
+    await clearAdminSessionCookie();
+    redirect(getAdminAppPath("/"));
+  }
+
+  const [seo, siteSettings, bindings, maintenanceEnabled, projects, sitemapEntries] = await Promise.all([
+    getSeoSettings(),
+    getSiteSettings(),
+    getSiteSettingsMediaBindings(),
+    getMaintenanceMode(),
+    getPublishedPortfolioProjects().catch(() => []),
+    buildSitemap().catch(() => []),
+  ]);
+
+  const checks = buildSeoChecklist({
+    seo,
+    settings: siteSettings,
+    bindings,
+    maintenanceEnabled,
+    publishedProjectCount: projects.length,
+    sitemapEntryCount: sitemapEntries.length,
+    siteUrl: getSiteUrl().origin,
+  });
+
+  return (
+    <AdminDashboardShell
+      copy={copy}
+      active="site-settings"
+      flash={flash}
+      siteSettingsChild="seo"
+      logoutAction={logoutAction}
+      headerTitle={copy.title}
+      headerDescription={copy.subtitle}
+    >
+      <MotionFade delay={0.16}>
+        <SeoSettingsForm
+          action={saveSeoSettingsAction}
+          settings={seo}
+          checks={checks}
+          sitemapEntryCount={sitemapEntries.length}
+          links={{
+            sitemap: buildSiteUrl("/sitemap.xml"),
+            robots: buildSiteUrl("/robots.txt"),
+            manifest: buildSiteUrl(INTERNAL_MANIFEST_PATH),
+          }}
+        />
+      </MotionFade>
+    </AdminDashboardShell>
+  );
+}
@@ -0,0 +1 @@
+export { default } from "../../../_admin/site-settings/seo/page";
@@ -1,15 +1,49 @@
 import type { MetadataRoute } from "next";
+import { unstable_noStore as noStore } from "next/cache";

-export default function robots(): MetadataRoute.Robots {
-  const siteUrl = new URL(process.env.NEXT_PUBLIC_SITE_URL ?? "https://mohfarawati.de");
+import { getMaintenanceMode, getSeoSettings } from "@/lib/app-config";
+import { INTERNAL_ADMIN_PREFIX } from "@/lib/admin-routing";
+import { getSiteUrl } from "@/lib/metadata";
+
+export const dynamic = "force-dynamic";
+
+/** Paths that must never be crawled even when indexing is enabled. */
+export const ROBOTS_DISALLOWED_PATHS = [
+  INTERNAL_ADMIN_PREFIX,
+  "/root",
+  "/api/",
+  "/success",
+  "/coming-soon",
+  "/*/success",
+  "/*/coming-soon",
+];
+
+export function buildRobots(input: { indexable: boolean }): MetadataRoute.Robots {
+  const siteUrl = getSiteUrl();
+
+  if (!input.indexable) {
+    return {
+      rules: [{ userAgent: "*", disallow: "/" }],
+      host: siteUrl.origin,
+    };
+  }

  return {
    rules: [
      {
        userAgent: "*",
-        disallow: ["/admin-internal"],
+        allow: "/",
+        disallow: ROBOTS_DISALLOWED_PATHS,
      },
    ],
    sitemap: new URL("/sitemap.xml", siteUrl).toString(),
+    host: siteUrl.origin,
  };
 }
+
+export default async function robots(): Promise<MetadataRoute.Robots> {
+  noStore();
+  const [seo, maintenanceEnabled] = await Promise.all([getSeoSettings(), getMaintenanceMode()]);
+
+  return buildRobots({ indexable: seo.allowIndexing && !maintenanceEnabled });
+}
@@ -0,0 +1 @@
+export { default } from "../../../_admin/site-settings/seo/page";
@@ -2,72 +2,111 @@ import type { MetadataRoute } from "next";
 import { unstable_noStore as noStore } from "next/cache";

 import { routing } from "@/i18n/routing";
-import { getSiteSettings } from "@/lib/app-config";
-import { getLocalizedPath } from "@/lib/locale";
-import { getPublishedPortfolioProjects } from "@/lib/portfolio";
+import { getMaintenanceMode, getSeoSettings, getSiteSettings } from "@/lib/app-config";
+import { getLocalizedPath, type AppLocale } from "@/lib/locale";
+import { toAbsoluteUrl } from "@/lib/metadata";
+import { getActivePortfolioCategories, getPublishedPortfolioProjects } from "@/lib/portfolio";

-function getSiteUrl(): URL {
-  return new URL(process.env.NEXT_PUBLIC_SITE_URL ?? "https://mohfarawati.de");
-}
+export const dynamic = "force-dynamic";

-function toAbsoluteUrl(pathname: string): string {
-  return new URL(pathname, getSiteUrl()).toString();
-}
+type EntryOptions = Pick<MetadataRoute.Sitemap[number], "changeFrequency" | "priority" | "lastModified">;

-function buildLocalizedEntries(
+/**
+ * One entry per locale for a path, each carrying hreflang alternates so search
+ * engines link the three language versions together.
+ */
+export function buildLocalizedEntries(
  pathname: string,
-  defaultLocale: "de" | "en" | "ar",
-  options?: Pick<MetadataRoute.Sitemap[number], "changeFrequency" | "priority" | "lastModified">,
+  defaultLocale: AppLocale,
+  options?: EntryOptions,
 ): MetadataRoute.Sitemap {
+  const languages = Object.fromEntries(
+    routing.locales.map((locale) => [locale, toAbsoluteUrl(getLocalizedPath(locale, pathname, defaultLocale))]),
+  ) as Record<AppLocale, string>;
+
  return routing.locales.map((locale) => ({
-    url: toAbsoluteUrl(getLocalizedPath(locale, pathname, defaultLocale)),
+    url: languages[locale],
    lastModified: options?.lastModified,
    changeFrequency: options?.changeFrequency,
    priority: options?.priority,
+    alternates: {
+      languages: {
+        ...languages,
+        "x-default": languages[defaultLocale],
+      },
+    },
  }));
 }

 export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  noStore();
-  const siteSettings = await getSiteSettings();
+  const [siteSettings, seo, maintenanceEnabled] = await Promise.all([
+    getSiteSettings(),
+    getSeoSettings(),
+    getMaintenanceMode(),
+  ]);

-  let projects: Awaited<ReturnType<typeof getPublishedPortfolioProjects>> = [];
-
-  try {
-    projects = await getPublishedPortfolioProjects();
-  } catch {
-    projects = [];
+  // While the site is hidden (maintenance) or indexing is off, publish an
+  // empty sitemap instead of advertising URLs that redirect or are noindex.
+  if (maintenanceEnabled || !seo.allowIndexing) {
+    return [];
  }

-  const categories = Array.from(
-    new Map(projects.map((project) => [project.category.slug, project.category])).values(),
+  const defaultLocale = siteSettings.defaultLocale;
+
+  let projects: Awaited<ReturnType<typeof getPublishedPortfolioProjects>> = [];
+  let categories: Awaited<ReturnType<typeof getActivePortfolioCategories>> = [];
+
+  try {
+    [projects, categories] = await Promise.all([
+      getPublishedPortfolioProjects(),
+      getActivePortfolioCategories(),
+    ]);
+  } catch {
+    projects = [];
+    categories = [];
+  }
+
+  // Only categories that actually have published work get a landing URL;
+  // an empty category page has nothing to index.
+  const categoriesWithProjects = categories.filter((category) =>
+    projects.some((project) => project.category.slug === category.slug),
  );

+  const latestProjectDate = projects.reduce<Date | undefined>((latest, project) => {
+    const date = project.publishedAt ?? undefined;
+
+    return date && (!latest || date > latest) ? date : latest;
+  }, undefined);
+
  return [
-    ...buildLocalizedEntries("/", siteSettings.defaultLocale, {
+    ...buildLocalizedEntries("/", defaultLocale, {
      changeFrequency: "weekly",
      priority: 1,
+      lastModified: latestProjectDate,
    }),
-    ...buildLocalizedEntries("/about", siteSettings.defaultLocale, {
+    ...buildLocalizedEntries("/about", defaultLocale, {
      changeFrequency: "monthly",
      priority: 0.8,
    }),
-    ...buildLocalizedEntries("/portfolio", siteSettings.defaultLocale, {
+    ...buildLocalizedEntries("/portfolio", defaultLocale, {
      changeFrequency: "weekly",
      priority: 0.9,
+      lastModified: latestProjectDate,
    }),
-    ...categories.flatMap((category) =>
-      buildLocalizedEntries(`/portfolio/${category.slug}`, siteSettings.defaultLocale, {
+    ...categoriesWithProjects.flatMap((category) =>
+      buildLocalizedEntries(`/portfolio/${category.slug}`, defaultLocale, {
        changeFrequency: "weekly",
        priority: 0.8,
+        lastModified: latestProjectDate,
      }),
    ),
-    ...buildLocalizedEntries("/contact", siteSettings.defaultLocale, {
+    ...buildLocalizedEntries("/contact", defaultLocale, {
      changeFrequency: "monthly",
      priority: 0.7,
    }),
    ...projects.flatMap((project) =>
-      buildLocalizedEntries(`/portfolio/${project.slug}`, siteSettings.defaultLocale, {
+      buildLocalizedEntries(`/portfolio/${project.slug}`, defaultLocale, {
        lastModified: project.publishedAt ?? undefined,
        changeFrequency: "monthly",
        priority: 0.8,
@@ -14,6 +14,7 @@ export const dynamic = "force-dynamic";

 const CONTENT_TYPES: Record<string, string> = {
  ".ico": "image/x-icon",
+  ".gif": "image/gif",
  ".jpg": "image/jpeg",
  ".jpeg": "image/jpeg",
  ".png": "image/png",
@@ -30,15 +31,30 @@ export async function GET(_: Request, { params }: MediaFileRouteProps) {
  try {
    const absolutePath = resolveMediaUploadPath(publicPath);
    const fileBuffer = await readFile(absolutePath);
-    const contentType = CONTENT_TYPES[path.extname(absolutePath).toLowerCase()] ?? "application/octet-stream";
+    const extension = path.extname(absolutePath).toLowerCase();
+    const contentType = CONTENT_TYPES[extension];

-    return new NextResponse(fileBuffer, {
-      status: 200,
-      headers: {
-        "Content-Type": contentType,
-        "Cache-Control": "public, max-age=31536000, immutable",
-      },
-    });
+    if (!contentType) {
+      return new NextResponse("Not Found", { status: 404 });
+    }
+
+    const headers: Record<string, string> = {
+      "Content-Type": contentType,
+      "Cache-Control": "public, max-age=31536000, immutable",
+      "X-Content-Type-Options": "nosniff",
+    };
+
+    // SVG is an active document type: sandbox it so an uploaded file can never
+    // run script or reach our origin even if it is opened directly.
+    if (extension === ".svg") {
+      headers["Content-Security-Policy"] = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
+    }
+
+    if (extension === ".pdf") {
+      headers["Content-Disposition"] = "inline";
+    }
+
+    return new NextResponse(new Uint8Array(fileBuffer), { status: 200, headers });
  } catch {
    return new NextResponse("Not Found", {
      status: 404,
				`@@ -0,0 +1 @@`
				`export { default } from "../../../_admin/site-settings/seo/page";`