bsmnt 0.13.1 → 0.15.0

package/src/templates/next-pagebuilder/lib/utils/base-url.ts

@@ -3,15 +3,30 @@
  *
  * Priority:
  * 1. NEXT_PUBLIC_BASE_URL (explicit production URL)
- * 2. VERCEL_PROJECT_PRODUCTION_URL (Vercel production domain)
- * 3. VERCEL_URL (Vercel preview/deployment URL)
+ * 2. VERCEL_PROJECT_PRODUCTION_URL, on production deployments only
+ * 3. VERCEL_URL (the deployment's own URL, so previews never emit production URLs)
  * 4. http://localhost:3000 (local development)
  */
 export const getBaseUrl = () =>
   process.env.NEXT_PUBLIC_BASE_URL ||
-  (process.env.VERCEL_PROJECT_PRODUCTION_URL
+  (process.env.VERCEL_ENV === "production" &&
+  process.env.VERCEL_PROJECT_PRODUCTION_URL
     ? `https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}`
     : undefined) ||
   (process.env.VERCEL_URL
     ? `https://${process.env.VERCEL_URL}`
     : "http://localhost:3000")
+
+// The production build also answers on *.vercel.app; only the launch domain is indexed.
+export const getIndexableHost = () => {
+  const baseUrl = process.env.NEXT_PUBLIC_BASE_URL
+  // Off Vercel VERCEL_ENV is unset, and the configured host is the launch domain.
+  const vercelEnv = process.env.VERCEL_ENV
+  if (!baseUrl || (vercelEnv && vercelEnv !== "production")) return null
+  return URL.canParse(baseUrl) ? new URL(baseUrl).host : null
+}
+
+export const isIndexableHost = (host: string | null | undefined) => {
+  const indexable = getIndexableHost()
+  return indexable !== null && host?.toLowerCase() === indexable
+}

package/src/templates/next-pagebuilder/lib/utils/breadcrumbs.ts

@@ -0,0 +1,70 @@
+import type { BREADCRUMB_PAGES_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types"
+
+type BreadcrumbPage = BREADCRUMB_PAGES_QUERY_RESULT[number]
+
+type Breadcrumb = {
+  name: string
+  url: string
+}
+
+const HOME_NAME = "Home"
+
+const trimSlashes = (path: string) => path.replace(/^\/+|\/+$/g, "")
+
+const firstNonEmpty = (...values: (string | null | undefined)[]) =>
+  values.find((value) => value?.trim())?.trim()
+
+const urlFor = (path: string) => (path ? `/${path}` : "/")
+
+const labelFor = (page: BreadcrumbPage | undefined) =>
+  page && firstNonEmpty(page.shortTitle, page.folderTitle, page.title)
+
+// Every parent path, not the path itself: "a/b/c" → ["a", "a/b"].
+const ancestorPaths = (path: string) => {
+  const segments = path.split("/").filter(Boolean)
+  return segments
+    .slice(0, -1)
+    .map((_, index) => segments.slice(0, index + 1).join("/"))
+}
+
+// The paths a page's crumbs are named from, besides the homepage: its
+// ancestors and itself.
+export const breadcrumbPaths = (path: string | null) => {
+  const current = trimSlashes(path ?? "")
+  return current ? [...ancestorPaths(current), current] : []
+}
+
+// Crumbs are named from the pages at each level, the current one included:
+// Short Title, then the folder name for a folder's index page, then Title. A
+// level with no page is skipped, so a crumb never links to a 404.
+export const buildBreadcrumbs = ({
+  path,
+  name,
+  pages,
+}: {
+  path: string | null
+  name: string
+  pages: readonly BreadcrumbPage[]
+}): Breadcrumb[] => {
+  const pageAt = (target: string) =>
+    pages.find((page) => trimSlashes(page.path ?? "") === target)
+
+  const home = pageAt("")
+  const crumbs: Breadcrumb[] = [
+    {
+      name: firstNonEmpty(home?.shortTitle, home?.title) ?? HOME_NAME,
+      url: "/",
+    },
+  ]
+
+  const current = trimSlashes(path ?? "")
+  if (!current) return crumbs
+
+  for (const ancestor of ancestorPaths(current)) {
+    const ancestorName = labelFor(pageAt(ancestor))
+    if (ancestorName) crumbs.push({ name: ancestorName, url: urlFor(ancestor) })
+  }
+
+  crumbs.push({ name: labelFor(pageAt(current)) ?? name, url: urlFor(current) })
+  return crumbs
+}

package/src/templates/next-pagebuilder/next.config.ts

@@ -1,5 +1,9 @@
 import withBundleAnalyzer from "@next/bundle-analyzer"
 import type { NextConfig } from "next"
+import { getIndexableHost } from "./lib/utils/base-url"
+
+// Only the launch domain is indexed; every other host is sent noindex.
+const indexableHost = getIndexableHost()
 
 const nextConfig: NextConfig = {
   reactStrictMode: true,
@@ -92,6 +96,18 @@ const nextConfig: NextConfig = {
     imageSizes: [16, 32, 48, 64, 96, 128, 256, 384],
   },
   headers: async () => [
+    {
+      source: "/:path*",
+      ...(indexableHost && {
+        missing: [
+          {
+            type: "host" as const,
+            value: indexableHost.replaceAll(".", "\\."),
+          },
+        ],
+      }),
+      headers: [{ key: "X-Robots-Tag", value: "noindex" }],
+    },
     {
       // Excludes /studio* — must stay mutually exclusive with the rule below.
       source: "/((?!studio(?:/|$)).*)",

package/src/templates/next-pagebuilder/package.json

@@ -17,7 +17,7 @@
     "knip": "knip",
     "knip:fix": "knip --fix",
     "lighthouse": "bunx @unlighthouse/cli --site http://localhost:3000",
-    "lint": "biome lint --max-diagnostics=200",
+    "lint": "biome ci --error-on-warnings --max-diagnostics=200 .",
     "lint:fix": "biome check --write --unsafe --max-diagnostics=200",
     "prepare": "lefthook install",
     "start": "next start",

package/src/templates/next-pagebuilder-cache/.env.example

@@ -26,7 +26,9 @@
 
 # Base URL
 # Inlined at build time — scope this to the Production environment only in
-# Vercel so Preview deployments fall through to VERCEL_PROJECT_PRODUCTION_URL.
+# Vercel so Preview deployments fall through to their own VERCEL_URL. On a
+# production deployment it is also the only host that gets indexed: every other
+# host is sent `X-Robots-Tag: noindex` and a disallow-all robots.txt.
 NEXT_PUBLIC_BASE_URL=
 
 # Draft Mode

package/src/templates/next-pagebuilder-cache/.github/workflows/ci.yml

@@ -8,6 +8,13 @@ on:
     branches:
       - main
 
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   ci:
     runs-on: ubuntu-latest
@@ -43,17 +50,33 @@ jobs:
       - name: Type check
         run: bun run typecheck
 
-      - name: Lint
+      - name: Lint and format
         run: bun run lint
 
+      # Runs your tests if any exist; a fresh project with none passes cleanly.
+      - name: Test
+        run: |
+          if git ls-files '*.test.*' '*.spec.*' '*_test.*' '*_spec.*' | grep -q .; then
+            bun test
+          else
+            echo "No test files found — skipping bun test."
+          fi
+
       # bsmnt:if dotenvx
       # dotenvx needs the private key to decrypt secrets at build time. It's
       # pulled from 1Password via an org-wide service-account token + the op-ref
       # committed in .env. Optional: builds pass without it (only plaintext /
       # NEXT_PUBLIC_* is read), and a per-repo DOTENV_PRIVATE_KEY secret still
       # works as a fallback.
+      # The `secrets` context isn't available in step `if:`, so the check runs as its own step.
+      - name: Detect 1Password token
+        id: op
+        env:
+          OP_SERVICE_ACCOUNT_TOKEN: ${{ secrets.OP_SERVICE_ACCOUNT_TOKEN }}
+        run: '[ -n "$OP_SERVICE_ACCOUNT_TOKEN" ] && echo "enabled=true" >> "$GITHUB_OUTPUT" || true'
+
       - name: Install 1Password CLI
-        if: ${{ secrets.OP_SERVICE_ACCOUNT_TOKEN != '' }}
+        if: steps.op.outputs.enabled == 'true'
         uses: 1password/install-cli-action@v1
 
       - name: Build
@@ -92,13 +115,14 @@ jobs:
         run: bun run build
 
       # bsmnt:endif
-      # Runs your tests if any exist; a fresh project with none passes cleanly.
-      - name: Test
+      # `prebuild` regenerated these; any change (or untracked file) means they were committed stale.
+      - name: Generated Sanity files are committed
         run: |
-          if git ls-files '*.test.*' '*.spec.*' '*_test.*' '*_spec.*' | grep -q .; then
-            bun test
-          else
-            echo "No test files found — skipping bun test."
+          cd lib/integrations/sanity
+          if [ -n "$(git status --porcelain -- sanity.types.ts schema.json)" ]; then
+            git status --short -- sanity.types.ts schema.json
+            echo "::error::Run \`bun sanity:typegen\` and commit the result."
+            exit 1
           fi
 
       - name: Knip

package/src/templates/next-pagebuilder-cache/AGENTS.md

@@ -11,7 +11,9 @@ page.
 Studio with a slug, not a directory. `app/(content)/[[...slug]]/page.tsx`
 resolves every one of them; a hand-written route shadows that resolver and
 becomes a URL no editor can see, move or delete. The only things that belong in
-`app/` are non-page endpoints — the Studio, API handlers, sitemap, feed.
+`app/` are non-page endpoints — the Studio, API handlers, sitemap, feed, and
+`app/components`, the Studio's live block preview: it renders fixtures rather
+than content, is gated to Studio embeds by `isStudioEmbed()` and is `noindex`.
 
 It runs with [Cache Components](https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheComponents)
 (`cacheComponents: true`), so every Sanity read sits behind a `'use cache'`
@@ -22,10 +24,18 @@ boundaries where they are unless you mean to move them.
 
 ## Page-builder blocks
 
+**Blocks are inline objects, never documents.** A placement belongs to exactly
+one page, so the page's `pageBuilder` array stores the block itself and nothing
+is dereferenced at read time. Don't reintroduce a block-as-document with a
+reference member — that model was removed deliberately: no block was ever
+reused, and it cost a hop on every read plus a second id to address.
+
 **A block is `defineBlock` + a registry entry.** Define the schema with
 `defineBlock` (`lib/integrations/sanity/schemas/shared/block.ts`), never
-`defineType` — it implies `type: "document"` and appends **Anchor ID** and
-**Presentation Mode** for you. Register the component in
+`defineType` — it implies `type: "object"` and appends **Anchor ID** and
+**Presentation Mode** for you. The array member's type name *is* the block's
+`_type`, so the registry, the insert menu and the fixture library all key off
+the same string. Register the component in
 `components/page-builder/registry.tsx`; the renderer is driven by that map, so
 there is no switch to extend.
 
@@ -40,10 +50,12 @@ that was never registered — is a typecheck error.
 drives the insert menu; `misc` only when nothing else fits). Never collapse them
 into one field: that is what made the menu a single flat list.
 
-**And a preview image.** The insert menu renders one tile per block from a
-`studioPreview` document (Components → Component Previews) keyed
-`block.<memberName>`. A block without one falls back to its schema icon, which
-is what made the old menu unreadable.
+**And a fixture.** A block isn't done until `components/page-builder/library.ts`
+has an entry for it: a stand-in value typed as the block's query result, plus a
+one-line note. That entry is the block's preview everywhere — the live pane in
+the insert menu, its row in Studio → Components, and the `/components` route,
+all rendered by the production renderer. Without one the picker just says the
+component has no preview.
 
 **Never hardcode vertical padding in a block component.** The renderer wraps
 each block in `<Section>` (`components/page-builder/section.tsx`), which owns
@@ -134,3 +146,6 @@ the "Page-builder blocks" section of the README.
 
   (`bun run build`, not `bun build` — the bare form is Bun's bundler.) Say what
   you ran and what it printed; don't report success you haven't seen.
+- **Before a commit or PR, or when told to ship, check the `launch-ready`
+  skill's rules against the diff.** Run all of them when asked whether the site
+  is ready to launch.

package/src/templates/next-pagebuilder-cache/README.md

@@ -25,14 +25,18 @@ bun dev
 
 ## Page-builder blocks
 
-A block is two halves — a schema document and a React component — and each half
-has one place that makes it a block rather than an ordinary document or a loose
+A block is two halves — a schema type and a React component — and each half has
+one place that makes it a block rather than an ordinary object type or a loose
 component. Use them and Anchor ID, Presentation Mode and the spacing scale come
 for free.
 
+Blocks are **inline objects** in the page's `pageBuilder` array, never documents
+and never referenced: a placement belongs to exactly one page, so the block
+lives on that page and nothing is dereferenced at read time.
+
 **Define the schema with `defineBlock`, never `defineType`**
 (`lib/integrations/sanity/schemas/shared/block.ts`). It implies
-`type: "document"` and appends two fields to every block:
+`type: "object"` and appends two fields to every block:
 
 - **Anchor ID** — optional. Left empty, the anchor is generated from the block's
   own title at render time (`headline` / `heading` / `teaserHeading` / `title` /
@@ -61,6 +65,14 @@ block in `<Section>` (`components/page-builder/section.tsx`), which owns the
 component returns its content only — no outer `<section>`, no `py-*` / `pt-*` /
 `pb-*` on its root. Internal gaps between a block's own parts are fine.
 
+**Every block ships a fixture in `components/page-builder/library.ts`**: a
+stand-in value typed as the block's query result, plus a one-line note. It is
+the block's only preview, and it is rendered by the production renderer at
+`/components` — a route the Studio embeds in an iframe, so the insert menu and
+**Components** in the Studio show the real block rather than a screenshot. The
+route is gated to Studio embeds and `noindex`; a block with no entry simply has
+no preview.
+
 ### The spacing scale is content, not code
 
 Editors own it at **Layout → Spacing Scale**: a list of steps, each with a name

package/src/templates/next-pagebuilder-cache/app/(content)/[[...slug]]/page.tsx

@@ -1,6 +1,9 @@
 import { cacheLife, cacheTag } from "next/cache"
 import { notFound } from "next/navigation"
-import { PageDocument } from "@/components/page-document"
+import { toPlainText } from "next-sanity"
+import { findBlogBlock, PageDocument } from "@/components/page-document"
+import { getBreadcrumbPages } from "@/lib/integrations/sanity/fetchers/breadcrumbs"
+import { getLayoutData } from "@/lib/integrations/sanity/fetchers/layout"
 import {
   type DynamicFetchOptions,
   getDynamicFetchOptions,
@@ -80,6 +83,23 @@ export const generateStaticParams = async () => {
   ]
 }
 
+// Blog posts fall back to their body and thumbnail when the SEO fields are
+// empty, and are tagged as articles.
+const blogPostMetadata = (page: NonNullable<PAGE_QUERY_RESULT>) => {
+  const post = findBlogBlock(page)
+  if (!post) return {}
+
+  return {
+    fallbackDescription: post.body ? toPlainText(post.body) : undefined,
+    fallbackImage: post.thumbnail,
+    article: {
+      publishedTime: post.date,
+      modifiedTime: page._updatedAt,
+      authors: [post.author?.name],
+    },
+  }
+}
+
 export const generateMetadata = async ({ params }: Props) => {
   const [{ slug }, fetchOptions] = await Promise.all([
     params,
@@ -91,11 +111,20 @@ export const generateMetadata = async ({ params }: Props) => {
 
   // stega off: it would corrupt a <title> or og:image URL, and metadata renders no
   // DOM for <VisualEditing> anyway. In published mode this is the body's key.
-  const page = await getCachedPage(path, { ...fetchOptions, stega: false })
+  const metadataFetchOptions = { ...fetchOptions, stega: false }
+  const [page, { structuredData }] = await Promise.all([
+    getCachedPage(path, metadataFetchOptions),
+    getLayoutData(metadataFetchOptions),
+  ])
 
-  return page
-    ? generateSanityMetadata({ document: page, url: path ? `/${path}` : "/" })
-    : {}
+  if (!page) return {}
+
+  return generateSanityMetadata({
+    document: page,
+    url: path ? `/${path}` : "/",
+    site: structuredData,
+    ...blogPostMetadata(page),
+  })
 }
 
 // No Suspense wrapper needed: `getDynamicFetchOptions` is prerender-safe and
@@ -112,7 +141,10 @@ export default async function CatchAllPage({
 
   if (slug?.length && path === null) notFound()
 
-  const page = await getCachedPage(path, fetchOptions)
+  const [page, breadcrumbPages] = await Promise.all([
+    getCachedPage(path, fetchOptions),
+    getBreadcrumbPages(path, fetchOptions),
+  ])
 
   if (!page) {
     // Fall back to a CMS redirect before 404ing.
@@ -120,5 +152,12 @@ export default async function CatchAllPage({
     notFound()
   }
 
-  return <PageDocument page={page} path={path} searchParams={searchParams} />
+  return (
+    <PageDocument
+      page={page}
+      path={path}
+      searchParams={searchParams}
+      breadcrumbPages={breadcrumbPages}
+    />
+  )
 }

package/src/templates/next-pagebuilder-cache/app/actions/unlock-gated-content.ts

@@ -14,13 +14,14 @@ export type UnlockResult =
   | { ok: true; payload: GatedContentPayload }
   | { ok: false; error: string }
 
-type UnlockInput = { documentId: string; email: string }
+type UnlockInput = { pageId: string; blockKey: string; email: string }
 
 export async function unlockGatedContent({
-  documentId,
+  pageId,
+  blockKey,
   email,
 }: UnlockInput): Promise<UnlockResult> {
-  if (!documentId) return { ok: false, error: "Missing content id." }
+  if (!(pageId && blockKey)) return { ok: false, error: "Missing content id." }
   if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
     return { ok: false, error: "Enter a valid email address." }
   }
@@ -38,7 +39,7 @@ export async function unlockGatedContent({
   // is how `variant` goes missing.
   const payload = await client.fetch<GATED_CONTENT_QUERY_RESULT>(
     GATED_CONTENT_QUERY,
-    { id: documentId },
+    { pageId, blockKey },
     toSanityFetchOptions({
       ...fetchOptions,
       // stega must stay off: it injects invisible characters into strings, which

package/src/templates/next-pagebuilder-cache/app/components/page.tsx

@@ -0,0 +1,91 @@
+import type { Metadata } from "next"
+import { draftMode } from "next/headers"
+import { notFound } from "next/navigation"
+import { Suspense } from "react"
+import { SpacingScale } from "@/components/layout/spacing-scale"
+import {
+  COMPONENT_LIBRARY,
+  COMPONENT_PREVIEW_PARAM,
+  getLibraryEntry,
+  type LibraryEntry,
+} from "@/components/page-builder/library"
+import { Renderer } from "@/components/page-builder/renderer"
+import { Stage } from "@/components/page-builder/stage"
+import { isStudioEmbed } from "@/lib/utils/studio-embed"
+
+export const metadata: Metadata = {
+  title: "Components",
+  robots: { index: false, follow: false, nocache: true },
+}
+
+type Props = {
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}
+
+const firstValue = (value: string | string[] | undefined) =>
+  Array.isArray(value) ? value[0] : value
+
+const PREVIEW_PAGE_ID = "component-preview"
+
+const EntryHeader = ({ entry }: { entry: LibraryEntry }) => (
+  <header className="sticky top-0 z-10 flex items-baseline gap-3 border-neutral-200 border-b bg-white/85 px-6 py-3 backdrop-blur">
+    <h2 className="font-mono text-neutral-900 text-xs uppercase">
+      {entry.title}
+    </h2>
+    <p className="text-neutral-500 text-xs">{entry.notes}</p>
+  </header>
+)
+
+const PreviewStage = ({ entry }: { entry: LibraryEntry }) => (
+  <Stage background={entry.background}>
+    <Renderer
+      blocks={[entry.block]}
+      pageId={PREVIEW_PAGE_ID}
+      pinnedCategory={null}
+      searchParams={undefined}
+    />
+  </Stage>
+)
+
+// Both `isStudioEmbed()` (headers) and `searchParams` are request-time data, so
+// under Cache Components this has to sit inside the page's <Suspense> boundary —
+// at the top of the page it fails the prerender with blocking-prerender-dynamic.
+const Library = async ({ searchParams }: Props) => {
+  const [params, embedded] = await Promise.all([searchParams, isStudioEmbed()])
+
+  if (!embedded) notFound()
+
+  const requested = firstValue(params[COMPONENT_PREVIEW_PARAM])
+  const entry = getLibraryEntry(requested)
+
+  if (requested && !entry) notFound()
+
+  if (entry) return <PreviewStage entry={entry} />
+
+  return (
+    <>
+      {COMPONENT_LIBRARY.map((item) => (
+        <section key={item.documentType}>
+          <EntryHeader entry={item} />
+          <PreviewStage entry={item} />
+        </section>
+      ))}
+    </>
+  )
+}
+
+// Outside the `(content)` group, so `<SpacingScale />` is on this route.
+const Page = async ({ searchParams }: Props) => {
+  const { isEnabled: isDraftMode } = await draftMode()
+
+  return (
+    <main className="flex flex-col">
+      <SpacingScale isDraftMode={isDraftMode} />
+      <Suspense fallback={null}>
+        <Library searchParams={searchParams} />
+      </Suspense>
+    </main>
+  )
+}
+
+export default Page

package/src/templates/next-pagebuilder-cache/app/layout.tsx

@@ -4,17 +4,11 @@ import type { Metadata } from "next"
 import { Geist } from "next/font/google"
 import type { PropsWithChildren } from "react"
 import { cn } from "@/lib/styles/cn"
+import { getBaseUrl } from "@/lib/utils/base-url"
 import AppData from "@/package.json"
 
 const APP_NAME = AppData.name
-const APP_DEFAULT_TITLE = "My Site"
-const APP_TITLE_TEMPLATE = "%s"
-const APP_DESCRIPTION = AppData.description
-// Build-time-stable so static routes (Studio, /_not-found) stay prerenderable
-// under Cache Components. NEXT_PUBLIC_* is inlined at build; reading runtime env
-// (VERCEL_URL) here would taint every route's metadata as request-time data.
-const APP_BASE_URL =
-  process.env.NEXT_PUBLIC_BASE_URL ?? "http://localhost:3000"
+const APP_BASE_URL = getBaseUrl()
 
 const geist = Geist({
   subsets: ["latin"],
@@ -22,55 +16,20 @@ const geist = Geist({
 })
 
 export const metadata: Metadata = {
-  alternates: {
-    canonical: "/",
-    languages: {
-      "en-US": "/en-US",
-    },
-  },
+  metadataBase: new URL(APP_BASE_URL),
+  applicationName: APP_NAME,
   appleWebApp: {
     capable: true,
     statusBarStyle: "default",
-    title: APP_DEFAULT_TITLE,
   },
-  applicationName: APP_NAME,
-  authors: [{ name: "basement.studio", url: "https://basement.studio" }],
-  description: APP_DESCRIPTION,
   formatDetection: { telephone: false },
-  metadataBase: new URL(APP_BASE_URL),
   openGraph: {
-    description: APP_DESCRIPTION,
-    images: [
-      {
-        alt: APP_DEFAULT_TITLE,
-        height: 630,
-        url: "/opengraph-image.jpg",
-        width: 1200,
-      },
-    ],
-    locale: "en_US",
     siteName: APP_NAME,
-    title: {
-      default: APP_DEFAULT_TITLE,
-      template: APP_TITLE_TEMPLATE,
-    },
+    locale: "en_US",
     type: "website",
-    url: APP_BASE_URL,
-  },
-  other: {
-    "fb:app_id": process.env.NEXT_PUBLIC_FACEBOOK_APP_ID || "",
-  },
-  title: {
-    default: APP_DEFAULT_TITLE,
-    template: APP_TITLE_TEMPLATE,
   },
   twitter: {
     card: "summary_large_image",
-    description: APP_DESCRIPTION,
-    title: {
-      default: APP_DEFAULT_TITLE,
-      template: APP_TITLE_TEMPLATE,
-    },
   },
 }
 

package/src/templates/next-pagebuilder-cache/app/robots.ts

@@ -1,12 +1,18 @@
 import type { MetadataRoute } from "next"
-import { getBaseUrl } from "@/lib/utils/base-url"
+import { headers } from "next/headers"
+import { getBaseUrl, isIndexableHost } from "@/lib/utils/base-url"
+
+export default async function robots(): Promise<MetadataRoute.Robots> {
+  const host = (await headers()).get("host")
+  if (!isIndexableHost(host)) {
+    return { rules: { userAgent: "*", disallow: "/" } }
+  }
 
-export default function robots(): MetadataRoute.Robots {
   return {
     rules: {
       userAgent: "*",
       allow: "/",
-      disallow: [],
+      disallow: ["/api/", "/studio"],
     },
     sitemap: `${getBaseUrl()}/sitemap.xml`,
   }

package/src/templates/next-pagebuilder-cache/biome.json

@@ -36,7 +36,8 @@
       "!**/*.mdx",
       "!**/tailwind.css",
       "!**/*.grit",
-      "!**/sanity.types.ts"
+      "!**/sanity.types.ts",
+      "!next-env.d.ts"
     ]
   },
   "formatter": {

package/src/templates/next-pagebuilder-cache/components/layout/footer/index.tsx

@@ -60,7 +60,7 @@ async function CachedFooter(fetchOptions: DynamicFetchOptions) {
           <div className="grid grid-cols-5 gap-x-8 gap-y-6 md:grid-cols-3 lg:grid-cols-5">
             {links.map((linkGroup: FooterLinkGroup) => (
               <div key={linkGroup._key} className="flex flex-col gap-2">
-                <h3>{linkGroup.title}</h3>
+                <h2>{linkGroup.title}</h2>
                 {linkGroup.items && linkGroup.items.length > 0 ? (
                   <ul className="space-y-1">
                     {linkGroup.items