@thorprovider/storefront 0.3.1 → 0.4.0-mvp.2

package/VENDOR.md

@@ -0,0 +1,69 @@
+# Vendored material and provenance
+
+`@thorprovider/storefront` ships exactly five **operative skills** — first-party,
+authored in this package: `storefront-workflow`, `sf-view-gen`, `sf-feature`,
+`sf-setup`, and `sf-theme-gen`. Everything else the suite needs is either retained
+generic knowledge, shipped as a **scoped reference** an operative skill loads by
+relative path, or retired and no longer shipped. This file records the origin and
+the adaptation of that retained material. The generator never reads
+machine-global skills at runtime; the copies below are the authority the suite
+resolves.
+
+## First-party operative skills (not vendored)
+
+| Skill | Path | Purpose |
+|---|---|---|
+| storefront-workflow | `skills/storefront-workflow/` | The four-phase model (bootstrap → compose → customize → verify) and the CLI/manifest authority |
+| sf-view-gen | `skills/sf-view-gen/` | Add/modify a view via the CLI; owns the retained json-render references |
+| sf-feature | `skills/sf-feature/` | Add/remove a feature bundle via the CLI |
+| sf-setup | `skills/sf-setup/` | Connect or re-point the Medusa backend via `storefront setup` |
+| sf-theme-gen | `skills/sf-theme-gen/` | Theme tokens, typography, identity; owns the retained theming references |
+
+## Retained references
+
+Useful generic knowledge is retained **only** as references inside the operative
+skill that owns the procedure. A reference is not an independently selectable
+skill (it is not a `SKILL.md`).
+
+| Retained reference | Owning skill | Upstream source | Refresh date | Adapted |
+|---|---|---|---|---|
+| `references/design-consistency.md` | `skills/storefront-workflow/` | `~/.config/opencode/skills/storefront-best-practices` | 2026-10-14 | Kept as a reference; UX/design-consistency guidance retained, raw Medusa SDK / React Query / direct-`/store` fetching removed |
+| `references/mobile-responsiveness.md` | `skills/storefront-workflow/` | `~/.config/opencode/skills/storefront-best-practices` | 2026-10-14 | Kept as a reference; responsive/mobile guidance retained, raw SDK fetching removed |
+| `references/seo.md` | `skills/storefront-workflow/` | `~/.config/opencode/skills/storefront-best-practices` | 2026-10-14 | Kept as a reference; SEO/accessibility guidance retained, entity-metadata policy preserved |
+| `references/shadcn-theming.md` | `skills/sf-theme-gen/` | `~/.config/opencode/skills/shadcn-theming` | 2026-10-14 | Unavailable tooling (`TeamCreate`, `fuse-ai-pilot`) and raw `shadcn init`/`shadcn add` scaffolding-and-discovery steps removed; OKLCH token/foreground-pair rules and the lightness rule kept |
+| `references/theme-setup.md` | `skills/sf-theme-gen/` | `~/.config/opencode/skills/shadcn-theming/references/templates` | 2026-10-14 | Kept as a reference; adapted to the generated storefront's external-file bounds |
+| `references/theming-guide.md` | `skills/sf-theme-gen/` | `~/.config/opencode/skills/shadcn-theming/references` | 2026-10-14 | Kept as a reference; adapted to the generated storefront's external-file bounds |
+| `references/json-render-core.md` | `skills/sf-view-gen/` | `~/.config/opencode/skills/json-render/core` | 2026-10-14 | Flattened from the standalone `json-render-core` skill to a reference; reachable only by relative path from `sf-view-gen` |
+| `references/json-render-react.md` | `skills/sf-view-gen/` | `~/.config/opencode/skills/json-render/react` | 2026-10-14 | Flattened from the standalone `json-render-react` skill to a reference; reachable only by relative path from `sf-view-gen` |
+| `references/json-render-next.md` | `skills/sf-view-gen/` | `~/.config/opencode/skills/json-render/next` | 2026-10-14 | Flattened from the standalone `json-render-next` skill to a reference; reachable only by relative path from `sf-view-gen` |
+| `references/json-render-shadcn.md` | `skills/sf-view-gen/` | `~/.config/opencode/skills/json-render/shadcn` | 2026-10-14 | Flattened from the standalone `json-render-shadcn` skill to a reference; reachable only by relative path from `sf-view-gen` |
+| `references/views.md` | `skills/sf-view-gen/` | Authored in this package | 2026-10-14 | First-party; documents the curated view set read from `storefront views --json` |
+
+## Retired
+
+These were previously bundled flat under `skills/` as standalone installable
+skills. They are no longer shipped as active skills or as retained reference
+material, and `storefront update` retires an installed copy that is verifiably
+unmodified.
+
+| Retired item | Upstream source | Last bundled | Why retired |
+|---|---|---|---|
+| `nextjs-shadcn` | `~/.config/opencode/skills/nextjs-shadcn` | 2026-09-28 | Broadly-triggering generic skill; `shadcn init`/`shadcn add` scaffolding contradicts the CLI-only generation rule |
+| `shadcn-component-discovery` | `~/.config/opencode/skills/shadcn-component-discovery` | 2026-09-28 | Broadly-triggering generic skill; UI is limited to `@thorprovider/blocks` |
+| `building-storefronts` | `~/.config/opencode/skills/building-storefronts` | 2026-09-28 | Broadly-triggering generic skill; pushes raw SDK / React Query fetching the storefront cannot use |
+| `json-render-solid` | `~/.config/opencode/skills/json-render/solid` | 2026-09-28 | Irrelevant renderer; the generated storefront renders React/Next only |
+| `json-render-remotion` | `~/.config/opencode/skills/json-render/remotion` | 2026-09-28 | Irrelevant renderer; video timelines are out of scope for a spec-based storefront |
+
+## Excluded
+
+Never bundled: the `json-render` `codegen`, `devtools`, `directives`, `image`, and
+`mcp` material. They are irrelevant to a generated storefront and are not shipped
+in any form.
+
+## Maintenance
+
+To refresh a retained reference: re-copy the upstream material to a reference
+file under the owning skill's `references/`, update the `Refresh date` above, and
+bump the package version. If a reference is retired, move it to the **Retired**
+table with its reason; `storefront update` retires a verifiably unmodified
+installed copy of it. See the package README maintenance note.

package/assets/openspec/config.yaml

@@ -0,0 +1,38 @@
+# Storefront OpenSpec configuration — seeded by @thorprovider/storefront.
+#
+# This file is storefront-owned: `storefront update` re-applies it after
+# re-running `openspec init`. Put customization in the storefront's own files,
+# not here.
+schema: spec-driven
+
+context: |
+  This project is a generated Thor Commerce storefront. A storefront is defined by
+  its manifest (storefront.config.json) and produced by the `storefront` CLI. The
+  CLI is the authority for every structural change — views, features, sections,
+  theme, and setup — and it is the only writer of derived files. Manual edits are
+  limited to user-owned files (view content/props/data/schema, mappers, icon-map,
+  shell) plus the bounded external surface of app/globals.css and app/layout.tsx,
+  and must preserve the CLI-managed imports and markers.
+  Determinism first: a change the CLI performs deterministically stays with the CLI.
+  A deterministic change the CLI records in storefront.config.json is trivial and
+  does not require an OpenSpec change; the manifest is its record. A change that
+  requires judgment — content authoring, prop/data mapping, composition reshaping,
+  or a cross-file redesign whose acceptance is not a CLI assertion — is non-trivial
+  and is driven through the spec-driven loop, surfaced to the user as the five
+  stages explore → plan → build → verify → inform, orchestrated by the agent
+  without asking the user to confirm each artifact. Keep any OpenSpec change
+  consistent with the storefront authorities: structural edits still go through
+  the CLI.
+
+rules:
+  proposal:
+    - "State the why, the observable storefront change, and the affected view(s) or feature(s); keep deferred scope explicit."
+    - "Do not restate this context or these rules in the artifact body."
+  specs:
+    - "New capabilities start with ## Purpose and ## ADDED Requirements; scenarios use exactly four hashtags (#### Scenario:) and every requirement has at least one."
+    - "Describe observable behavior, not implementation details."
+  design:
+    - "Record each decision with its why and the alternative considered; state how the change respects the CLI-as-authority and the user-owned surface."
+  tasks:
+    - "Group tasks by dependency; each task is a checkbox and states its own verification."
+    - "Never report the change complete until `storefront sync` and `storefront doctor` pass and the change's acceptance is met."

package/assets/templates/AGENTS.md

@@ -0,0 +1,76 @@
+# AGENTS.md — __SITE_NAME__ storefront
+
+This storefront was generated by `@thorprovider/storefront`. It is governed by a
+manifest (`storefront.config.json` at the project root) and produced by the
+`storefront` CLI. This file is managed: `storefront sync` regenerates it from the
+package template, and `storefront doctor` reports it as drift when edited by
+hand. Read it before changing anything.
+
+## RULE 0 — Non-negotiable
+
+1. **The `storefront` CLI is the authority.** Every structural change — adding or
+   removing a view or feature, composing sections, changing the theme mode,
+   connecting the backend — goes through `npx @thorprovider/storefront …`. Never
+   copy templates or scaffold structure by hand.
+2. **Derived files are CLI-only; never hand-edit them.** The CLI is the only
+   writer of derived files. If a change seems to need a capability the CLI does
+   not expose, first check the CLI subcommands and the `plan` → `apply`
+   operations envelope; if it is still missing, **STOP and report the gap** —
+   do not hand-edit a derived file. A hand edit is silently overwritten by the
+   next `sync`.
+3. **Hand-edit only user-owned files and the bounded external surface.** Manual
+   edits are limited to the declared user-owned files:
+   `lib/<name>/views/<view>/{schema,content,props,data}.ts`, `lib/<name>/mappers.ts`,
+   `lib/<name>/icon-map.ts`, and `lib/<name>/shell/**` — plus the bounded external
+   customization surface of `app/globals.css` and `app/layout.tsx`: theme design
+   tokens and their foreground pairs, font wiring, and global identity/metadata.
+   Prefer the deterministic `storefront theme` controls (colors, radius, fonts,
+   presets, imports) over hand edits; the bounded surface remains editable when a
+   value has no CLI control.
+   Editing the external files must preserve the CLI-managed wiring: the library
+   stylesheet import, the provider import and marker, the theme-mode marker, and
+   the block token contract. The CLI only appends that wiring idempotently, so a
+   restructure that removes it is drift, not a customization. Everything else is
+   derived (CLI-only).
+4. **Respect the architecture invariants.** UI components come only from
+   `@thorprovider/blocks`; data comes only from `@thorprovider/adapters` and
+   `@thorprovider/runtime/commerce` (never HTTP directly); routing stays the
+   catch-all `app/[[...slug]]/page.tsx`; `@thorprovider/medusa-extended` is not
+   used.
+5. **Verify after every change.** Run `npx @thorprovider/storefront sync`, then
+   `npx @thorprovider/storefront doctor`. `doctor` must report no drift; a build
+   (`yarn build`) is the final acceptance.
+6. **Drive non-trivial customization through the spec-driven loop.** A change
+   that needs judgment — content authoring, prop/data mapping, composition
+   reshaping, or a cross-file redesign whose acceptance is not a CLI assertion —
+   is **non-trivial**: drive it through the spec-driven loop and surface the five
+   stages to the user, **explore → plan → build → verify → inform**. A change the
+   CLI performs deterministically (theme mode, `view add|remove`,
+   `feature add|remove`, `setup`) is recorded in `storefront.config.json` and does
+   **not** require an OpenSpec change — the manifest is its record. Never ask the
+   user to run `openspec` or to approve individual artifacts.
+
+## Workflow model
+
+**bootstrap → compose → customize → verify.** The manifest
+(`storefront.config.json`) is the structural source of truth; the CLI is the only
+writer of derived files; the developer (or agent) edits only user-owned files and
+the bounded external surface of `app/globals.css` and `app/layout.tsx`.
+Customization that needs judgment runs through the spec-driven loop surfaced as
+explore → plan → build → verify → inform.
+See the `storefront-workflow` skill for the full model and the ownership classes.
+
+## Router — intent → skill → CLI
+
+The user states the intent in natural language; load the skill and delegate the
+write to the CLI. Never edit a derived file to achieve the intent.
+
+| Intent | Load skill | Delegate to CLI |
+|---|---|---|
+| Add or remove a view; compose a view's sections | `sf-view-gen` | `storefront views --json`, then `storefront view add\|remove …`; sections via `plan` → `apply` |
+| Customize the theme: colors, radius, fonts, presets; identity/SEO | `sf-theme-gen` | `storefront theme` — `--brand orange`, `--primary <color>`, `--accent <color>`, `--radius <length>`, `--font-sans google:Inter`, `--set light.primary=#f97316`, `--preset <ref>`, `--import <src>`, `--export <file>`, `--mode light\|dark\|system`. Visual values live in `app/globals.css`; the mode in `storefront.config.json`. Inspect with `storefront theme --inspect`. The bounded external surface stays editable by hand |
+| Add or remove a feature (e.g. `checkout`) | `sf-feature` | `storefront features --json`, then `storefront feature add\|remove …` |
+| Connect or re-point the Medusa backend; change region, sales channel, or publishable key | `sf-setup` | `storefront setup --backend-url … --publishable-key … --sales-channel-id … --region-id …` |
+| Edit a view's content/props/data; map props or data; reshape composition; any change whose acceptance is not a CLI assertion (non-trivial) | `storefront-workflow` | spec-driven loop surfaced as **explore → plan → build → verify → inform** — the agent drives it and never asks the user to confirm OpenSpec artifacts; structural edits still go through `storefront …`, verified with `storefront sync` then `storefront doctor` |
+
+The step-by-step procedures live in the skills, not in this file.

package/assets/templates/app/app/[[...slug]]/page.tsx

@@ -1,17 +1,69 @@
 // Generated by Thor Commerce storefront (template: assets/templates/app/app/[[...slug]]/page.tsx)
 
 import { notFound } from 'next/navigation'
+import { buildBreadcrumbListJsonLd, serializeJsonLd } from '@thorprovider/runtime/contracts'
 import { __STOREFRONT_CAMEL__App } from '@/lib/__STOREFRONT__/runtime'
+import { readCartStateForRender } from '@/lib/__STOREFRONT__/cart-state'
 import { StorefrontRenderer } from './renderer'
 
 export const { generateMetadata, generateStaticParams } = __STOREFRONT_CAMEL__App
 
 export default async function Page({
   params,
+  searchParams,
 }: {
   params: Promise<{ slug?: string[] }>
+  searchParams: Promise<Record<string, string | string[] | undefined>>
 }) {
-  const data = await __STOREFRONT_CAMEL__App.getPageData({ params })
+  // The raw URL search params are forwarded to the loader, which validates them
+  // through the canonical boundary before any commerce call (E2 task 5.1).
+  const data = await __STOREFRONT_CAMEL__App.getPageData({ params, searchParams })
   if (!data) return notFound()
-  return <StorefrontRenderer {...data} />
+
+  // Read the signed cookie and load the backend cart for the initial render.
+  // This never creates a cart; a guest identity is issued by a Server Action.
+  const cartState = await readCartStateForRender()
+  const initialState = { ...(data.initialState ?? {}), ...cartState }
+
+  // Entity structured data is server-rendered from the real loaded entity and
+  // sanitized so entity text cannot terminate the script element.
+  const jsonLd = data.entitySeo?.jsonLd
+  // The entity OpenGraph type (`product`/`CollectionPage`) is emitted here, not
+  // through Next metadata: Next validates `og:type` against the OpenGraph
+  // vocabulary and rejects those entity types, so a raw `property` tag is the
+  // only way to carry the entity type into the rendered `<head>`.
+  const ogType = data.entitySeo?.openGraph?.type
+  // The navigability feature's real trail is server-rendered as a sanitized
+  // `BreadcrumbList` alongside the entity structured data. It is built from the
+  // loader's own state, so it always matches the rendered breadcrumb.
+  const breadcrumbItems = (data.initialState as Record<string, unknown> | undefined)
+    ?.breadcrumbItems
+  const breadcrumbJsonLd = buildBreadcrumbListJsonLd(
+    Array.isArray(breadcrumbItems)
+      ? (breadcrumbItems as { label?: string; href?: string }[])
+      : undefined,
+  )
+
+  return (
+    <>
+      {ogType ? <meta property="og:type" content={ogType} /> : null}
+      {jsonLd ? (
+        <script
+          type="application/ld+json"
+          dangerouslySetInnerHTML={{ __html: serializeJsonLd(jsonLd) }}
+        />
+      ) : null}
+      {breadcrumbJsonLd ? (
+        <script
+          type="application/ld+json"
+          dangerouslySetInnerHTML={{ __html: serializeJsonLd(breadcrumbJsonLd) }}
+        />
+      ) : null}
+      <StorefrontRenderer
+        spec={data.spec}
+        layoutSpec={data.layoutSpec}
+        initialState={initialState}
+      />
+    </>
+  )
 }

package/assets/templates/app/app/[[...slug]]/renderer.tsx

@@ -2,9 +2,20 @@
 
 // Generated by Thor Commerce storefront (template: assets/templates/app/app/[[...slug]]/renderer.tsx)
 
+import { useRef } from 'react'
 import { PageRenderer } from '@json-render/next'
 import type { PageData } from '@json-render/next'
 
-export function StorefrontRenderer(data: PageData) {
-  return <PageRenderer {...data} />
+export function StorefrontRenderer({ initialState, ...data }: PageData) {
+  // The server recomputes `initialState` on every render, and a Server Action
+  // triggers an RSC refresh — so the prop is a fresh object each time even when
+  // its content is unchanged. `@json-render/react`'s StateProvider resets the
+  // client store whenever the `initialState` reference changes, which would wipe
+  // client-owned state (for example the account order history) after an action.
+  // Keep a STABLE reference while the serialized content is unchanged; a genuine
+  // server-side change (for example the cart) still propagates a new value.
+  const key = JSON.stringify(initialState ?? {})
+  const stable = useRef({ key, value: initialState })
+  if (stable.current.key !== key) stable.current = { key, value: initialState }
+  return <PageRenderer {...data} initialState={stable.current.value} />
 }

package/assets/templates/app/app/globals.css

@@ -28,10 +28,10 @@
   --color-border: var(--border);
   --color-input: var(--input);
   --color-ring: var(--ring);
-  --radius-sm: var(--radius-sm);
-  --radius-md: var(--radius-md);
-  --radius-lg: var(--radius-lg);
-  --radius-xl: var(--radius-xl);
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
   --font-sans: var(--font-geist-sans);
 }
 
@@ -59,10 +59,7 @@
   --border: oklch(0.88 0.003 90);
   --input: oklch(0.92 0.003 90);
   --ring: oklch(0.15 0 0);
-  --radius-sm: 0.25rem;
-  --radius-md: 0.375rem;
-  --radius-lg: 0.5rem;
-  --radius-xl: 0.75rem;
+  --radius: 0.5rem;
 }
 
 .dark {

package/assets/templates/app/app/layout.tsx

@@ -2,10 +2,10 @@
 
 import type { Metadata } from 'next'
 import { Geist } from 'next/font/google'
+import { ThemeProvider } from 'next-themes'
 import { StorefrontProvider } from '@thorprovider/runtime/host-glue/providers'
-import { themeVarsToCss, themeTokensToVars } from '@thorprovider/runtime/render-core/theme'
-import { DEFAULT_THEME_TOKENS } from '@thorprovider/runtime/contracts'
 import { registry } from '@/lib/__STOREFRONT__/registry'
+import { getSiteUrl } from '@/lib/__STOREFRONT__/store-context'
 import './globals.css'
 
 const geist = Geist({
@@ -13,22 +13,32 @@ const geist = Geist({
   subsets: ['latin'],
 })
 
-const themeCss = themeVarsToCss(themeTokensToVars(DEFAULT_THEME_TOKENS))
+// The canonical public origin is optional: when THOR_SITE_URL is unset no base
+// URL is invented. `metadataBase` is left undefined in that case.
+const siteUrl = getSiteUrl()
 
 export const metadata: Metadata = {
+  metadataBase: siteUrl ? new URL(siteUrl) : undefined,
   title: '__SITE_NAME__',
   description: 'Tienda online de __SITE_NAME__.',
+  openGraph: {
+    title: '__SITE_NAME__',
+    description: 'Tienda online de __SITE_NAME__.',
+    url: siteUrl,
+  },
 }
 
 export default function RootLayout({
   children,
 }: Readonly<{ children: React.ReactNode }>) {
   return (
-    <html lang="es" className={geist.variable}>
+    <html lang="es" className={geist.variable} suppressHydrationWarning>
       <body className="font-sans antialiased">
-        <StorefrontProvider themeCss={themeCss} registry={registry}>
-          {children}
-        </StorefrontProvider>
+        <ThemeProvider attribute="class" defaultTheme="__STOREFRONT_MODE__" enableSystem>
+          <StorefrontProvider registry={registry}>
+            {children}
+          </StorefrontProvider>
+        </ThemeProvider>
       </body>
     </html>
   )

package/assets/templates/app/app/robots.ts

@@ -0,0 +1,19 @@
+// Generated by Thor Commerce storefront (template: assets/templates/app/app/robots.ts)
+// Always served. Allows public pages, disallows private surfaces, and points at
+// the sitemap only when THOR_SITE_URL is configured.
+
+import type { MetadataRoute } from 'next'
+import { __STOREFRONT_CAMEL__Spec } from '@/lib/__STOREFRONT__/spec'
+import { robotsDisallowPaths, robotsSitemapUrl } from '@/lib/__STOREFRONT__/spec/seo'
+import { getSiteUrl } from '@/lib/__STOREFRONT__/store-context'
+
+export default function robots(): MetadataRoute.Robots {
+  return {
+    rules: {
+      userAgent: '*',
+      allow: '/',
+      disallow: robotsDisallowPaths(__STOREFRONT_CAMEL__Spec.routes ?? {}),
+    },
+    sitemap: robotsSitemapUrl(getSiteUrl()),
+  }
+}

package/assets/templates/app/app/sitemap.ts

@@ -0,0 +1,71 @@
+// Generated by Thor Commerce storefront (template: assets/templates/app/app/sitemap.ts)
+// Lists the fixed public routes plus every public catalog entity, enumerated
+// across adapter pagination with a bound and a cycle guard. Absolute URLs are
+// emitted only when THOR_SITE_URL is configured; otherwise the sitemap is empty
+// (no invented URL). An enumeration failure fails loudly (no partial sitemap).
+
+import type { MetadataRoute } from 'next'
+import { getCatalog, getCatalogResults } from '@thorprovider/runtime/commerce'
+import { __STOREFRONT_CAMEL__Spec } from '@/lib/__STOREFRONT__/spec'
+import {
+  buildSitemapEntries,
+  enumeratePublicEntities,
+  SitemapEnumerationError,
+  type PublicEntityPage,
+} from '@/lib/__STOREFRONT__/spec/seo'
+import { getSiteUrl } from '@/lib/__STOREFRONT__/store-context'
+
+const ENTITY_PAGE_SIZE = 100
+const MAX_PAGES = 100
+
+async function productPage(cursor: string | undefined): Promise<PublicEntityPage> {
+  const page = cursor ? Number(cursor) : 1
+  const outcome = await getCatalogResults({
+    page,
+    pageSize: ENTITY_PAGE_SIZE,
+    sort: 'name',
+  })
+  if (!outcome.ok) {
+    throw new SitemapEnumerationError({
+      kind: 'enumeration',
+      message: outcome.error.message,
+    })
+  }
+  const items = outcome.results.products.map((product) => ({
+    id: product.id,
+    path: `/products/${product.handle}`,
+  }))
+  const total = outcome.results.total
+  const hasMore =
+    typeof total === 'number' ? page * ENTITY_PAGE_SIZE < total : items.length >= ENTITY_PAGE_SIZE
+  return hasMore ? { items, nextCursor: String(page + 1) } : { items }
+}
+
+async function categoryPage(): Promise<PublicEntityPage> {
+  const catalog = await getCatalog()
+  return {
+    items: catalog.categoriesRaw.map((category) => ({
+      id: category.id,
+      path: `/categories/${category.handle}`,
+    })),
+  }
+}
+
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  const siteUrl = getSiteUrl()
+  if (!siteUrl) return []
+
+  const routes = __STOREFRONT_CAMEL__Spec.routes ?? {}
+  const [products, categories] = await Promise.all([
+    enumeratePublicEntities(productPage, { maxPages: MAX_PAGES }),
+    enumeratePublicEntities(categoryPage, { maxPages: MAX_PAGES }),
+  ])
+  if (!products.ok) throw new SitemapEnumerationError(products.failure)
+  if (!categories.ok) throw new SitemapEnumerationError(categories.failure)
+
+  return buildSitemapEntries({
+    routes,
+    siteUrl,
+    entities: [...products.entities, ...categories.entities],
+  })
+}