// /auth/partner-signin/page.tsx

import { Suspense } from "react";
import PartnerSignIn from "./PartnerSignIn";

export default function Page() {
  return (
    <Suspense fallback={<div>Loading...</div>}>
      <PartnerSignIn />
    </Suspense>
  );
}

"use client";

import { Suspense, useEffect, useState } from "react";
import { signIn } from "next-auth/react";
import { useSearchParams, useRouter } from "next/navigation";

export default function PartnerSignIn() {
  const searchParams = useSearchParams();
  const router = useRouter();
  const [status, setStatus] = useState<"loading" | "signing-in" | "error">(
    "loading",
  );

  const token = searchParams.get("token");
  const email = searchParams.get("email");

  useEffect(() => {
    if (!token || !email) {
      queueMicrotask(() => {
        setStatus("error");
      });
      router.push("/login?error=invalid-partner-link");
      return;
    }

    fetch("/api/auth/verify-partner-token", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ token, email }),
    })
      .then((response) => response.json())
      .then(async (data) => {
        if (data.valid) {
          queueMicrotask(() => {
            setStatus("signing-in");
          });
          // Sign in using email provider with pre-verified email
          const result = await signIn("email", {
            email: email,
            redirect: false,
            callbackUrl: data.redirectUrl || "/app?welcome=partner",
          });

          if (result?.url) {
            // Instead of email verification, go directly to the app
            router.push(data.redirectUrl || "/app?welcome=partner");
          } else {
            queueMicrotask(() => {
              setStatus("error");
            });
            router.push("/login?error=signin-failed");
          }
        } else {
          queueMicrotask(() => {
            setStatus("error");
          });
          router.push("/login?error=invalid-token");
        }
      })
      .catch(() => {
        queueMicrotask(() => {
          setStatus("error");
        });
        router.push("/login?error=system-error");
      });
  }, [token, email, router]);

  return ... ;
}

import { Suspense } from "react";

export default function AuthLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>;
}

import "@/styles/globals.css";

type LayoutProps = {
  children: React.ReactNode;
};

export default async function RootLayout(props: LayoutProps) {
  const { children } = props;
  return children;
}

⏺ Excellent! This confirms it's NOT related to generateStaticParams in the [domain] routes.

  The error still occurs with only 4 pages (Generating static pages (0/4)) and just the /auth route active. Notice it now says "Generating static pages (0/4)" instead of "(0/2199)".

  This means:
  - :white_check_mark: The issue is isolated to the /auth/partner-signin route itself
  - :white_check_mark: NOT caused by other routes with generateStaticParams
  - :white_check_mark: The route structure with Suspense boundaries is still failing

  Let me check what those 4 pages are and look more carefully at the /auth route structure:

⏺ Bash(find /Users/alexnelson/Sites/ontempo/app/auth -type f -name "*.tsx" -o -name "*.ts" | sort)
  ⎿  /Users/alexnelson/Sites/ontempo/app/auth/layout.tsx                      
     /Users/alexnelson/Sites/ontempo/app/auth/partner-signin/page.tsx
     /Users/alexnelson/Sites/ontempo/app/auth/partner-signin/PartnerSignIn.tsx

⏺ Bash(ls -R /Users/alexnelson/Sites/ontempo/app/auth)
  ⎿  layout.tsx                   
     partner-signin
     … +3 lines (ctrl+o to expand)

⏺ So only 3 files. Let me look more carefully at the actual Suspense setup. Let me re-read the files to see the current state:

⏺ Read(app/auth/partner-signin/page.tsx)
  ⎿  Read 10 lines

⏺ Read(app/auth/layout.tsx)
  ⎿  Read 10 lines

⏺ Perfect. So we have:
  - Layout with Suspense :white_check_mark:
  - Page with Suspense :white_check_mark:
  - Client component with useSearchParams :white_check_mark:

  This is the exact minimal reproduction. The setup is correct, yet Next.js 16 with cacheComponents: true is still trying to prerender it and failing.

import { NextRequest, NextResponse } from "next/server";
import { getToken } from "next-auth/jwt";

export const config = {
  matcher: [
    "/((?!api/|_next/|_static/|_vercel|[\\w-]+\\.\\w+).*)",
  ],
};

export default async function proxy(req: NextRequest) {
  const url = req.nextUrl;

  // Skip processing for font files
  if (
    url.pathname.includes("/_next/static/fonts/") ||
    url.pathname.match(/\.(ttf|woff|woff2|eot|otf)$/)
  ) {
    return NextResponse.next();
  }

  const hostname = req.headers
    .get("host")!
    .replace(".localhost:3000", `.${process.env.NEXT_PUBLIC_ROOT_DOMAIN}`);

  const searchParams = req.nextUrl.searchParams.toString();
  const path = `${url.pathname}${searchParams ? `?${searchParams}` : ""}`;

  // Create base response
  let response: NextResponse;

  // Handle app pages
  if (hostname == `app.${process.env.NEXT_PUBLIC_ROOT_DOMAIN}`) {
    const session = await getToken({ req });

    if (!session && path !== "/login") {
      const loginUrl = new URL("/login", req.url);
      response = NextResponse.redirect(loginUrl);
    } else if (session && path === "/login") {
      const homeUrl = new URL("/", req.url);
      response = NextResponse.redirect(homeUrl);
    } else {
      const appUrl = new URL(`/app${path === "/" ? "" : path}`, req.url);
      response = NextResponse.rewrite(appUrl);
    }
  }
  // Handle root application
  else if (
    hostname === "localhost:3000" ||
    hostname === process.env.NEXT_PUBLIC_ROOT_DOMAIN
  ) {
    const homeUrl = new URL(`/home${path === "/" ? "" : path}`, req.url);
    response = NextResponse.rewrite(homeUrl);
  } else {
    const customUrl = new URL(`/${hostname}${path}`, req.url);
    response = NextResponse.rewrite(customUrl);
  }

  return response;
}