@forgecart/cli 2.202610280649.0 → 2.202610280926.0

package/templates/storefront-blank/src/app/api/%5F%5Fbackend/methods/route.ts

@@ -0,0 +1,27 @@
+import { NextResponse } from 'next/server';
+
+import { getBackend } from '../../../../server/bootstrap';
+
+/**
+ * DEV-ONLY registry listing — the agent's verification surface for backend
+ * features. After authoring a method, the agent probes this route and
+ * confirms the new name is listed; a boot failure (the api-map drift check)
+ * surfaces here as a 500 carrying the actionable message.
+ *
+ * Gated on `NODE_ENV === 'development'`: the literal check is inlined by
+ * the bundler, so a production build answers 404 and dead-code-eliminates
+ * the body. Method NAMES are the only thing exposed — never inputs,
+ * outputs, or configuration.
+ */
+export async function GET(): Promise<NextResponse> {
+  if (process.env.NODE_ENV !== 'development') {
+    return NextResponse.json({ error: 'not found' }, { status: 404 });
+  }
+  try {
+    const { registry } = await getBackend();
+    return NextResponse.json({ methods: [...registry.keys()].sort() });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: reason }, { status: 500 });
+  }
+}

package/templates/storefront-blank/src/app/error.tsx

@@ -0,0 +1,21 @@
+'use client';
+
+/**
+ * Route-level backstop boundary. The action layer never throws (typed
+ * `ActionResult` envelopes end at inline UI), so landing here means a RENDER
+ * failed — e.g. a Server Component read against an unreachable shop API.
+ * Recovery is a re-render via `reset()`.
+ */
+export default function RouteError({ reset }: { error: Error; reset: () => void }) {
+  return (
+    <div className="mx-auto max-w-xl space-y-4 py-16 text-center">
+      <h1 className="text-2xl font-bold tracking-tight text-base-content">Something went wrong</h1>
+      <p className="text-base-content/60">
+        The store could not load this page. Please try again in a moment.
+      </p>
+      <button type="button" className="btn btn-primary" onClick={() => reset()}>
+        Try again
+      </button>
+    </div>
+  );
+}

package/templates/storefront-blank/src/app/global-error.tsx

@@ -0,0 +1,23 @@
+'use client';
+
+/**
+ * Root backstop: replaces the whole document when the root layout itself
+ * fails to render. Must own its own <html>/<body> — the layout that normally
+ * provides them is the thing that crashed. Styled inline (no globals.css —
+ * that import lives in the crashed layout).
+ */
+export default function GlobalError({ reset }: { error: Error; reset: () => void }) {
+  return (
+    <html lang="en">
+      <body
+        style={{ fontFamily: 'system-ui, sans-serif', padding: '4rem 1rem', textAlign: 'center' }}
+      >
+        <h1>Something went wrong</h1>
+        <p>The store is temporarily unavailable. Please try again in a moment.</p>
+        <button type="button" onClick={() => reset()} style={{ padding: '0.5rem 1.25rem' }}>
+          Try again
+        </button>
+      </body>
+    </html>
+  );
+}

package/templates/storefront-blank/src/app/globals.css

@@ -0,0 +1,110 @@
+@import "tailwindcss";
+
+@plugin "daisyui" {
+  themes: false;
+}
+
+/*
+ * ═══════════════════════════════════════════════════════════════════════════
+ * STOREFRONT THEME — the single brand mutation point (design-system contract)
+ * ═══════════════════════════════════════════════════════════════════════════
+ *
+ * Every component in this template speaks SEMANTIC daisyUI classes
+ * (bg-base-100, btn-primary, badge-secondary, alert, steps, …), so the block
+ * below is the ONE place a brand lives. Restyling the storefront = editing
+ * these tokens — nothing else. Never scatter raw palette utilities
+ * (bg-gray-900, text-white, #hex) through components; if a component needs a
+ * color, it needs a TOKEN.
+ *
+ * Token groups and what they drive:
+ *   --color-base-*        page substrate (200), raised surfaces (100), borders
+ *                         (300) and default text (base-content)
+ *   --color-primary       the brand action color: CTAs (btn-primary), active
+ *                         selections, the cart count badge
+ *   --color-secondary     supporting emphasis (subscription badges, secondary
+ *                         chips)
+ *   --color-accent        reserved highlight — used sparingly by new
+ *                         components; keep it distinct from primary
+ *   --color-neutral       high-contrast neutral fills (rarely needed directly)
+ *   info/success/warning/ status semantics (alerts, validators, error text) —
+ *   error                 conventional hues, usually NOT part of a rebrand
+ *   --radius-*            selector = small controls (checkbox/tabs), field =
+ *                         inputs/buttons, box = cards/modals
+ *   --size-*, --border    control density and border weight
+ *   --depth, --noise      daisyUI effect toggles (flat baseline: 0)
+ *
+ * The checkout surfaces consume the same set (steps, fieldset/validator
+ * inputs, radio-card selection rings, alert) — the block enumerates every
+ * variable daisyUI components resolve, so no class ever falls back outside
+ * the contract.
+ *
+ * This baseline is deliberately UNBRANDED (near-black monochrome on soft
+ * gray): it is the neutral canvas an agent rebrands per store. Extension
+ * points this contract keeps open: additional themes are further
+ * `@plugin "daisyui/theme"` blocks (a dark theme adds `prefersdark: true`),
+ * and the visual editor writes these same tokens ("theme main colors" =
+ * primary / secondary / accent here).
+ *
+ * A brand font goes in the `@theme` block after the theme: swap the
+ * `--font-sans` stack (and add the font's `@font-face`/import above it).
+ */
+@plugin "daisyui/theme" {
+  name: "storefront";
+  default: true;
+  color-scheme: light;
+
+  /* Base — white surfaces over a soft-gray substrate, near-black text. */
+  --color-base-100: #ffffff;
+  --color-base-200: #f9fafb;
+  --color-base-300: #e5e7eb;
+  --color-base-content: #111827;
+
+  /* Actions — unbranded monochrome. */
+  --color-primary: #111827;
+  --color-primary-content: #ffffff;
+  --color-secondary: #374151;
+  --color-secondary-content: #ffffff;
+  --color-accent: #1f2937;
+  --color-accent-content: #ffffff;
+  --color-neutral: #111827;
+  --color-neutral-content: #f9fafb;
+
+  /* Status — conventional semantics, not brand. */
+  --color-info: #2563eb;
+  --color-info-content: #ffffff;
+  --color-success: #16a34a;
+  --color-success-content: #ffffff;
+  --color-warning: #d97706;
+  --color-warning-content: #ffffff;
+  --color-error: #dc2626;
+  --color-error-content: #ffffff;
+
+  /* Shape — matches the template's previous rounded-md/lg scale. */
+  --radius-selector: 0.375rem;
+  --radius-field: 0.375rem;
+  --radius-box: 0.5rem;
+  --size-selector: 0.25rem;
+  --size-field: 0.25rem;
+  --border: 1px;
+  --depth: 0;
+  --noise: 0;
+}
+
+/* Brand typography mutation point — swap the stack to give the store a font. */
+@theme {
+  --font-sans: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji",
+    "Segoe UI Symbol", "Noto Color Emoji";
+}
+
+/*
+ * Base document behavior (structural — NOT part of the theme contract).
+ * A horizontal touchpad glide must never trigger the browser's swipe-back
+ * navigation: mid-checkout that discards the shopper's in-progress state
+ * (the refresh-resume path recovers the payment step, but preventing the
+ * accidental navigation is the real fix). The back button and keyboard
+ * navigation are untouched — only the overscroll gesture is consumed.
+ */
+html,
+body {
+  overscroll-behavior-x: none;
+}

package/templates/storefront-blank/src/app/layout.tsx

@@ -0,0 +1,102 @@
+import type { Metadata } from 'next';
+import { notFound, permanentRedirect } from 'next/navigation';
+import { Suspense, type ReactNode } from 'react';
+
+import { ForgeErrorBeacon } from '../components/ForgeErrorBeacon';
+import { ForgeTracker } from '../components/ForgeTracker';
+import { ForgecartDesigner } from '../components/ForgecartDesigner';
+import { getRequestLocale } from '../lib/locale/request-binding';
+import { shellMetadata } from '../lib/seo/metadata';
+import { getSiteVerifications } from '../lib/seo/site-verification';
+import { FORGE_REVISION_META, resolveLiveRevision } from '../server/forge/live-revision';
+
+import './globals.css';
+
+/**
+ * The deployment-wide metadata floor.
+ *
+ * Resolved per REQUEST rather than declared as a static `metadata` object,
+ * because everything in it arrives in the environment of the running server
+ * rather than of the machine that built the bundle: the public origin from
+ * `.env` (see `lib/seo/public-origin.ts`) and the shop name from the channel
+ * itself. A build-time answer would bake the builder's empty environment into
+ * every store shipped from that image.
+ *
+ * The title is the STORE's name, so a merchant who scaffolds a page and writes
+ * no metadata gets their own store in the browser tab. Route-specific claims
+ * live on the routes; this is only the floor, and it deliberately carries no
+ * canonical (it does not know which route it is wrapping).
+ *
+ * The site-verification placements (#1530) are read on the same request cache
+ * and handed to the SAME composer, so `lib/seo/metadata.ts` stays the only
+ * thing in this template that turns a placement into a `<meta>`. They ride the
+ * FLOOR rather than a route, because the verifier chooses which page it fetches
+ * and a tag on only some of them is a verification that works until it does not.
+ *
+ * It also carries the DEV-ONLY revision stamp (#847), written where the page is
+ * RENDERED: the browser beacon reads it back at throw time, so a promote landing
+ * between serve and throw cannot make the report blame the new revision for the
+ * old one's crash. Dev-gated by the literal `NODE_ENV` check, so a production
+ * build eliminates the resolution and a deployed storefront leaks no revision.
+ * Unresolvable is a NORMAL answer and means no tag.
+ */
+export async function generateMetadata(): Promise<Metadata> {
+  const { shopName, channelResolved } = await getRequestLocale();
+  const siteVerifications = await getSiteVerifications();
+  const shell = shellMetadata({ shopName, channelResolved, siteVerifications });
+  if (process.env.NODE_ENV !== 'development') return shell;
+  const revision = resolveLiveRevision();
+  if (revision === null) return shell;
+  // MERGED into the shell's `other`, never written over it: that key carries the
+  // site-verification placements (#1530), and a storefront pod serves through
+  // `npm run dev`, so an overwrite here would strip the provider's tag from
+  // every page its verifier can fetch.
+  return { ...shell, other: { ...shell.other, [FORGE_REVISION_META]: revision } };
+}
+
+/**
+ * The root layout of a blank storefront (#3480) — the platform's shell with no
+ * example storefront on it: no header, no footer navigation and no cart. What a
+ * blank workspace builds on is all here: the document language, the locale
+ * contract, the metadata floor above and the invisible client plumbing.
+ *
+ * DYNAMIC on every route, by design (D8). It reads the request locale to write
+ * `<html lang>`, and `lang` is an attribute on the document root: structurally
+ * outside every Suspense boundary, so it cannot come from a streamed hole.
+ * `next.config.js` carries the reasoning — Cache Components is off because the
+ * escape hatch it would force (a `<Suspense>` above `<body>`) is exactly what
+ * makes the two throws below unable to set a status.
+ *
+ * Those throws are the locale contract's teeth. Raised HERE, in the shell,
+ * they reach the one place Next assigns a status: `permanentRedirect` gives a
+ * real 308 with a `Location`, and `notFound` a real 404. Raised from inside
+ * any boundary they would resolve as client-rendered content instead, and the
+ * response would be a 200 carrying a 404 page — a soft-404, which a crawler
+ * indexes rather than drops.
+ */
+export default async function RootLayout({ children }: { children: ReactNode }) {
+  const { decision, binding } = await getRequestLocale();
+  if (decision.kind === 'redirect') permanentRedirect(decision.to);
+  if (decision.kind === 'notFound') notFound();
+
+  return (
+    <html lang={binding.locale}>
+      <body className="min-h-screen bg-base-200 text-base-content antialiased">
+        <main className="mx-auto max-w-6xl px-4 py-10">{children}</main>
+        {/* Invisible client plumbing. The tracker reads usePathname(), which
+            needs a boundary of its own — null fallback, these render nothing.
+            This must stay INSIDE <body>: a boundary above it would make the
+            shell resumable and cost the statuses above. */}
+        <Suspense fallback={null}>
+          <ForgecartDesigner />
+          <ForgeErrorBeacon />
+          <ForgeTracker
+            enabled={Boolean(
+              process.env.FORGECART_SHOP_API_URL && process.env.FORGECART_CHANNEL_TOKEN,
+            )}
+          />
+        </Suspense>
+      </body>
+    </html>
+  );
+}

package/templates/storefront-blank/src/app/page.tsx

@@ -0,0 +1,52 @@
+import type { Metadata } from 'next';
+
+import { getRequestLocale } from '../lib/locale/request-binding';
+import { staticPathsByLocale } from '../lib/seo/alternates';
+import { pageTitle, routeMetadata } from '../lib/seo/metadata';
+import type { RouteSearchParams } from '../lib/seo/noindex';
+
+/**
+ * The landing surface is indexable — unless the URL carries query state (an
+ * experiment pin, a preview) that makes it a VIEW of the page competing with
+ * the page's own address.
+ *
+ * `title: null` because the store's landing page has no name of its own: it IS
+ * the store, so it takes the shop name alone rather than composing something
+ * like `Home | Acme`. The description is the shell's, inherited by omission.
+ */
+export async function generateMetadata({
+  searchParams,
+}: {
+  searchParams: Promise<RouteSearchParams>;
+}): Promise<Metadata> {
+  const [resolvedSearchParams, { binding, languageCodes, shopName, channelResolved }] =
+    await Promise.all([searchParams, getRequestLocale()]);
+  return routeMetadata({
+    binding,
+    shopName,
+    channelResolved,
+    // The canonical is built from the BASE path, so `/?fc-exp=hero:b` declares
+    // `/` as its address — the query-state copy points at the page it is a view
+    // of, which is the whole reason those URLs are noindex rather than ignored.
+    pathname: '/',
+    pathsByLocale: staticPathsByLocale(languageCodes, '/'),
+    searchParams: resolvedSearchParams,
+    title: null,
+  });
+}
+
+/**
+ * Home — the blank storefront's one page (#3480): the store's name as its one
+ * heading, and nothing else. No example content to delete: everything the
+ * merchant builds starts here, on the shell's platform plumbing. The heading
+ * reads the name the document title carries, so a channel that has not named
+ * its store still renders one.
+ */
+export default async function HomePage() {
+  const { shopName } = await getRequestLocale();
+  return (
+    <h1 className="text-4xl font-bold tracking-tight text-balance">
+      {pageTitle(null, shopName)}
+    </h1>
+  );
+}

package/templates/storefront-blank/src/app/pages/[slug]/not-found.tsx

@@ -0,0 +1,23 @@
+import { LocaleLink } from '../../../components/LocaleLink';
+import { getRequestLocale } from '../../../lib/locale/request-binding';
+
+/**
+ * What a visitor sees at a page URL that holds nothing: an unknown route, or a
+ * page whose content is not published (or not published YET). The copy does not
+ * distinguish them on purpose — "this is scheduled for Tuesday" is the
+ * merchant's information, not the public's.
+ */
+export default async function AcfPageNotFound() {
+  const { binding } = await getRequestLocale();
+  return (
+    <div className="space-y-4">
+      <h1 className="text-2xl font-bold tracking-tight text-base-content">Page not found</h1>
+      <p className="text-base-content/60">
+        We couldn&apos;t find that page. It may have been moved or taken down.
+      </p>
+      <LocaleLink href="/" locale={binding} className="btn btn-primary">
+        Back to the shop
+      </LocaleLink>
+    </div>
+  );
+}

package/templates/storefront-blank/src/app/pages/[slug]/page.tsx

@@ -0,0 +1,115 @@
+import type { Metadata } from 'next';
+import { notFound } from 'next/navigation';
+import { cache } from 'react';
+
+import { pageContentClaims } from '../../../lib/content/page-metadata';
+import { PageFields } from '../../../lib/content/render-fields';
+import { resolvePage } from '../../../lib/content/resolve-page';
+import {
+  getPageByRoute,
+  getPageEntries,
+  type PageEntry,
+  type PageGroup,
+} from '../../../lib/forgecart';
+import { getRequestLocale } from '../../../lib/locale/request-binding';
+import { routeMetadata } from '../../../lib/seo/metadata';
+import type { RouteSearchParams } from '../../../lib/seo/noindex';
+import { PAGE_ROUTE_PREFIX } from '../../../lib/seo/sitemap-entries';
+
+/**
+ * The merchant's own pages (#1934, epic launch#50), served at the route the
+ * shop API minted for the page definition.
+ *
+ * Locale-prefixed addresses land here too and cost nothing: the route tree is
+ * FLAT by law (#1041) and the middleware rewrites `/de/pages/x` onto this same
+ * file with the locale carried on a request header, so `/pages/x` and every
+ * `/<xx>/pages/x` are one route with one decision.
+ *
+ * FORCE-DYNAMIC, explicitly. "An unpublished page answers 404 on the NEXT
+ * request" is this feature's contract, and a contract must not rest on the
+ * incidental fact that some module downstream happens to read `headers()`. No
+ * `revalidate`, no `use cache`: a window here would serve a page the merchant
+ * has already taken down, which is the one failure this route may not have.
+ */
+export const dynamic = 'force-dynamic';
+
+/**
+ * The page's definition AND its visible record, read once per request.
+ *
+ * Both halves together, because the 404 decision needs both and Next invokes
+ * `generateMetadata` and the page as separate calls — without React's request
+ * cache the two would resolve independently, and a page unpublished between
+ * them would emit indexable metadata for a URL that then 404s.
+ *
+ * The entries read is skipped when nothing is mounted at the route: there is no
+ * definition code to ask about, and the resolution's answer is already settled.
+ */
+const pageForRequest = cache(
+  async (route: string): Promise<{ group: PageGroup | null; entries: PageEntry[] }> => {
+    const group = await getPageByRoute(route);
+    if (group === null) return { group: null, entries: [] };
+    return { group, entries: await getPageEntries(group.code) };
+  },
+);
+
+/**
+ * A page's metadata comes from the same resolution the route acts on, so the
+ * head and the status can never disagree about what this URL is.
+ *
+ * Its CONTENT claims — title, description, social card, alternates and
+ * indexability — are the record's per-language SEO sidecar (#1375), decided in
+ * `lib/content/page-metadata.ts` by the rules the product route uses: the
+ * definition's `seoSources` mapping and the merchant's stored overrides arrive
+ * already resolved into each language, and a language with no copy of its own
+ * renders as a fallback that claims nothing (noindex, no canonical, never an
+ * hreflang alternate). This file only dispatches.
+ */
+export async function generateMetadata({
+  params,
+  searchParams,
+}: {
+  params: Promise<{ slug: string }>;
+  searchParams: Promise<RouteSearchParams>;
+}): Promise<Metadata> {
+  const [{ slug }, resolvedSearchParams, { binding, languageCodes, shopName, channelResolved }] =
+    await Promise.all([params, searchParams, getRequestLocale()]);
+  const { group, entries } = await pageForRequest(slug);
+  const resolution = resolvePage({ requestedRoute: slug, group, entries });
+  const pathname = `${PAGE_ROUTE_PREFIX}/${slug}`;
+
+  return routeMetadata({
+    binding,
+    shopName,
+    channelResolved,
+    pathname,
+    searchParams: resolvedSearchParams,
+    ...pageContentClaims(resolution, { locale: binding.locale, languageCodes, pathname }),
+  });
+}
+
+/**
+ * The resolution runs in the page SHELL, above any boundary, and that placement
+ * is the whole correctness of this route's status codes: `notFound()` can only
+ * set a status where Next assigns one, and raised from inside a Suspense
+ * boundary the shell has already flushed a 200 — a crawler then INDEXES the
+ * not-found page instead of dropping it (the same law `products/[slug]`
+ * carries, measured there).
+ *
+ * There is no boundary at all here, and that follows from the same fact: the
+ * two reads ARE this page, so streaming a skeleton would buy nothing while the
+ * only content loaded.
+ */
+export default async function AcfPage({ params }: { params: Promise<{ slug: string }> }) {
+  const { slug } = await params;
+  const { group, entries } = await pageForRequest(slug);
+  const resolution = resolvePage({ requestedRoute: slug, group, entries });
+
+  if (resolution.kind === 'notFound') notFound();
+
+  return (
+    <article className="space-y-8">
+      <h1 className="text-3xl font-bold tracking-tight text-balance">{resolution.group.name}</h1>
+      <PageFields definitions={resolution.group.fieldDefinitions} entry={resolution.entry} />
+    </article>
+  );
+}

package/templates/storefront-blank/src/app/ping/route.ts

@@ -0,0 +1,21 @@
+/**
+ * Liveness ping for the in-pod dev-server readiness probe.
+ *
+ * Returns a static 200 with no layout, data fetch, or session. The workspace's
+ * readiness probe hits THIS route (not `/`) on a fast cadence while the store is
+ * STARTING and then a slow liveness cadence forever — and `/` renders the
+ * cart-aware layout, whose `activeOrder` call MATERIALISES an active order on every
+ * request. Probing `/` therefore minted a throwaway order on every poll; probing a
+ * route handler renders nothing and touches no session, so readiness polling stays
+ * side-effect-free.
+ *
+ * Request access keeps it out of any static prerender so a production build serves
+ * it on demand exactly like `next dev` does — the probe always gets a fresh 200.
+ */
+
+export function GET(): Response {
+  return new Response('ok', {
+    status: 200,
+    headers: { 'content-type': 'text/plain' },
+  });
+}

package/templates/storefront-blank/src/app/robots.ts

@@ -0,0 +1,69 @@
+import type { MetadataRoute } from 'next';
+
+import { NOINDEX_PATHS, NOINDEX_QUERY_KEYS } from '../lib/seo/noindex';
+import { getPublicOrigin } from '../lib/seo/public-origin';
+
+/**
+ * `robots.txt` (#1347, epic launch#54 W1-9) — the crawler-facing half of the
+ * indexability contract in `lib/seo/noindex.ts`.
+ *
+ * FORCE-DYNAMIC, and that is load-bearing rather than cautious. Next
+ * pre-renders metadata routes at build time by default, and a storefront is
+ * built once then run with its per-channel environment supplied afterwards. A
+ * build-time answer would freeze the BUILDER's environment — which never has a
+ * channel's public origin — into `Disallow: /` for every store shipped from
+ * that image, permanently, with no way to correct it short of a rebuild. The
+ * scaffold is frozen at provisioning time (#1041), so "permanently" is literal.
+ */
+export const dynamic = 'force-dynamic';
+
+/**
+ * Infrastructure routes that are never a destination for a human or a crawler:
+ * the tracking relay, the error beacon, the SDK proxy and the health probe.
+ *
+ * Deliberately NOT derived from the locale grammar's `UNPREFIXED_FIRST_SEGMENTS`
+ * despite the overlap. That set answers "which first segments are not a
+ * language?" and correctly contains `sitemap.xml`, `robots.txt`, `_next` and
+ * `favicon.ico` — every one of which a crawler MUST be allowed to fetch.
+ * Sharing one list would make the next infrastructure route silently
+ * uncrawlable, or a crawlable asset silently unprefixed.
+ */
+const INFRASTRUCTURE_DISALLOW: readonly string[] = [
+  '/api/',
+  '/__fc/',
+  '/__forge_beacon',
+  '/ping',
+];
+
+/**
+ * Without a public origin the storefront asserts nothing, so `robots.txt`
+ * refuses the whole tree. With one, it mirrors the noindex set — the page
+ * rules are DERIVED from `noindex.ts` rather than restated, because a
+ * `robots.txt` that disagrees with the pages' own `robots` metadata is the
+ * exact drift this module exists to prevent.
+ *
+ * The `Sitemap:` line rides the origin BRANCH, not merely the origin value: the
+ * URL it names has to be absolute, and the document it points at is empty
+ * without an origin. Announcing an empty sitemap is a claim about the catalog;
+ * announcing nothing is the absence of one, which is all a deployment that has
+ * not been told its own address is entitled to say.
+ */
+export default function robots(): MetadataRoute.Robots {
+  const publicOrigin = getPublicOrigin();
+  if (publicOrigin === null) {
+    return { rules: { userAgent: '*', disallow: '/' } };
+  }
+
+  return {
+    rules: {
+      userAgent: '*',
+      allow: '/',
+      disallow: [
+        ...NOINDEX_PATHS,
+        ...INFRASTRUCTURE_DISALLOW,
+        ...NOINDEX_QUERY_KEYS.map((key) => `/*?${key}=`),
+      ],
+    },
+    sitemap: `${publicOrigin}/sitemap.xml`,
+  };
+}