orionplace-react 0.6.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orionplace-react",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Next.js 16 storefront for your Orionplace marketplace: setup CLI, server API gateway, typed store and ready-made catalog, cart, checkout and account components in English and Russian, plus an Android app build.",
   "type": "module",
   "license": "MIT",

package/runtime/marketplace.d.mts

@@ -37,6 +37,18 @@ export declare function marketplacePublicOrigin(
   tenantDomain?: string,
 ): string;
 
+export declare function noindexPathPrefixes(value?: string): string[];
+
+export declare function marketplaceNoindexPath(
+  pathname: string,
+  value?: string,
+): boolean;
+
+export declare function sitemapIndexedPages(
+  pages: MarketplaceSitemapPage[],
+  value?: string,
+): MarketplaceSitemapPage[];
+
 export declare function marketplaceRobots(origin: string): string;
 
 export declare function marketplaceRobotsResponse(

package/runtime/marketplace.mjs

@@ -329,6 +329,7 @@ export async function forwardMarketplace(request, configuration = {}) {
 // node_modules/.cache/orionplace/sitemaps/<domain>.json (ORIONPLACE_CACHE_DIR
 // moves it). "orionplace-<framework> sitemap rebuild" rebuilds that file at
 // once; the running storefront serves the new file without a restart.
+// Paths in ORIONPLACE_NOINDEX_PATHS are left out when the sitemap is served.
 
 export const SITEMAP_LIFETIME = 60 * 60 * 1000;
 const sitemapPageSize = 100;
@@ -353,6 +354,34 @@ export function marketplacePublicOrigin(request, tenantDomain = '') {
   return local || !tenantDomain ? url.origin : `https://${tenantDomain}`;
 }
 
+/**
+ * Pages kept out of search engines: ORIONPLACE_NOINDEX_PATHS lists path
+ * prefixes separated by spaces or commas, for example "/catalog /category
+ * /product" on a demo or staging storefront. Those pages answer with
+ * `X-Robots-Tag: noindex, follow` and the sitemap leaves them out. Empty
+ * (the default) keeps every public page indexable.
+ */
+export function noindexPathPrefixes(value = environment.ORIONPLACE_NOINDEX_PATHS) {
+  return String(value ?? '')
+    .split(/[\s,]+/)
+    .map((item) => item.trim().replace(/\/+$/, ''))
+    .filter((item) => /^\/[A-Za-z0-9._~\/-]+$/.test(item));
+}
+
+/** Whether a page path is kept out of search engines (see noindexPathPrefixes). */
+export function marketplaceNoindexPath(pathname, value = environment.ORIONPLACE_NOINDEX_PATHS) {
+  const path = String(pathname ?? '');
+  return noindexPathPrefixes(value)
+    .some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
+}
+
+/** The sitemap pages search engines may index. */
+export function sitemapIndexedPages(pages, value = environment.ORIONPLACE_NOINDEX_PATHS) {
+  return noindexPathPrefixes(value).length
+    ? pages.filter((page) => !marketplaceNoindexPath(page.path, value))
+    : pages;
+}
+
 /** @param {string} origin */
 export function marketplaceRobots(origin) {
   return `User-agent: *\nDisallow: /api/\nAllow: /\n\nSitemap: ${origin}/sitemap.xml\n`;
@@ -618,7 +647,7 @@ async function buildMarketplaceSitemap(tenant) {
 /** How many <url> entries a built sitemap has. */
 export function sitemapUrlCount(sitemap) {
   let count = 0;
-  for (const page of sitemap.pages) {
+  for (const page of sitemapIndexedPages(sitemap.pages)) {
     const own = page.locales
       ? sitemap.locales.filter((code) => page.locales.includes(code))
       : sitemap.locales;
@@ -776,7 +805,7 @@ export async function marketplaceSitemapResponse(request, configuration = {}) {
     }
   }
   const origin  = marketplacePublicOrigin(request, tenant.domain);
-  return new Response(marketplaceSitemapXml(origin, sitemap.pages, sitemap.locales), {
+  return new Response(marketplaceSitemapXml(origin, sitemapIndexedPages(sitemap.pages), sitemap.locales), {
     headers: {
       'Content-Type': 'application/xml; charset=utf-8',
       'Cache-Control': 'public, max-age=3600',

package/src/project-readme.mjs

@@ -405,6 +405,12 @@ npx orionplace-react sitemap rebuild shop.example.com  # one domain
 npx orionplace-react sitemap status                  # when each was built
 \`\`\`
 
+To keep a demo or staging storefront's shop pages out of search engines, set
+\`ORIONPLACE_NOINDEX_PATHS\` in \`.env\` to path prefixes separated by spaces,
+for example \`ORIONPLACE_NOINDEX_PATHS="/catalog /category /product"\`. Those
+pages answer with \`X-Robots-Tag: noindex, follow\` and the sitemap leaves them
+out; the journal and other pages stay indexable. Leave it empty on a live shop.
+
 This setup does not add analytics.
 
 ## Android app

package/templates/app/_storefront/CategoryPage.tsx

@@ -4,7 +4,8 @@ import { StorefrontCategory } from '@/components/orionplace/categories/Storefron
 import { useOrionplaceStorefront } from '@/hooks/useOrionplaceStorefront';
 import { useOrionplaceCatalog } from '@/providers/OrionplaceProvider';
 import { catalogBranchIds } from '@/lib/orionplace/catalog';
-import type { ProductSearchPage } from '@/lib/orionplace/productSearch';
+import type { ProductListLocation } from '@/lib/orionplace/productListLocation';
+import type { ProductListPage } from '@/lib/orionplace/productSearch';
 import { useProductSearch } from './useProductSearch';
 import { useStorefrontNavigation } from './useStorefrontNavigation';
 
@@ -12,10 +13,12 @@ export function CategoryPage({
   categoryId,
   initial,
   initialError = '',
+  location,
 }: {
   categoryId: number;
-  initial?: ProductSearchPage;
+  initial?: ProductListPage;
   initialError?: string;
+  location?: ProductListLocation;
 }) {
   const navigation = useStorefrontNavigation();
   const controls   = useOrionplaceStorefront();
@@ -24,6 +27,7 @@ export function CategoryPage({
     { categoryId, categoryIds: catalogBranchIds(catalog, categoryId) },
     initial,
     initialError,
+    { location },
   );
   const pagination = search.data?.products?.rpag;
 

package/templates/app/_storefront/SearchPage.tsx

@@ -15,10 +15,11 @@ import { OrionplaceEmptyState } from '@/components/orionplace/shared/OrionplaceE
 import { useOrionplaceStorefront } from '@/hooks/useOrionplaceStorefront';
 import { browseLabels } from '@/lib/orionplace/browseLabels';
 import { featuredLabels } from '@/lib/orionplace/featuredLabels';
+import type { ProductListLocation } from '@/lib/orionplace/productListLocation';
 import {
   productSearchHeading,
   productSearchTrail,
-  type ProductSearchPage as ProductSearchData,
+  type ProductListPage as ProductSearchData,
   type ProductSearchScope,
 } from '@/lib/orionplace/productSearch';
 import { useProductSearch } from './useProductSearch';
@@ -41,10 +42,12 @@ export function SearchPage({
   scope,
   initial,
   initialError = '',
+  location,
 }: {
   scope: ProductSearchScope;
   initial?: ProductSearchData;
   initialError?: string;
+  location?: ProductListLocation;
 }) {
   const locale     = useOrionplaceSelections((state) => state.localeCode);
   const labels     = browseLabels(locale);
@@ -55,7 +58,9 @@ export function SearchPage({
   const guest      = Boolean(scope.featured && ready && !init?.is_authenticated);
   const navigation = useStorefrontNavigation();
   const controls   = useOrionplaceStorefront();
-  const search     = useProductSearch(scope, initial, initialError);
+  const search     = useProductSearch(scope, initial, initialError, {
+    location,
+  });
   const pagination = search.data?.products?.rpag;
   const api = useOrionplaceApi();
   const directory = directoryLabels(locale);

package/templates/app/_storefront/SellersPage.tsx

@@ -12,7 +12,8 @@ import { useOrionplaceApi } from '@/hooks/useOrionplaceApi';
 import { useOrionplaceReviews } from '@/hooks/useOrionplaceReviews';
 import { useOrionplaceStorefront } from '@/hooks/useOrionplaceStorefront';
 import { directoryLabels } from '@/lib/orionplace/directoryLabels';
-import type { ProductSearchPage } from '@/lib/orionplace/productSearch';
+import type { ProductListLocation } from '@/lib/orionplace/productListLocation';
+import type { ProductListPage } from '@/lib/orionplace/productSearch';
 import { useOrionplaceSelections } from '@/providers/OrionplaceProvider';
 import { useProductSearch } from './useProductSearch';
 import { useStorefrontNavigation } from './useStorefrontNavigation';
@@ -25,11 +26,13 @@ export function SellersPage({
   initial,
   initialProducts,
   initialError = '',
+  location,
 }: {
   sellerId?: number;
   initial?: SellerPageData;
-  initialProducts?: ProductSearchPage;
+  initialProducts?: ProductListPage;
   initialError?: string;
+  location?: ProductListLocation;
 }) {
   const api = useOrionplaceApi();
   const locale = useOrionplaceSelections((state) => state.localeCode);
@@ -38,6 +41,7 @@ export function SellersPage({
   const labels = directoryLabels(locale);
   const search = useProductSearch({ sellerId }, initialProducts, '', {
     scrollToTop: false,
+    location,
   });
   const reviews = useOrionplaceReviews({
     sellerId,
@@ -112,7 +116,9 @@ export function SellersPage({
               products={search.data?.products?.data ?? []}
               facets={search.facets}
               filters={search.filters}
-              fixedFilters={['product_owner']}
+              // The seller scope fixes the seller and its rating, as in the
+              // Nuxt and Svelte packages.
+              fixedFilters={['product_owner', 'owner_rating_from']}
               page={search.page}
               pages={pagination?.pages}
               total={total}

package/templates/app/_storefront/storefrontRoutes.tsx

@@ -67,10 +67,11 @@ import {
   type ManufacturerSearchData,
 } from '@/lib/orionplace/manufacturerDirectory';
 import {
-  loadProductSearch,
-  type ProductSearchPage,
+  loadProductListPage,
+  type ProductListPage,
   type ProductSearchScope,
 } from '@/lib/orionplace/productSearch';
+import { productListLocationFromQuery } from '@/lib/orionplace/productListLocation';
 import {
   emptySellerFilters,
   sellerDirectoryRequest,
@@ -212,8 +213,11 @@ const routes: Record<string, Loader> = {
       !scope.query ||
       scope.query.length >= 3 ||
       Object.values(scope).some((value) => typeof value === 'number');
+    const location                  = productListLocationFromQuery(query);
     const { initial, initialError } = searched
-      ? await initialData(context, (api) => loadProductSearch(api, scope))
+      ? await initialData(context, (api) =>
+          loadProductListPage(api, scope, location.filters, location.page),
+        )
       : { initial: undefined, initialError: '' };
     return {
       page: (
@@ -221,6 +225,7 @@ const routes: Record<string, Loader> = {
           scope={scope}
           initial={initial}
           initialError={initialError}
+          location={location}
         />
       ),
     };
@@ -254,11 +259,17 @@ const routes: Record<string, Loader> = {
     if (!categoryId || !findCatalogCategory(catalog, categoryId)) {
       return { notFound: true };
     }
+    const location                  = productListLocationFromQuery(context.query);
     const { initial, initialError } = await initialData(context, (api) =>
-      loadProductSearch(api, {
-        categoryId,
-        categoryIds: catalogBranchIds(catalog, categoryId),
-      }),
+      loadProductListPage(
+        api,
+        {
+          categoryId,
+          categoryIds: catalogBranchIds(catalog, categoryId),
+        },
+        location.filters,
+        location.page,
+      ),
     );
     return {
       page: (
@@ -266,6 +277,7 @@ const routes: Record<string, Loader> = {
           categoryId={categoryId}
           initial={initial}
           initialError={initialError}
+          location={location}
         />
       ),
     };
@@ -275,8 +287,9 @@ const routes: Record<string, Loader> = {
 
   '/featured': async (context) => {
     const scope                     = { featured: true } as const;
+    const location                  = productListLocationFromQuery(context.query);
     const { initial, initialError } = await initialData(context, (api) =>
-      loadProductSearch(api, scope),
+      loadProductListPage(api, scope, location.filters, location.page),
     );
     return {
       page: (
@@ -284,6 +297,7 @@ const routes: Record<string, Loader> = {
           scope={scope}
           initial={initial}
           initialError={initialError}
+          location={location}
         />
       ),
     };
@@ -487,8 +501,9 @@ const routes: Record<string, Loader> = {
       return { redirect: `/catalog?locale=${encodeURIComponent(text(query.locale))}` };
     }
     const sellerId  = positive(text(query.seller) || undefined);
+    const location  = productListLocationFromQuery(query);
     let initial;
-    let initialProducts: ProductSearchPage | undefined;
+    let initialProducts: ProductListPage | undefined;
     let initialError = '';
     try {
       const api = await context.api();
@@ -499,7 +514,12 @@ const routes: Record<string, Loader> = {
           : sellerDirectoryRequest(emptySellerFilters(), 1),
       );
       if (sellerId && initial.sellers.data[0]) {
-        initialProducts = await loadProductSearch(api, { sellerId }, {}, 1);
+        initialProducts = await loadProductListPage(
+          api,
+          { sellerId },
+          location.filters,
+          location.page,
+        );
       }
     } catch (reason) {
       initialError = await context.errorText(reason);
@@ -511,6 +531,7 @@ const routes: Record<string, Loader> = {
           initial={initial}
           initialProducts={initialProducts}
           initialError={initialError}
+          location={location}
         />
       ),
     };

package/templates/app/_storefront/useProductSearch.ts

@@ -9,14 +9,19 @@ import {
 import type { ProductFacetSelection } from '@/interfaces/orionplace/products/IProductSearchFacets';
 import { useOrionplaceApi } from '@/hooks/useOrionplaceApi';
 import {
-  loadProductSearch,
-  productSearchFacetData,
-  type ProductSearchPage,
+  loadProductListPage,
+  productListFacetData,
+  type ProductListPage,
   type ProductSearchScope,
 } from '@/lib/orionplace/productSearch';
-import { initialSearchFacets } from '@/lib/orionplace/searchFilters';
 import { apiErrorMessage } from '@/lib/orionplace/api';
 import { featureLabels } from '@/lib/orionplace/featureLabels';
+import {
+  productListLocationFromQuery,
+  productListLocationQuery,
+  sameProductListLocation,
+  type ProductListLocation,
+} from '@/lib/orionplace/productListLocation';
 
 /*
  * A search needs a category, a fixed scope or a 3-letter query, as in the
@@ -30,35 +35,77 @@ function searchable(scope: ProductSearchScope) {
   );
 }
 
+const firstListPage: ProductListLocation = { page: 1, filters: {} };
+
+function listSignature(location: ProductListLocation) {
+  return JSON.stringify(productListLocationQuery({}, location));
+}
+
+function addressQuery(): Record<string, string> {
+  return Object.fromEntries(new URL(window.location.href).searchParams);
+}
+
 /*
  * `scrollToTop: false` keeps the scroll position on a page turn, for a page
  * whose pagination scrolls to its own list (the seller page).
+ * `location` is the page and filters `initial` was loaded with (the URL of the
+ * server render). The page and filters stay in the URL, so Back from a
+ * product or a reload opens the list the visitor left; `rememberInAddress:
+ * false` keeps them out of it.
  */
 export function useProductSearch(
   scope: ProductSearchScope,
-  initial?: ProductSearchPage,
+  initial?: ProductListPage,
   initialError = '',
-  options: { scrollToTop?: boolean } = {},
+  options: {
+    scrollToTop?: boolean;
+    location?: ProductListLocation;
+    rememberInAddress?: boolean;
+  } = {},
 ) {
+  const remember              = options.rememberInAddress !== false;
+  const serverLocation        = remember
+    ? (options.location ?? firstListPage)
+    : firstListPage;
+  // The page and filters in the URL; the server render reads them from the
+  // request, the browser from the address bar.
+  function addressLocation(): ProductListLocation {
+    if (!remember) {
+      return firstListPage;
+    }
+    return typeof window === 'undefined'
+      ? serverLocation
+      : productListLocationFromQuery(addressQuery());
+  }
+  // `initial` belongs to the URL it was loaded for.
+  function fromServer(location: ProductListLocation) {
+    return listSignature(location) === listSignature(serverLocation);
+  }
+  const [opening]             = useState(addressLocation);
+  const openedFromServer      = fromServer(opening);
   const api                   = useOrionplaceApi();
   const locale                = useOrionplaceSelections(
     (state) => state.localeCode,
   );
   const productsStore         = useOrionplaceProductsStore();
   const browseStore           = useOrionplaceBrowseStore();
-  const [data, setData]       = useState(initial);
-  const [filters, setFilters] = useState<ProductFacetSelection>({});
-  const [page, setPage]       = useState(initial?.products?.rpag.page ?? 1);
+  const [data, setData]       = useState(openedFromServer ? initial : undefined);
+  const [filters, setFilters] = useState<ProductFacetSelection>(opening.filters);
+  const [page, setPage]       = useState(
+    openedFromServer ? (initial?.products?.rpag.page ?? opening.page) : opening.page,
+  );
   const [pending, setPending] = useState(false);
-  const [loaded, setLoaded]   = useState(Boolean(initial));
-  const [error, setError]     = useState(initialError);
+  const [loaded, setLoaded]   = useState(openedFromServer && Boolean(initial));
+  const [error, setError]     = useState(openedFromServer ? initialError : '');
   // Filter choices of the scope's first response; a filtered response must
   // not shrink them, so the visitor can still pick another seller or price.
-  const [facets, setFacets]   = useState(() => productSearchFacetData(initial));
+  const [facets, setFacets]   = useState(() =>
+    productListFacetData(openedFromServer ? initial : undefined),
+  );
   const request               = useRef<AbortController | undefined>(undefined);
   const signature             = JSON.stringify(scope);
 
-  function apply(next: ProductSearchPage) {
+  function apply(next: ProductListPage) {
     // The backend sends the unfiltered total with the first page only;
     // later pages keep it, as in the Nuxt and Svelte packages.
     setData((previous) =>
@@ -80,10 +127,10 @@ export function useProductSearch(
         : next,
     );
     setLoaded(true);
-    const incoming = productSearchFacetData(next);
+    const incoming = productListFacetData(next);
     if (incoming) {
       browseStore.getState().preserveSearchFacets(incoming);
-      setFacets((previous) => initialSearchFacets(previous, incoming));
+      setFacets((previous) => productListFacetData(next, previous));
     }
     for (const product of next.products?.data ?? []) {
       productsStore
@@ -92,19 +139,39 @@ export function useProductSearch(
     }
   }
 
+  // Replaces the URL, so Back from the list still leaves it in one step.
+  function rememberLocation(next: ProductListLocation) {
+    const query = addressQuery();
+    if (
+      !remember ||
+      sameProductListLocation(productListLocationFromQuery(query), next)
+    ) {
+      return;
+    }
+    const search = new URLSearchParams(productListLocationQuery(query, next));
+    window.history.replaceState(
+      null,
+      '',
+      `${window.location.pathname}?${search}${window.location.hash}`,
+    );
+  }
+
   async function load(nextPage = page, nextFilters = filters) {
+    rememberLocation({ page: nextPage, filters: nextFilters });
     request.current?.abort();
     const controller = new AbortController();
     request.current  = controller;
     setPending(true);
     setError('');
     try {
-      const next = await loadProductSearch(
+      const next = await loadProductListPage(
         api,
         scope,
         nextFilters,
         nextPage,
         controller.signal,
+        // Only a list without its filter choices yet needs the full ones.
+        !browseStore.getState().searchFacets,
       );
       if (!controller.signal.aborted) {
         setPage(nextPage);
@@ -122,18 +189,22 @@ export function useProductSearch(
     }
   }
 
+  // A new scope starts from the page and filters of its URL: none after a
+  // link, the ones the visitor left after Back or a reload.
   useEffect(() => {
+    const location = addressLocation();
+    const server   = fromServer(location) ? initial : undefined;
     browseStore.getState().setSearchQuery(scope.query ?? '');
-    browseStore.getState().setSearchFilters({});
-    browseStore.getState().setSearchFacets(productSearchFacetData(initial));
-    setFacets(productSearchFacetData(initial));
-    setData(initial);
-    setFilters({});
-    setPage(initial?.products?.rpag.page ?? 1);
-    setLoaded(Boolean(initial));
-    setError(initialError);
-    if (!initial && searchable(scope)) {
-      void load(1, {});
+    browseStore.getState().setSearchFilters(location.filters);
+    browseStore.getState().setSearchFacets(productListFacetData(server));
+    setFacets(productListFacetData(server));
+    setData(server);
+    setFilters(location.filters);
+    setPage(server?.products?.rpag.page ?? location.page);
+    setLoaded(Boolean(server));
+    setError(fromServer(location) ? initialError : '');
+    if (!server && searchable(scope)) {
+      void load(location.page, location.filters);
     }
     return () => request.current?.abort();
   }, [signature]);

package/templates/lib/orionplace/pageMetadata.ts

@@ -13,6 +13,8 @@ import type { ICategoryLocale } from '@/interfaces/orionplace/category/ICategory
 import type { IPromoDefinition } from '@/interfaces/orionplace/cart/ICartData';
 import { promoName } from '@/lib/orionplace/promoPresentation';
 import {
+  storefrontAbsoluteUrl,
+  storefrontCanonicalUrl,
   storefrontPageMetadata,
   type StorefrontSeoPage,
 } from '@/lib/orionplace/pageSeo';
@@ -111,6 +113,8 @@ export function storefrontMetadata(
   locale: string,
   url: URL,
   records: StorefrontPageRecords = {},
+  // The public origin (the proxy's host on the server, the page's own in the browser).
+  origin = url.origin,
 ) {
   const segments               = url.pathname.split('/').filter(Boolean);
   let page                     = records.pageKind ?? storefrontSeoPage(url.pathname);
@@ -125,7 +129,13 @@ export function storefrontMetadata(
   let image: string | undefined;
   const tags: MetaTags         = [];
   let robots: string | undefined;
-  if (privatePages.has(page) || page === 'notFound' || page === 'error') {
+  // A private product link (`key`) stays out of search results, loaded or not.
+  if (
+    privatePages.has(page) ||
+    page === 'notFound' ||
+    page === 'error' ||
+    (page === 'product' && url.searchParams.get('key'))
+  ) {
     robots = 'noindex, nofollow';
   } else if (page === 'browse') {
     robots = 'noindex, follow';
@@ -177,9 +187,6 @@ export function storefrontMetadata(
       field('meta_description') || field('short_description'),
     ).slice(0, 160);
     image              = product.images?.full?.[0] ?? product.images?.small?.[0];
-    if (url.searchParams.get('key')) {
-      robots = 'noindex, nofollow';
-    }
   } else if (page === 'publication' && records.post) {
     values.title       = getAvailableNestedValueFromObject(
       records.post.locale,
@@ -210,12 +217,24 @@ export function storefrontMetadata(
     values.title       = promoName(records.promo, locale);
   }
   const content                = storefrontPageMetadata(page, locale, values);
+  // Link previews load only complete image addresses; the canonical address
+  // is the sitemap's one for this page.
+  image                        = storefrontAbsoluteUrl(image, origin);
+  const canonical              = storefrontCanonicalUrl(
+    origin,
+    url.pathname,
+    url.search,
+    locale,
+    robots,
+  );
   const metadata: Metadata     = {
     ...content,
     ...(robots ? { robots } : {}),
+    ...(canonical ? { alternates: { canonical } } : {}),
     openGraph: {
       title: content.title,
       description: content.description,
+      ...(canonical ? { url: canonical } : {}),
       ...(image ? { images: [image] } : {}),
     },
   };
@@ -230,6 +249,7 @@ export function storefrontMetadata(
     'og:title': content.title,
     'og:description': content.description,
     'og:image': image,
+    'og:url': canonical,
   })) {
     headTags.set(name, {
       ...(name.startsWith('og:') ? { property: name } : { name }),

package/templates/lib/orionplace/pageSeo.ts

@@ -282,3 +282,71 @@ export function storefrontPageMetadata(
     keywords: plainText(values.keywords ?? '') || `${title}, ${copy[2]}`,
   };
 }
+
+/*
+ * Addresses for search engines and link previews. The public origin is the
+ * storefront host the visitor used (the proxy's Host or X-Forwarded-Host),
+ * over HTTPS; a local host keeps HTTP for development.
+ */
+export function storefrontPublicOrigin(host: string | null | undefined): string {
+  const name  = (host ?? '').split(',')[0]!.trim().toLowerCase();
+  if (!/^(?:[a-z0-9-]+(?:\.[a-z0-9-]+)*|\[[0-9a-f:]+\])(?::\d{1,5})?$/.test(name)) {
+    return '';
+  }
+  const local = /^(?:localhost|127(?:\.\d{1,3}){3}|\[::1\])(?::\d+)?$/.test(name);
+  return `${local ? 'http' : 'https'}://${name}`;
+}
+
+/**
+ * A complete address for a link preview image: a storefront path such as
+ * `/ps3/blog/posts/images/5` gets the public origin; without an origin it is
+ * left out, since a relative og:image is not loaded by link previews.
+ */
+export function storefrontAbsoluteUrl(
+  value: string | null | undefined,
+  origin: string,
+): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  try {
+    const url = origin ? new URL(value, `${origin}/`) : new URL(value);
+    return /^https?:$/.test(url.protocol) ? url.toString() : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// The pages the sitemap lists (runtime/marketplace.mjs), plus plan pages.
+const indexedPage = /^\/(?:|catalog|journal|tariffs|manufacturers|sellers|stores|contact|privacy|(?:category|product|journal)\/\d+|tariffs\/[^/]+\/\d+)$/;
+
+/**
+ * The canonical address of a page: the sitemap's address for it, the page in
+ * the language it shows (`?locale=`). Pages that are not listed, pages with
+ * other query parameters (filters, page numbers, private keys) and noindex
+ * pages get none.
+ */
+export function storefrontCanonicalUrl(
+  origin: string,
+  pathname: string,
+  search: string,
+  locale: string,
+  robots?: string,
+): string | undefined {
+  const path  = pathname.replace(/\/+$/, '') || '/';
+  const query = new URLSearchParams(search);
+  query.delete('locale');
+  if (
+    !origin ||
+    /noindex/i.test(robots ?? '') ||
+    !indexedPage.test(path) ||
+    [...query.keys()].length
+  ) {
+    return undefined;
+  }
+  const url   = new URL(path, `${origin}/`);
+  if (locale) {
+    url.searchParams.set('locale', locale);
+  }
+  return url.toString();
+}

package/templates/lib/orionplace/productListLocation.ts

@@ -0,0 +1,130 @@
+import type { ProductFacetSelection } from '@/interfaces/orionplace/products/IProductSearchFacets';
+
+// Where a product list is: its result page and the chosen filters. Category,
+// search, seller and featured lists keep it in the URL as `?page&filters`, so
+// a reload and the browser's Back button from a product return to the same
+// list. `filters` is the filter selection as JSON; the address is visitor
+// input, so only plain filter values within the limits below are read.
+export interface ProductListLocation {
+  page: number;
+  filters: ProductFacetSelection;
+}
+
+type QueryValue = string | null | undefined | readonly (string | null)[];
+
+const locationKeys    = ['page', 'filters'];
+const maxPage         = 10000;
+const maxFiltersText  = 4000;
+const maxFilterKeys   = 40;
+const maxFilterIds    = 200;
+const maxFilterString = 100;
+const filterKey       = /^[a-z][a-z0-9_]{0,63}$/;
+
+function first(value: QueryValue) {
+  return Array.isArray(value) ? value[0] : (value as string | null | undefined);
+}
+
+function filterValue(value: unknown): ProductFacetSelection[string] {
+  if (Array.isArray(value)) {
+    const ids = value.filter(
+      (id): id is number => Number.isSafeInteger(id) && id >= 0,
+    );
+
+    return ids.length === value.length && ids.length && ids.length <= maxFilterIds
+      ? ids
+      : undefined;
+  }
+  if (typeof value === 'string') {
+    return value && value.length <= maxFilterString ? value : undefined;
+  }
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : undefined;
+  }
+
+  // `false` chooses nothing, as an empty list or text.
+  return value === true ? true : undefined;
+}
+
+export function productListFiltersFromText(
+  text: string | null | undefined,
+): ProductFacetSelection {
+  if (!text || text.length > maxFiltersText) {
+    return {};
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return {};
+  }
+  const result: ProductFacetSelection = {};
+  for (const [key, value] of Object.entries(parsed).slice(0, maxFilterKeys)) {
+    const checked = filterKey.test(key) ? filterValue(value) : undefined;
+    if (checked !== undefined) {
+      result[key] = checked;
+    }
+  }
+
+  return result;
+}
+
+// The filters as URL text, or undefined when nothing is chosen.
+// Keys are sorted, so the same choice always gives the same text.
+export function productListFiltersText(filters: ProductFacetSelection) {
+  const chosen = productListFiltersFromText(JSON.stringify(filters));
+  const keys   = Object.keys(chosen).sort();
+
+  return keys.length
+    ? JSON.stringify(Object.fromEntries(keys.map((key) => [key, chosen[key]])))
+    : undefined;
+}
+
+export function productListLocationFromQuery(
+  query: Record<string, QueryValue>,
+): ProductListLocation {
+  const page = Number(first(query.page));
+
+  return {
+    page: Number.isSafeInteger(page) && page > 0 && page <= maxPage ? page : 1,
+    filters: productListFiltersFromText(first(query.filters)),
+  };
+}
+
+// Compares the URL form, so the same choice in another key order is equal.
+export function sameProductListLocation(
+  left: ProductListLocation,
+  right: ProductListLocation,
+) {
+  return (
+    left.page === right.page &&
+    productListFiltersText(left.filters) === productListFiltersText(right.filters)
+  );
+}
+
+// The query of `next`: other parameters such as `locale` or `q` stay, and the
+// first page without filters adds nothing.
+export function productListLocationQuery(
+  query: Record<string, QueryValue>,
+  next: ProductListLocation,
+) {
+  const result: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(query)) {
+    const text = first(value);
+    if (typeof text === 'string' && !locationKeys.includes(key)) {
+      result[key] = text;
+    }
+  }
+  if (next.page > 1) {
+    result.page = String(next.page);
+  }
+  const filters = productListFiltersText(next.filters);
+  if (filters) {
+    result.filters = filters;
+  }
+
+  return result;
+}

package/templates/lib/orionplace/productSearch.ts

@@ -7,6 +7,7 @@ import type {
   IProductSearchResponse,
 } from '@/interfaces/orionplace/products/IProductSearchApi';
 import type { OrionplaceApi } from '@/lib/orionplace/api';
+import { initialSearchFacets } from '@/lib/orionplace/searchFilters';
 
 export type ProductSearchPage = NonNullable<
   IProductSearchResponse['page_data']
@@ -230,3 +231,50 @@ export async function loadProductSearch(
     signal,
   );
 }
+
+/**
+ * A result page with `fullFacets`: the filter choices of the unfiltered
+ * first page, when the page was a later one or loaded with filters.
+ */
+export type ProductListPage = ProductSearchPage & {
+  fullFacets?: IProductSearchFacets | null;
+};
+
+/**
+ * A list opened from its URL (Back, a reload) on a later page or with
+ * filters gets only the filtered choices, or none after the first page.
+ * With `withFullFacets` this also asks for the unfiltered first page, so the
+ * filter panel keeps every seller, price and option to choose from. The
+ * extra request is only for the panel: when it fails the panel shows the
+ * choices of the result.
+ */
+export async function loadProductListPage(
+  api: OrionplaceApi,
+  scope: ProductSearchScope,
+  filters: ProductFacetSelection = {},
+  page = 1,
+  signal?: AbortSignal,
+  withFullFacets = true,
+): Promise<ProductListPage> {
+  // Both requests run together.
+  const [data, full] = await Promise.all([
+    loadProductSearch(api, scope, filters, page, signal),
+    withFullFacets && (page > 1 || Object.keys(filters).length > 0)
+      ? loadProductSearch(api, scope, {}, 1, signal).catch(() => undefined)
+      : undefined,
+  ]);
+
+  return full ? { ...data, fullFacets: productSearchFacetData(full) } : data;
+}
+
+/** The filter choices of a list page: the full ones first, as kept by the store. */
+export function productListFacetData(
+  page: ProductListPage | undefined,
+  previous: IProductSearchFacets | null = null,
+) {
+  return [page?.fullFacets ?? null, productSearchFacetData(page)].reduce(
+    (current, incoming) =>
+      incoming ? initialSearchFacets(current, incoming) : current,
+    previous,
+  );
+}

package/templates/lib/orionplace/serverMetadata.ts

@@ -1,4 +1,6 @@
 import { cache } from 'react';
+import { headers } from 'next/headers';
+import { storefrontPublicOrigin } from '@/lib/orionplace/pageSeo';
 import { getOrionplaceAppLoad } from '@/lib/orionplace/appLoadServer';
 import {
   getOrionplaceServerLocale,
@@ -73,11 +75,16 @@ export const getStorefrontMetadataContext = cache(async () => {
   } catch {
     // The page retains its request error and offers Retry.
   }
+  const incoming                                 = await headers();
   return storefrontMetadata(
     result?.response.page_data.init ?? null,
     locale,
     url,
     { product, post, tariff, promo, pageKind },
+    // The address the visitor used: the proxy's host.
+    storefrontPublicOrigin(
+      incoming.get('x-forwarded-host') ?? incoming.get('host'),
+    ),
   );
 });
 

package/templates/proxy.ts

@@ -1,4 +1,5 @@
 import { NextResponse, type NextRequest } from 'next/server';
+import { marketplaceNoindexPath } from '@orionplace-runtime/marketplace.mjs';
 import {
   APP_LOAD_HANDOFF_HEADER,
   startAppLoad,
@@ -47,6 +48,10 @@ export async function proxy(request: NextRequest) {
     ...(unavailable ? { status: 503 } : {}),
   });
   response.headers.set('Cache-Control', 'private, no-store');
+  // Pages under ORIONPLACE_NOINDEX_PATHS stay out of search engines.
+  if (marketplaceNoindexPath(request.nextUrl.pathname)) {
+    response.headers.set('X-Robots-Tag', 'noindex, follow');
+  }
   return response;
 }