@publish.os/nextjs 0.0.1-alpha.90 → 0.0.1-alpha.92

package/compiler-assets/nextjs/shims/metadata-icons.tsx

@@ -0,0 +1,39 @@
+import { faviconsAndLogos } from "@source/.publishos/favicons-and-logos.generated";
+import type { Metadata } from "next";
+
+type GeneratedMetadataIcons = {
+  icon?: readonly {
+    media?: string;
+    sizes?: string;
+    type?: string;
+    url: string;
+  }[];
+  apple?: readonly {
+    sizes?: string;
+    type?: string;
+    url: string;
+  }[];
+};
+
+const generated = faviconsAndLogos.metadataIcons as GeneratedMetadataIcons;
+
+export const metadataIcons = Object.keys(generated).length
+  ? ({
+      ...(generated.icon ? { icon: [...generated.icon] } : {}),
+      ...(generated.apple ? { apple: [...generated.apple] } : {}),
+    } satisfies Metadata["icons"])
+  : undefined;
+
+/** Global errors bypass Next's layout metadata but use the same resolved icons. */
+export function MetadataIcons() {
+  return (
+    <>
+      {metadataIcons?.icon?.map(({ url, ...attributes }) => (
+        <link href={url} key={url} rel="icon" {...attributes} />
+      ))}
+      {metadataIcons?.apple?.map(({ url, ...attributes }) => (
+        <link href={url} key={url} rel="apple-touch-icon" {...attributes} />
+      ))}
+    </>
+  );
+}

package/compiler-assets/nextjs/shims/not-found-content.tsx

@@ -0,0 +1,53 @@
+import { Link } from "@components/ui/link";
+import type { NotFoundScope } from "@publish.os/nextjs/kernel/routes/not-found";
+
+export default function NotFoundContent({ scope }: { scope: NotFoundScope }) {
+  const sections = [
+    { title: "Recommendations", links: scope.recommendations },
+    { title: "For crawlers and agents", links: scope.indexes },
+  ];
+  return (
+    <section
+      className="mx-auto flex w-full max-w-xl flex-1 flex-col items-center justify-center px-6 py-16 font-main sm:px-8 sm:py-24"
+      data-publishos-not-found={scope.id}
+    >
+      <h1 className="text-center font-mono text-8xl leading-none font-medium tracking-tight text-foreground-1 sm:text-9xl">
+        404<span className="sr-only"> — Page not found</span>
+      </h1>
+      <p className="mt-6 max-w-md text-center text-sm leading-6 text-pretty text-foreground-3">
+        This page does not exist. Please check the URL and try again.
+      </p>
+      <div className="mt-10 w-full space-y-8">
+        {sections.map(({ title, links }) =>
+          links.length ? (
+            <section aria-label={title} key={title}>
+              <h2 className="text-xs font-medium text-foreground-3">{title}</h2>
+              <ul className="mt-2 space-y-0">
+                {links.map((link) => (
+                  <li className="flex items-baseline gap-3" key={link.href}>
+                    <span
+                      aria-hidden="true"
+                      className="shrink-0 text-sm text-foreground-3"
+                    >
+                      -
+                    </span>
+                    <Link
+                      className="inline-flex min-h-10 min-w-0 max-w-full items-center py-1 text-start wrap-anywhere"
+                      href={link.href}
+                      prefetch={false}
+                      size="sm"
+                      target="_self"
+                      variant="link.inline"
+                    >
+                      {link.title}
+                    </Link>
+                  </li>
+                ))}
+              </ul>
+            </section>
+          ) : null,
+        )}
+      </div>
+    </section>
+  );
+}

package/compiler-assets/nextjs/shims/not-found-navigation.tsx

@@ -0,0 +1,60 @@
+"use client";
+
+import type { MouseEvent, ReactNode } from "react";
+
+/** Next's routing-level error document has no app-router tree to navigate from. */
+export default function NotFoundNavigation({
+  children,
+}: {
+  children: ReactNode;
+}) {
+  function navigate(event: MouseEvent<HTMLDivElement>) {
+    if (
+      event.defaultPrevented ||
+      event.button !== 0 ||
+      event.altKey ||
+      event.ctrlKey ||
+      event.metaKey ||
+      event.shiftKey
+    )
+      return;
+
+    const target = event.target as Node;
+    const element =
+      target.nodeType === 1 ? (target as Element) : target.parentElement;
+    const link = element?.closest<HTMLAnchorElement>("a[href]");
+    const view = event.currentTarget.ownerDocument.defaultView;
+    if (
+      !link ||
+      !view ||
+      link.hasAttribute("download") ||
+      (link.target && link.target !== "_self")
+    )
+      return;
+
+    let destination: URL;
+    try {
+      destination = new URL(link.href, view.location.href);
+    } catch {
+      return;
+    }
+    if (
+      !["http:", "https:"].includes(destination.protocol) ||
+      destination.origin !== view.location.origin ||
+      (destination.pathname === view.location.pathname &&
+        destination.search === view.location.search &&
+        destination.hash)
+    )
+      return;
+
+    event.preventDefault();
+    event.stopPropagation();
+    view.location.assign(destination.href);
+  }
+
+  return (
+    <div className="contents" onClickCapture={navigate}>
+      {children}
+    </div>
+  );
+}

package/compiler-assets/nextjs/shims/proxy.ts

@@ -1,14 +1,19 @@
+import { isMarkdownClient } from "@app/agent-user-agents";
+import {
+  createNotFoundTextResponse,
+  resolveNotFoundScope,
+} from "@publish.os/nextjs/kernel/routes/not-found";
 import { agentRouteConfig } from "@source/.publishos/agent-route-config.generated";
 import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
 
-const AGENT_USER_AGENT_PATTERN =
-  /\b(?:axios|got|node-fetch|undici|curl|wget|python-requests|httpx|aiohttp|claude-code|claudebot|claude|cursor|chatgpt|openai|perplexity|anthropic-ai)\b/i;
 const INTERNAL_MARKDOWN_PREFIX = "/__publishos/md";
 const FRAMEWORK_PREFIX = "__PUBLISHOS_FRAMEWORK_PREFIX__";
-const PUBLIC_FILE_PATTERN = /\.[a-z0-9]{1,12}$/i;
 const TEXT_METHODS = new Set(["GET", "HEAD"]);
 const PUBLIC_PATHS = new Set<string>(agentRouteConfig.publicPaths);
+const MARKDOWN_PATHS = new Set<string>(agentRouteConfig.markdownPaths);
+const OUTPUT_PATHS = new Set<string>(agentRouteConfig.outputPaths);
+const NOT_FOUND_SCOPE_HEADER = "x-publishos-not-found-scope";
 
 function debugAgentRoute(
   event: string,
@@ -30,11 +35,15 @@ function normalizePagePath(pathname: string): string {
   return pathname.replace(/\/+$/, "");
 }
 
-function markdownRoutePath(pathname: string): string {
+function markdownRoutePath(
+  pathname: string,
+  reason: "accept" | "extension",
+): string {
   const normalized = normalizePagePath(pathname);
-  const pagePath = normalized.endsWith(".md")
-    ? normalized.slice(0, -".md".length)
-    : normalized;
+  const pagePath =
+    reason === "extension" && normalized.endsWith(".md")
+      ? normalized.slice(0, -".md".length)
+      : normalized;
   return pagePath === "/"
     ? INTERNAL_MARKDOWN_PREFIX
     : `${INTERNAL_MARKDOWN_PREFIX}${pagePath}`;
@@ -45,36 +54,21 @@ function markdownAlternatePath(pathname: string): string {
   if (normalized === "/") {
     return agentRouteConfig.discoveryLinks.sitemap ?? "/sitemap.md";
   }
-  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+  return `${normalized}.md`;
 }
 
-function markdownNotFoundBody(): string {
-  const links = [
-    agentRouteConfig.discoveryLinks.home
-      ? `> Home: ${agentRouteConfig.discoveryLinks.home}`
-      : undefined,
-    agentRouteConfig.discoveryLinks.sitemap
-      ? `> Sitemap: ${agentRouteConfig.discoveryLinks.sitemap}`
-      : undefined,
-    agentRouteConfig.discoveryLinks.llms
-      ? `> LLMS index: ${agentRouteConfig.discoveryLinks.llms}`
-      : undefined,
-  ].filter((line): line is string => Boolean(line));
-
-  return [
-    "# Not found",
-    "",
-    ...links,
-    "",
-    "The requested Markdown page was not found.",
-    "",
-  ].join("\n");
+function rootMarkdownSitemapPath(requestUrl: URL): string {
+  return new URL(
+    agentRouteConfig.discoveryLinks.sitemap ?? "/sitemap.md",
+    requestUrl,
+  ).pathname;
 }
 
 function explicitAcceptQuality(accept: string, mimeType: string): number {
-  if (!accept) return 0;
+  if (!accept.trim()) return 1;
 
   const [targetType, targetSubtype] = mimeType.toLowerCase().split("/");
+  let bestSpecificity = -1;
   let bestQuality = 0;
 
   for (const entry of accept.split(",")) {
@@ -86,63 +80,131 @@ function explicitAcceptQuality(accept: string, mimeType: string): number {
     if (!rawType) continue;
 
     const [type, subtype] = rawType.split("/");
-    if (type !== targetType || subtype !== targetSubtype) continue;
+    const specificity =
+      type === targetType && subtype === targetSubtype
+        ? 2
+        : type === targetType && subtype === "*"
+          ? 1
+          : type === "*" && subtype === "*"
+            ? 0
+            : -1;
+    if (specificity < 0) continue;
 
     let quality = 1;
     for (const param of rawParams) {
       const [key, value] = param.split("=").map((part) => part.trim());
       if (key !== "q") continue;
-      const parsed = Number.parseFloat(value);
-      quality = Number.isFinite(parsed) ? parsed : 0;
+      const parsed = Number(value);
+      quality =
+        Number.isFinite(parsed) && parsed >= 0 && parsed <= 1 ? parsed : 0;
     }
 
-    if (quality > bestQuality) bestQuality = quality;
+    if (specificity > bestSpecificity) {
+      bestSpecificity = specificity;
+      bestQuality = quality;
+    } else if (specificity === bestSpecificity) {
+      bestQuality = Math.max(bestQuality, quality);
+    }
   }
 
   return bestQuality;
 }
 
-function wantsMarkdown(request: NextRequest): boolean {
+function negotiatedTextType(
+  request: NextRequest,
+): "text/markdown; charset=utf-8" | "text/html; charset=utf-8" | undefined {
+  const accept = request.headers.get("accept") ?? "";
+  const markdownQuality = agentRouteConfig.markdownAccept
+    ? explicitAcceptQuality(accept, "text/markdown")
+    : 0;
+  const htmlQuality = explicitAcceptQuality(accept, "text/html");
+
+  if (markdownQuality === 0 && htmlQuality === 0) return undefined;
+  if (markdownQuality > htmlQuality) return "text/markdown; charset=utf-8";
+  if (markdownQuality < htmlQuality) return "text/html; charset=utf-8";
+  if (looksLikeAgent(request)) return "text/markdown; charset=utf-8";
+  return htmlQuality > 0 && markdownQuality > 0
+    ? "text/html; charset=utf-8"
+    : undefined;
+}
+
+function negotiatedPlainNotFound(request: NextRequest): boolean {
   if (!TEXT_METHODS.has(request.method)) return false;
 
   const accept = request.headers.get("accept") ?? "";
+  const plainQuality = explicitAcceptQuality(accept, "text/plain");
   const markdownQuality = agentRouteConfig.markdownAccept
     ? explicitAcceptQuality(accept, "text/markdown")
     : 0;
-  const plainQuality = agentRouteConfig.plainTextAccept
-    ? explicitAcceptQuality(accept, "text/plain")
-    : 0;
   const htmlQuality = explicitAcceptQuality(accept, "text/html");
 
-  if (markdownQuality > 0 && markdownQuality >= htmlQuality) return true;
-  if (plainQuality > 0 && htmlQuality === 0 && markdownQuality === 0) {
-    return true;
-  }
+  return plainQuality > Math.max(markdownQuality, htmlQuality);
+}
 
-  return false;
+function removeDisabledDiscoveryHeaders(response: Response): Response {
+  if (!agentRouteConfig.enabled || !agentRouteConfig.discoveryHeaders) {
+    for (const name of ["link", "x-publishos-llms", "x-publishos-sitemap"])
+      response.headers.delete(name);
+  }
+  return response;
 }
 
 function looksLikeAgent(request: NextRequest): boolean {
   if (!TEXT_METHODS.has(request.method)) return false;
   if (!agentRouteConfig.agentDetection) return false;
-  if (explicitAcceptQuality(request.headers.get("accept") ?? "", "text/html")) {
-    return false;
+  return isMarkdownClient(request.headers.get("user-agent") ?? "");
+}
+
+function mergeVary(response: Response, values: string[]): void {
+  const existing = (response.headers.get("vary") ?? "")
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean);
+  if (existing.some((value) => value === "*")) return;
+  const merged = [...existing];
+  for (const value of values) {
+    if (!merged.some((item) => item.toLowerCase() === value.toLowerCase()))
+      merged.push(value);
   }
-  return AGENT_USER_AGENT_PATTERN.test(request.headers.get("user-agent") ?? "");
+  if (merged.length) response.headers.set("vary", merged.join(", "));
+}
+
+function negotiationVary(): string[] {
+  if (!agentRouteConfig.enabled || !agentRouteConfig.markdownAccept) return [];
+  return ["Accept", ...(agentRouteConfig.agentDetection ? ["User-Agent"] : [])];
+}
+
+function isNextNavigationRequest(request: NextRequest): boolean {
+  return [
+    "rsc",
+    "next-router-prefetch",
+    "next-router-state-tree",
+    "next-router-segment-prefetch",
+  ].some((name) => request.headers.has(name));
 }
 
 function markdownRequestReason(
   request: NextRequest,
-): "accept" | "agent" | "extension" | undefined {
+): "accept" | "extension" | undefined {
   if (!agentRouteConfig.enabled) return undefined;
+  if (!TEXT_METHODS.has(request.method) || isNextNavigationRequest(request))
+    return undefined;
   if (
     agentRouteConfig.markdownRoutes &&
     request.nextUrl.pathname.endsWith(".md")
   ) {
-    return "extension";
+    let decoded: string;
+    try {
+      decoded = normalizePagePath(
+        decodeURIComponent(request.nextUrl.pathname),
+      ).normalize("NFC");
+    } catch {
+      decoded = request.nextUrl.pathname;
+    }
+    if (!PUBLIC_PATHS.has(decoded)) return "extension";
   }
-  if (wantsMarkdown(request)) return "accept";
-  if (looksLikeAgent(request)) return "agent";
+  const selectedType = negotiatedTextType(request);
+  if (selectedType === "text/markdown; charset=utf-8") return "accept";
   return undefined;
 }
 
@@ -154,6 +216,7 @@ function isInternalMarkdownRoute(pathname: string): boolean {
 }
 
 function isStaticOrMetadataRoute(pathname: string): boolean {
+  if (OUTPUT_PATHS.has(normalizePagePath(pathname))) return true;
   if (
     pathname === FRAMEWORK_PREFIX ||
     pathname.startsWith(`${FRAMEWORK_PREFIX}/`) ||
@@ -175,21 +238,29 @@ function isStaticOrMetadataRoute(pathname: string): boolean {
     return true;
   }
 
-  return PUBLIC_FILE_PATTERN.test(pathname) && !pathname.endsWith(".md");
+  return false;
 }
 
-function rewriteToMarkdown(
-  request: NextRequest,
-  reason: "accept" | "agent" | "extension",
-): NextResponse {
-  const url = request.nextUrl.clone();
+function rewriteToMarkdown({
+  request,
+  reason,
+  requestHeaders,
+}: {
+  request: NextRequest;
+  reason: "accept" | "extension";
+  requestHeaders: Headers;
+}): NextResponse {
+  const url = new URL(request.url);
   url.pathname =
     normalizePagePath(url.pathname) === "/"
-      ? "/sitemap.md"
-      : markdownRoutePath(url.pathname);
+      ? rootMarkdownSitemapPath(url)
+      : markdownRoutePath(url.pathname, reason);
+  const revision = request.nextUrl.searchParams.get("publishos_revision");
+  url.search = "";
+  url.hash = "";
+  if (revision) url.searchParams.set("publishos_revision", revision);
 
-  const requestHeaders = new Headers(request.headers);
-  requestHeaders.set("x-publishos-agent-route", "markdown");
+  requestHeaders.set("accept", "text/markdown");
 
   debugAgentRoute("md", {
     accept: request.headers.get("accept") ?? undefined,
@@ -200,20 +271,25 @@ function rewriteToMarkdown(
     userAgent: request.headers.get("user-agent") ?? undefined,
   });
 
-  return NextResponse.rewrite(url, {
+  const response = NextResponse.rewrite(url, {
     request: {
       headers: requestHeaders,
     },
   });
+  if (reason !== "extension") mergeVary(response, negotiationVary());
+  return response;
 }
 
 function withDiscoveryHeaders(
   response: NextResponse,
   pathname: string,
 ): NextResponse {
+  mergeVary(response, negotiationVary());
   const markdownUrl = markdownAlternatePath(pathname);
   const links = [
-    `<${markdownUrl}>; rel="alternate"; type="text/markdown"`,
+    agentRouteConfig.markdownRoutes
+      ? `<${markdownUrl}>; rel="alternate"; type="text/markdown"`
+      : undefined,
     agentRouteConfig.discoveryLinks.llms
       ? `<${agentRouteConfig.discoveryLinks.llms}>; rel="llms-txt"; type="text/plain"`
       : undefined,
@@ -221,8 +297,9 @@ function withDiscoveryHeaders(
       ? `<${agentRouteConfig.discoveryLinks.sitemap}>; rel="alternate"; type="text/markdown"; title="Markdown sitemap"`
       : undefined,
   ].filter((link): link is string => Boolean(link));
-  response.headers.set("link", links.join(", "));
-  response.headers.set("x-publishos-markdown", markdownUrl);
+  if (links.length) response.headers.set("link", links.join(", "));
+  if (agentRouteConfig.markdownRoutes)
+    response.headers.set("x-publishos-markdown", markdownUrl);
   if (agentRouteConfig.discoveryLinks.llms) {
     response.headers.set(
       "x-publishos-llms",
@@ -241,20 +318,28 @@ function withDiscoveryHeaders(
 
 export function proxy(request: NextRequest) {
   const { pathname } = request.nextUrl;
+  const requestHeaders = new Headers(request.headers);
+  requestHeaders.delete(NOT_FOUND_SCOPE_HEADER);
+  requestHeaders.delete("x-publishos-agent-route");
 
-  if (pathname === "/_not-found") return NextResponse.next();
+  if (pathname === "/_not-found") {
+    requestHeaders.set(NOT_FOUND_SCOPE_HEADER, "none");
+    const response = NextResponse.next({
+      request: { headers: requestHeaders },
+    });
+    response.headers.set("x-robots-tag", "noindex");
+    response.headers.set("vary", "Accept, User-Agent");
+    return response;
+  }
 
   if (isInternalMarkdownRoute(pathname)) {
-    if (request.headers.get("x-publishos-agent-route") === "markdown") {
-      return NextResponse.next();
-    }
     if (!agentRouteConfig.blockInternalMarkdownRoute) {
       debugAgentRoute("pass", {
         method: request.method,
         path: pathname,
         reason: "allowed-internal",
       });
-      return NextResponse.next();
+      return NextResponse.next({ request: { headers: requestHeaders } });
     }
 
     debugAgentRoute("md", {
@@ -264,15 +349,7 @@ export function proxy(request: NextRequest) {
       status: 404,
     });
 
-    return new Response(markdownNotFoundBody(), {
-      status: 404,
-      headers: {
-        "cache-control": "public, max-age=60, s-maxage=300",
-        "content-type": "text/markdown; charset=utf-8",
-        "x-content-type-options": "nosniff",
-        "x-robots-tag": "noindex",
-      },
-    });
+    return createNotFoundTextResponse({ method: request.method });
   }
 
   if (isStaticOrMetadataRoute(pathname)) {
@@ -281,25 +358,109 @@ export function proxy(request: NextRequest) {
       path: pathname,
       reason: "static-or-metadata",
     });
-    return NextResponse.next();
+    return NextResponse.next({ request: { headers: requestHeaders } });
   }
 
   const markdownReason = markdownRequestReason(request);
   if (markdownReason) {
-    return rewriteToMarkdown(request, markdownReason);
+    let htmlPath: string | undefined;
+    try {
+      const decoded = normalizePagePath(decodeURIComponent(pathname)).normalize(
+        "NFC",
+      );
+      htmlPath =
+        markdownReason === "extension" && decoded.endsWith(".md")
+          ? decoded.slice(0, -3) || "/"
+          : decoded;
+    } catch {
+      htmlPath = undefined;
+    }
+    const scope = resolveNotFoundScope({
+      scopes: agentRouteConfig.notFoundScopes,
+      pathname,
+    });
+    const hasArtifact =
+      htmlPath === "/"
+        ? OUTPUT_PATHS.has(rootMarkdownSitemapPath(new URL(request.url)))
+        : htmlPath !== undefined && MARKDOWN_PATHS.has(htmlPath);
+    if (!scope || !hasArtifact) {
+      const response = createNotFoundTextResponse({
+        scope,
+        pathname,
+        method: request.method,
+        contentType:
+          markdownReason === "accept" ? negotiatedTextType(request) : undefined,
+        vary: markdownReason !== "extension",
+      });
+      return removeDisabledDiscoveryHeaders(response);
+    }
+    return rewriteToMarkdown({
+      request,
+      reason: markdownReason,
+      requestHeaders,
+    });
   }
 
   let pagePath: string;
   try {
-    pagePath = normalizePagePath(decodeURIComponent(pathname));
+    pagePath = normalizePagePath(decodeURIComponent(pathname)).normalize("NFC");
   } catch {
     pagePath = pathname;
   }
   if (!PUBLIC_PATHS.has(pagePath)) {
-    // Use Next's static 404 before an unknown catch-all reaches error recovery.
-    const url = request.nextUrl.clone();
+    // Select Next's error route before an unknown catch-all can stream.
+    const scope = resolveNotFoundScope({
+      scopes: agentRouteConfig.notFoundScopes,
+      pathname,
+    });
+    if (negotiatedPlainNotFound(request)) {
+      return removeDisabledDiscoveryHeaders(
+        createNotFoundTextResponse({
+          scope,
+          pathname,
+          method: request.method,
+          contentType: "text/plain; charset=utf-8",
+          vary: true,
+        }),
+      );
+    }
+    requestHeaders.set(NOT_FOUND_SCOPE_HEADER, scope?.id ?? "none");
+    const url = new URL(request.url);
     url.pathname = "/_not-found";
-    return NextResponse.rewrite(url, { status: 404 });
+    url.search = "";
+    url.hash = "";
+    const response = NextResponse.rewrite(url, {
+      status: 404,
+      request: { headers: requestHeaders },
+    });
+    const recoveryHeaders = createNotFoundTextResponse({
+      scope,
+      pathname,
+      method: request.method,
+      vary: true,
+    }).headers;
+    for (const name of [
+      "x-robots-tag",
+      "vary",
+      ...(agentRouteConfig.enabled && agentRouteConfig.discoveryHeaders
+        ? ["link", "x-publishos-llms", "x-publishos-sitemap"]
+        : []),
+    ]) {
+      const value = recoveryHeaders.get(name);
+      if (value) response.headers.set(name, value);
+    }
+    return response;
+  }
+
+  if (
+    agentRouteConfig.enabled &&
+    TEXT_METHODS.has(request.method) &&
+    !isNextNavigationRequest(request) &&
+    !negotiatedTextType(request)
+  ) {
+    const response = new NextResponse(null, { status: 406 });
+    mergeVary(response, negotiationVary());
+    return response;
   }
 
   if (!agentRouteConfig.enabled || !agentRouteConfig.discoveryHeaders) {
@@ -310,7 +471,11 @@ export function proxy(request: NextRequest) {
         ? "discovery-disabled"
         : "agent-routes-disabled",
     });
-    return NextResponse.next();
+    const response = NextResponse.next({
+      request: { headers: requestHeaders },
+    });
+    mergeVary(response, negotiationVary());
+    return response;
   }
 
   debugAgentRoute("html", {
@@ -321,7 +486,10 @@ export function proxy(request: NextRequest) {
     userAgent: request.headers.get("user-agent") ?? undefined,
   });
 
-  return withDiscoveryHeaders(NextResponse.next(), pathname);
+  return withDiscoveryHeaders(
+    NextResponse.next({ request: { headers: requestHeaders } }),
+    pathname,
+  );
 }
 
 export const config = {

package/compiler-assets/nextjs/shims/site-fenced-code-block.tsx

@@ -1,9 +1,5 @@
 import { CodeBlock } from "@components/mdx/code-block";
-import {
-  type ComponentPropsWithoutRef,
-  isValidElement,
-  type ReactNode,
-} from "react";
+import { type HTMLAttributes, isValidElement, type ReactNode } from "react";
 
 type CodeChildProps = {
   children?: ReactNode;
@@ -15,7 +11,7 @@ export function FencedCodeBlock({
   children,
   title,
   ...props
-}: ComponentPropsWithoutRef<"pre">) {
+}: HTMLAttributes<HTMLElement>) {
   const codeElement = isValidElement<CodeChildProps>(children)
     ? children
     : null;