The good path is this way.

import Stripe from "stripe";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

export async function POST(request: Request) {
  const body = await request.text(); // raw body, not request.json()
  const signature = request.headers.get("stripe-signature") ?? "";
  let event: Stripe.Event;
  try {
    event = stripe.webhooks.constructEvent(body, signature, process.env.STRIPE_WEBHOOK_SECRET!);
  } catch {
    return new Response("Invalid signature", { status: 400 });
  }
  if (event.type === "checkout.session.completed") {
    // fulfil the order
  }
  return Response.json({ received: true });
}

const session = await stripe.checkout.sessions.create({
  mode: "subscription",
  line_items: [{ price: process.env.STRIPE_METERED_PRICE_ID! }], // no quantity for a metered price
  success_url: `${origin}/billing?session_id={CHECKOUT_SESSION_ID}`,
  cancel_url: `${origin}/pricing`,
});
return Response.redirect(session.url!, 303);

const idempotencyKey = `order-${order.id}-payment`;

const intent = await stripe.paymentIntents.create(
  { amount: order.amountCents, currency: "usd", metadata: { order_id: order.id } },
  { idempotencyKey },
);

const amount = Math.round(priceInDollars * 100); // 19.99 -> 1999

const intent = await stripe.paymentIntents.create({
  amount,
  currency: "usd",
  automatic_payment_methods: { enabled: true },
});

alter table public.notes enable row level security;

create policy "Users insert their own notes"
  on public.notes for insert
  to authenticated
  with check ((select auth.uid()) = user_id);

create policy "Users read their own notes"
  on public.notes for select
  to authenticated
  using ((select auth.uid()) = user_id);

import { cookies } from "next/headers";
import { createServerClient } from "@supabase/ssr";

export async function createClient() {
  const cookieStore = await cookies();
  return createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!, {
    cookies: {
      getAll: () => cookieStore.getAll(),
      setAll: (list) => {
        try {
          list.forEach(({ name, value, options }) => cookieStore.set(name, value, options));
        } catch {
          // called from a server component: middleware refreshes the session instead
        }
      },
    },
  });
}

const supabase = await createClient();
const { data: { user } } = await supabase.auth.getUser();
if (!user) redirect("/login");

const { data: profile, error } = await supabase
  .from("profiles")
  .select("id, username")
  .eq("id", userId)
  .maybeSingle();

if (error) throw error;
if (!profile) return notFound();

-- migration
alter publication supabase_realtime add table public.messages;

// client
const channel = supabase
  .channel("messages")
  .on("postgres_changes", { event: "INSERT", schema: "public", table: "messages" }, (payload) => {
    console.log(payload.new);
  })
  .subscribe();

// on unmount
supabase.removeChannel(channel);

-- migration
create or replace function public.search_notes(p_query text)
returns setof public.notes
language sql stable
as $$ select * from public.notes where body ilike '%' || p_query || '%' $$;

grant execute on function public.search_notes(text) to authenticated;
notify pgrst, 'reload schema';

// client: keys match the parameter names
const { data, error } = await supabase.rpc("search_notes", { p_query: "bees" });

export default async function Page({
  params,
  searchParams,
}: {
  params: Promise<{ slug: string }>;
  searchParams: Promise<{ q?: string }>;
}) {
  const { slug } = await params;
  const { q } = await searchParams;
  return <Post slug={slug} query={q} />;
}

// route handler
export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  return Response.json({ id });
}

// search-box.tsx
"use client";
import { useSearchParams } from "next/navigation";

export function SearchBox() {
  const q = useSearchParams().get("q") ?? "";
  return <input defaultValue={q} name="q" />;
}

// page.tsx
import { Suspense } from "react";
import { SearchBox } from "./search-box";

export default function Page() {
  return (
    <Suspense fallback={null}>
      <SearchBox />
    </Suspense>
  );
}

vercel env add STRIPE_SECRET_KEY preview
vercel env ls preview
vercel env pull .env.local
vercel deploy   # new preview build picks the variable up

// app/api/report/route.ts: needs fs, so it runs on Node
export const runtime = "nodejs";

import { readFile } from "node:fs/promises";

export async function GET() {
  const template = await readFile(process.cwd() + "/templates/report.html", "utf8");
  return new Response(template, { headers: { "content-type": "text/html" } });
}

// middleware.ts stays edge-safe: Web APIs only
import { jwtVerify } from "jose";

messages.push({ role: "assistant", content: response.content });

const results = [];
for (const block of response.content) {
  if (block.type !== "tool_use") continue;
  try {
    results.push({ type: "tool_result", tool_use_id: block.id, content: await runTool(block.name, block.input) });
  } catch (err) {
    results.push({ type: "tool_result", tool_use_id: block.id, content: String(err), is_error: true });
  }
}

messages.push({ role: "user", content: results }); // one result per tool_use, same turn

const response = await anthropic.messages.create({
  model: MODEL, // your model id
  max_tokens: 1024,
  system: "You are a concise release-notes writer.",
  messages: [{ role: "user", content: "Summarise this diff: ..." }],
});

import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic({ maxRetries: 5 }); // SDK backs off on 429, 5xx and 529

async function withBackoff<T>(call: () => Promise<T>, attempts = 6): Promise<T> {
  for (let i = 0; ; i++) {
    try {
      return await call();
    } catch (err) {
      const overloaded = err instanceof Anthropic.APIError && err.status === 529;
      if (!overloaded || i >= attempts - 1) throw err;
      const delay = Math.min(30_000, 1000 * 2 ** i) * (0.5 + Math.random() / 2);
      await new Promise((r) => setTimeout(r, delay));
    }
  }
}

const payout = await hivepay.payouts.create(
  {
    amount: 4999,
    currency: "usd",
    destination: {
      type: "bank_account",
      token: "ba_tok_8f2c41d7a9"
    },
    metadata: {
      reference: "Oct payout 8841"
    }
  },
  {
    idempotencyKey: "hp_0123456789abcdef01234567"
  }
);

import { createClient } from "./sdk/hivepay.mjs";

const hivepay = createClient({ apiKey: process.env.HIVEPAY_API_KEY ?? "hp_test_offline" });

const payout = await hivepay.payouts.create(
  {
    amount: 4999, // minor units: $49.99
    currency: "usd",
    destination: { type: "bank_account", token: "ba_tok_8f2c41d7a9" },
    metadata: { reference: "Oct payout 8841" }, // <= 18 chars
  },
  // hp_ + 24 lowercase hex, stable per payout (first 24 hex of sha256("idem-8841"))
  { idempotencyKey: "hp_fbfefa43c66696070f20c6e1" },
);
// payout => { id: "po_...", status: "paid", amount: 4999, currency: "usd" }

const payout = await hivepay.payouts.create(
  {
    amount: 4999,
    currency: "usd",
    destination: {
      type: "bank_account",
      token: "ba_tok_8f2c41d7a9",
    },
    metadata: {
      reference: "Oct payout 8841",
    },
  },
  {
    idempotencyKey: "hp_0123456789abcdef01234567",
  }
);