@asstio-dev/storefront 0.31.1 → 0.40.0-market.1

package/dist/seo/head.js

@@ -1,8 +1,11 @@
-import { alternateSet, collapse, headDescription, pickImages, productDescription, rejectRedirect, requireMarket } from "./shared.js";
+import { alternateSet, collapse, headDescription, pickImages, productDescription, rejectRedirect, requireBinding } from "./shared.js";
 const applyTemplate = (template, title) => (template === undefined ? title : template.replace("%s", () => title));
-/** Spec §6.4. Meta order is fixed; a tag whose value is null is left out. */
+/** Spec §6.4, market model §16.3. Meta order is fixed; a tag whose value is null is left out. The canonical is the page's own URL on
+ *  the request's binding (origin, base path and prefix included: the API built it); a secondary binding is `noindex,follow`. */
 function buildHead(ctx, input) {
-    const set = alternateSet(ctx.site, ctx.market, input.url, input.alternateUrls, ctx.xDefault);
+    const binding = requireBinding(ctx.site, ctx.binding);
+    const set = alternateSet(ctx.site, binding, input.alternates, ctx.xDefault);
+    const robots = binding.indexable ? null : "noindex,follow";
     const meta = [];
     const name = (n, content) => {
         if (content !== null)
@@ -13,6 +16,7 @@ function buildHead(ctx, input) {
             meta.push({ property: p, content });
     };
     const img = input.image;
+    name("robots", robots);
     name("description", input.description);
     // Always `website`: Next.js has no `product` Open Graph type and its renderer throws on one (review #2).
     prop("og:type", "website");
@@ -35,24 +39,23 @@ function buildHead(ctx, input) {
     name("twitter:title", input.title);
     name("twitter:description", input.description);
     name("twitter:image", img ? img.url : null);
-    return { title: applyTemplate(ctx.titleTemplate, input.title), description: input.description, canonical: input.url, alternates: set.alternates, meta };
+    return { title: applyTemplate(ctx.titleTemplate, input.title), description: input.description, canonical: input.url, robots, alternates: set.alternates, meta };
 }
 export function productHead(p, ctx) {
     rejectRedirect(p, `product ${p.sku}`);
-    const market = requireMarket(ctx.site, ctx.market);
-    const [image] = pickImages(ctx.site, p.images, market.language, p.name, 1);
-    return buildHead(ctx, { title: p.seo.title, description: headDescription(productDescription(p)), url: p.url, alternateUrls: p.alternateUrls, image: image ?? null });
+    const binding = requireBinding(ctx.site, ctx.binding);
+    const [image] = pickImages(ctx.site, p.images, binding.locale, p.name, 1);
+    return buildHead(ctx, { title: p.seo.title, description: headDescription(productDescription(p)), url: p.url, alternates: p.alternates, image: image ?? null });
 }
 /** A collection has no description or image in the API; pass `description` yourself if the page has one. */
 export function collectionHead(r, ctx) {
-    requireMarket(ctx.site, ctx.market);
-    return buildHead(ctx, { title: r.collection.name, description: headDescription(collapse(ctx.description)), url: r.collection.url, alternateUrls: r.alternateUrls, image: null });
+    return buildHead(ctx, { title: r.collection.name, description: headDescription(collapse(ctx.description)), url: r.collection.url, alternates: r.alternates, image: null });
 }
 export function brandHead(b, ctx) {
     rejectRedirect(b, `brand ${b.slug}`);
-    const market = requireMarket(ctx.site, ctx.market);
-    const [image] = b.logo ? pickImages(ctx.site, [b.logo], market.language, b.name, 1) : [];
-    return buildHead(ctx, { title: b.name, description: headDescription(collapse(b.description?.text)), url: b.url, alternateUrls: b.alternateUrls, image: image ?? null });
+    const binding = requireBinding(ctx.site, ctx.binding);
+    const [image] = b.logo ? pickImages(ctx.site, [b.logo], binding.locale, b.name, 1) : [];
+    return buildHead(ctx, { title: b.name, description: headDescription(collapse(b.description?.text)), url: b.url, alternates: b.alternates, image: image ?? null });
 }
 const metaKey = (m) => ("property" in m ? m.property : m.name);
 /** `{ [k]: v }` when `v` is defined, else `{}` — so a missing value is an absent key, never `null`/`undefined`. */
@@ -72,6 +75,7 @@ export function toNextMetadata(h) {
     return {
         title: { absolute: h.title },
         ...opt("description", h.description ?? undefined),
+        ...opt("robots", h.robots ?? undefined),
         alternates: {
             canonical: h.canonical,
             ...opt("languages", h.alternates.length > 0 ? Object.fromEntries(h.alternates.map((a) => [a.hreflang, a.href])) : undefined),

package/dist/seo/locales.d.ts

@@ -1,5 +1,6 @@
 /**
- * Market → locale for hreflang and Open Graph (spec 2026-10-06 §4.19).
+ * Binding → locale for hreflang and Open Graph (spec 2026-10-06 §4.19; market model §16.2: the content locale's language and script
+ * plus the binding's destination country).
  *
  * Embedded tables, read 2026-10-07:
  * - ISO 639-1: the two-letter column of the ISO 639-2 Registration Authority list (Library of Congress,
@@ -24,3 +25,7 @@ export declare function normalizeLocale(market: {
 export declare const hreflang: (l: MarketLocale) => string;
 /** Open Graph `language_TERRITORY`, script dropped: `zh_TW`. Never derived from `hreflang` by separator replacement. */
 export declare const ogLocale: (l: MarketLocale) => string;
+/** Market model §16.2: the hreflang of a binding — the content locale's language (+script) and the binding's destination region, never
+ *  the content locale's own region (`en-GB` bound to DE → `en-DE`); `null` when either is not a valid code. The API publishes the
+ *  compiled value on every binding and alternate; this is the same rule for a caller that has only a locale and a country. */
+export declare function hreflangFor(locale: string, country: string): string | null;

package/dist/seo/locales.js

@@ -1,5 +1,6 @@
 /**
- * Market → locale for hreflang and Open Graph (spec 2026-10-06 §4.19).
+ * Binding → locale for hreflang and Open Graph (spec 2026-10-06 §4.19; market model §16.2: the content locale's language and script
+ * plus the binding's destination country).
  *
  * Embedded tables, read 2026-10-07:
  * - ISO 639-1: the two-letter column of the ISO 639-2 Registration Authority list (Library of Congress,
@@ -93,3 +94,10 @@ export function normalizeLocale(market) {
 export const hreflang = (l) => (l.script ? `${l.language}-${l.script}-${l.country}` : `${l.language}-${l.country}`);
 /** Open Graph `language_TERRITORY`, script dropped: `zh_TW`. Never derived from `hreflang` by separator replacement. */
 export const ogLocale = (l) => `${l.language}_${l.country}`;
+/** Market model §16.2: the hreflang of a binding — the content locale's language (+script) and the binding's destination region, never
+ *  the content locale's own region (`en-GB` bound to DE → `en-DE`); `null` when either is not a valid code. The API publishes the
+ *  compiled value on every binding and alternate; this is the same rule for a caller that has only a locale and a country. */
+export function hreflangFor(locale, country) {
+    const l = normalizeLocale({ language: locale, country });
+    return l && hreflang(l);
+}

package/dist/seo/product.d.ts

@@ -3,5 +3,9 @@ import { type JsonLd, type ProductDto, type ProductJsonLdOptions } from "./types
  * schema.org `Product` / `ProductGroup` for a product page (spec §6.2). Decision order: no offer → single (only for a
  * proven singleton) → group. Never an `AggregateOffer`, never a guessed price. A priced `p.selectedVariant` is always
  * in the group, appended when the list does not hold it (variant URLs spec §6).
+ *
+ * Provenance (market model §7.4, plans review 1 #7): an `Offer` is a public offer, so a variant gets one only when the page was
+ * answered for an anonymous context (`p.context.customerKind === "anonymous"`) and its own offer is `available`. A dealer's
+ * price, a `loginRequired` page or a response without `context` emits the product without offers.
  */
 export declare function productJsonLd(p: ProductDto, ctx: ProductJsonLdOptions): JsonLd;

package/dist/seo/product.js

@@ -1,17 +1,24 @@
 import { gtinJsonLd } from "../gtin.js";
-import { jsonLdDescription, pickImages, productDescription, rejectRedirect, requireMarket } from "./shared.js";
+import { jsonLdDescription, pickImages, productDescription, rejectRedirect, requireBinding } from "./shared.js";
 import { SeoError } from "./types.js";
 const PROPERTIES = ["size", "color", "material", "pattern"];
 const IN_STOCK = "https://schema.org/InStock";
 const BACK_ORDER = "https://schema.org/BackOrder";
 const OUT_OF_STOCK = "https://schema.org/OutOfStock";
 const SCHEMA_AVAILABILITY = { inStock: IN_STOCK, backorder: BACK_ORDER, unavailable: OUT_OF_STOCK };
-/** Sellability C1 §6: the caller's answer, else the variant's own; a response from an API older than 0.14 has no
- * `availability` and falls back to `inStock`. */
+/** The offer's stock status as an availability, for a variant whose `availability` is null. */
+const FROM_STOCK = { inStock: "inStock", backorder: "backorder" };
+/** Sellability C1 §6: the caller's answer, else the variant's own `availability` (null wherever stock is hidden), else its offer's
+ * stock status (market model §8.2). */
 function availabilityOf(v, ctx) {
-    const state = ctx.availability?.(v) ?? v.availability ?? (v.inStock ? "inStock" : "unavailable");
+    const state = ctx.availability?.(v) ?? v.availability ?? FROM_STOCK[v.offer.stock.status] ?? "unavailable";
     return SCHEMA_AVAILABILITY[state] ?? OUT_OF_STOCK;
 }
+/** The variant's gross price (`inc`), whatever the page's display basis: schema.org offers carry the consumer price (SEO helper spec,
+ * market model Google = inc-only). Null when the pair has no gross — the variant then gets no offer. */
+function offerAmount(v) {
+    return v.offer.price?.inc ?? null;
+}
 const brandNode = (label) => ({ "@type": "Brand", name: label });
 /** Spec §4.12: absolute http(s), distinct per variant; checked for every emitted variant, single path included. The
  * caller's hook wins, else the variant's own `url` (variant URLs spec §6); neither is an error. */
@@ -62,10 +69,14 @@ function offerExtras(ctx) {
  * schema.org `Product` / `ProductGroup` for a product page (spec §6.2). Decision order: no offer → single (only for a
  * proven singleton) → group. Never an `AggregateOffer`, never a guessed price. A priced `p.selectedVariant` is always
  * in the group, appended when the list does not hold it (variant URLs spec §6).
+ *
+ * Provenance (market model §7.4, plans review 1 #7): an `Offer` is a public offer, so a variant gets one only when the page was
+ * answered for an anonymous context (`p.context.customerKind === "anonymous"`) and its own offer is `available`. A dealer's
+ * price, a `loginRequired` page or a response without `context` emits the product without offers.
  */
 export function productJsonLd(p, ctx) {
     rejectRedirect(p, `product ${p.sku}`);
-    const market = requireMarket(ctx.site, ctx.market);
+    const binding = requireBinding(ctx.site, ctx.binding);
     const variesBy = ctx.variesBy ?? {};
     for (const [axis, prop] of Object.entries(variesBy))
         if (!PROPERTIES.includes(prop))
@@ -74,14 +85,16 @@ export function productJsonLd(p, ctx) {
         throw new SeoError("variantUrl must be a function");
     const list = p.variants ?? ctx.variants ?? null;
     const complete = p.variants !== null;
+    const publicOffers = p.context?.customerKind === "anonymous";
+    const offered = (v) => publicOffers && v.offer.offerStatus === "available" && offerAmount(v) !== null;
     // Variant URLs spec §6: a priced selection is always emitted, exactly once (deduplicated by id against the list).
-    const sel = p.selectedVariant?.price != null ? p.selectedVariant : null;
+    const sel = p.selectedVariant != null && offered(p.selectedVariant) ? p.selectedVariant : null;
     const merged = sel !== null && !(list ?? []).some((v) => v.id === sel.id) ? [...(list ?? []), sel] : (list ?? []);
-    const sellable = merged.filter((v) => v.price !== null);
+    const sellable = merged.filter(offered);
     const description = jsonLdDescription(productDescription(p));
-    const images = pickImages(ctx.site, p.images, market.language, p.name).map((i) => i.url);
+    const images = pickImages(ctx.site, p.images, binding.locale, p.name).map((i) => i.url);
     // Variant URLs spec §5.4: effective images = the variant's own set when it owns one (an owned empty set stays empty).
-    const effectiveImages = (v, alt) => v.hasOwnImages ? pickImages(ctx.site, v.images, market.language, alt).map((x) => x.url) : images;
+    const effectiveImages = (v, alt) => v.hasOwnImages ? pickImages(ctx.site, v.images, binding.locale, alt).map((x) => x.url) : images;
     const common = (type, image = images) => ({
         "@context": "https://schema.org",
         "@type": type,
@@ -92,8 +105,8 @@ export function productJsonLd(p, ctx) {
     });
     const offer = (v, url) => ({
         "@type": "Offer",
-        price: v.price.amount,
-        priceCurrency: v.price.currency,
+        price: offerAmount(v),
+        priceCurrency: v.offer.price.currency,
         availability: availabilityOf(v, ctx),
         url,
         ...offerExtras(ctx),
@@ -110,7 +123,7 @@ export function productJsonLd(p, ctx) {
     if (sellable.length === 0)
         return { ...common("Product"), sku: p.sku, ...(p.brand ? { brand: brandNode(p.brand.label) } : {}) };
     // The singleton is decided on the list alone: a selection never turns a proven singleton into a group (§6).
-    const listSellable = (list ?? []).filter((v) => v.price !== null);
+    const listSellable = (list ?? []).filter(offered);
     if (list !== null && list.length === 1 && p.options.length === 0 && listSellable.length === 1 && (complete || Number(p.variantCount) === 1)) {
         const v = listSellable[0];
         const [url] = checkVariantUrls([v], ctx);

package/dist/seo/shared.d.ts

@@ -1,6 +1,7 @@
 import { type MediaDescriptor } from "../media.js";
-import { type MarketDto, type ProductDto, type SiteDto } from "./types.js";
-export declare function requireMarket(site: SiteDto, code: string): MarketDto;
+import { type AlternateDto, type BindingDto, type ProductDto, type SiteDto } from "./types.js";
+/** The page binding a helper renders for (market model §16.2): `id` must be one of `site.bindings`. */
+export declare function requireBinding(site: SiteDto, id: string): BindingDto;
 /** Spec §4.17: a page with `redirectTo` should answer 301, not render. */
 export declare function rejectRedirect(entity: {
     redirectTo: string | null;
@@ -31,8 +32,9 @@ export type AlternateSet = {
     alternateLocales: string[];
 };
 /**
- * Spec §6.4, one pass (review #16): candidates = `alternateUrls` entries for the site's markets + the current market
- * with `url` when missing; markets without a valid locale are skipped; over the final set identical pairs are
- * deduplicated and the same hreflang with different URLs throws. `x-default` is decided on the original map.
+ * Market model §16.3, one pass: the API's `alternates` (the indexable bindings where the page exists publicly, the current one
+ * included when it is indexable) as hreflang links, sorted by hreflang; identical pairs are deduplicated and the same hreflang with
+ * different URLs throws. `x-default` is the alternate of `xDefault` (a binding id; default `site.defaultBindingId`, `false` for none)
+ * when the page exists there. A secondary binding (`indexable: false`) is in no cluster: no links, only its own Open Graph locale.
  */
-export declare function alternateSet(site: SiteDto, market: string, url: string, alternateUrls: Record<string, string>, xDefault?: string | false): AlternateSet;
+export declare function alternateSet(site: SiteDto, current: BindingDto, alternates: readonly AlternateDto[], xDefault?: string | false): AlternateSet;

package/dist/seo/shared.js

@@ -1,11 +1,12 @@
 import { mediaUrl, MediaUrlError, pickWidth } from "../media.js";
-import { hreflang, normalizeLocale, ogLocale } from "./locales.js";
+import { normalizeLocale, ogLocale } from "./locales.js";
 import { SeoError } from "./types.js";
-export function requireMarket(site, code) {
-    const m = site.markets.find((x) => x.code === code);
-    if (!m)
-        throw new SeoError(`market '${code}' is not one of the site's markets (${site.markets.map((x) => x.code).join(", ")})`);
-    return m;
+/** The page binding a helper renders for (market model §16.2): `id` must be one of `site.bindings`. */
+export function requireBinding(site, id) {
+    const b = site.bindings.find((x) => x.id === id);
+    if (!b)
+        throw new SeoError(`binding '${id}' is not one of the site's bindings (${site.bindings.map((x) => x.id).join(", ")})`);
+    return b;
 }
 /** Spec §4.17: a page with `redirectTo` should answer 301, not render. */
 export function rejectRedirect(entity, what) {
@@ -66,41 +67,39 @@ export function pickImages(site, descriptors, language, fallbackAlt, limit = 10)
     }
     return out;
 }
+const ogOf = (locale, country) => {
+    const l = normalizeLocale({ language: locale, country });
+    return l && ogLocale(l);
+};
 /**
- * Spec §6.4, one pass (review #16): candidates = `alternateUrls` entries for the site's markets + the current market
- * with `url` when missing; markets without a valid locale are skipped; over the final set identical pairs are
- * deduplicated and the same hreflang with different URLs throws. `x-default` is decided on the original map.
+ * Market model §16.3, one pass: the API's `alternates` (the indexable bindings where the page exists publicly, the current one
+ * included when it is indexable) as hreflang links, sorted by hreflang; identical pairs are deduplicated and the same hreflang with
+ * different URLs throws. `x-default` is the alternate of `xDefault` (a binding id; default `site.defaultBindingId`, `false` for none)
+ * when the page exists there. A secondary binding (`indexable: false`) is in no cluster: no links, only its own Open Graph locale.
  */
-export function alternateSet(site, market, url, alternateUrls, xDefault) {
-    const byCode = new Map(site.markets.map((m) => [m.code, m]));
-    const candidates = Object.entries(alternateUrls).filter(([code]) => byCode.has(code)).map(([code, href]) => ({ code, href }));
-    if (!Object.hasOwn(alternateUrls, market))
-        candidates.push({ code: market, href: url });
+export function alternateSet(site, current, alternates, xDefault) {
+    const locale = ogOf(current.locale, current.country);
+    if (!current.indexable)
+        return { alternates: [], locale, alternateLocales: [] };
     const entries = new Map();
-    for (const c of candidates) {
-        const loc = normalizeLocale(byCode.get(c.code));
-        if (!loc)
-            continue;
-        const tag = hreflang(loc);
-        const seen = entries.get(tag);
+    for (const a of alternates) {
+        const seen = entries.get(a.hreflang);
         if (seen === undefined)
-            entries.set(tag, { code: c.code, href: c.href, loc });
-        else if (seen.href !== c.href)
-            throw new SeoError(`markets '${seen.code}' and '${c.code}' both give hreflang '${tag}' with different URLs; fix their language/country`);
+            entries.set(a.hreflang, a);
+        else if (seen.url !== a.url)
+            throw new SeoError(`bindings '${seen.bindingId}' and '${a.bindingId}' both give hreflang '${a.hreflang}' with different URLs; fix the site's bindings`);
     }
     const sorted = [...entries].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-    const alternates = sorted.map(([tag, e]) => ({ hreflang: tag, href: e.href }));
-    const target = xDefault === false ? null : (xDefault ?? site.defaultMarket);
-    if (target !== null && Object.hasOwn(alternateUrls, target))
-        alternates.push({ hreflang: "x-default", href: alternateUrls[target] });
-    const self = byCode.get(market);
-    const selfLoc = self ? normalizeLocale(self) : null;
-    const locale = selfLoc ? ogLocale(selfLoc) : null;
+    const links = sorted.map(([tag, a]) => ({ hreflang: tag, href: a.url }));
+    const target = xDefault === false ? null : (xDefault ?? site.defaultBindingId);
+    const fallback = target == null ? undefined : alternates.find((a) => a.bindingId === target);
+    if (fallback !== undefined)
+        links.push({ hreflang: "x-default", href: fallback.url });
     const alternateLocales = [];
-    for (const [, e] of sorted) {
-        const l = ogLocale(e.loc);
-        if (e.code !== market && l !== locale && !alternateLocales.includes(l))
+    for (const [, a] of sorted) {
+        const l = ogOf(a.locale, a.country);
+        if (l !== null && a.bindingId !== current.id && l !== locale && !alternateLocales.includes(l))
             alternateLocales.push(l);
     }
-    return { alternates, locale, alternateLocales };
+    return { alternates: links, locale, alternateLocales };
 }

package/dist/seo/sitemap.d.ts

@@ -9,9 +9,11 @@ export type SitemapUrl = {
         href: string;
     }[];
 };
-/** `complete: false` = the API was unavailable part-way (transport failure, a 5xx, `INDEX_UNAVAILABLE`,
- * `SITE_REGISTRY_WARMING`); `entries` is what was read before that. `complete: true` means "walked to exhaustion
- * without an error" — a cursor walk is an eventually consistent crawl, not a snapshot. */
+/** `complete: true`: every type's walk reached its end without an error, each on its own catalog generation, and the config version did
+ * not change between types. It is no promise of one generation for the whole result, and no snapshot: see `sitemapEntries`.
+ * `complete: false`: the API was unavailable part-way (transport failure, a 5xx, `INDEX_UNAVAILABLE`, `SITE_REGISTRY_WARMING`), or the
+ * walk could not meet that promise after its restart. `entries` is what the last walk read, so a restart that stopped early can hold less
+ * than the first walk did; only a first walk that finished replaces such a restart. */
 export type SitemapResult = {
     entries: SitemapUrl[];
     complete: boolean;
@@ -25,19 +27,35 @@ export type NextSitemapEntry = {
     };
 };
 export interface SitemapOptions {
-    /** The market the client was created with (the same `X-Market`). Required: `/v1/site` answers the site's default market,
-     * not the request's, and a wrong market here would pair one market's URLs with another's hreflang. */
-    market: string;
+    /** The binding id (`{market}/{COUNTRY}/{locale}`, one of `site.bindings`) whose sitemap is walked; sent as `binding`. Required: the
+     * sitemap is per binding (market model §16.4), and a wrong binding here would pair one binding's URLs with another's hreflang. */
+    binding: string;
     /** Default: all three. */
     types?: SitemapType[];
     /** Items per request, 1–1000 (default 1000). */
     pageSize?: number;
+    /** Inclusive ISO-8601 timestamp: only entries changed at or after it (`since`, selective revalidation). Sent on every page; a cursor is
+     * bound to it. */
+    since?: string;
 }
 /**
- * Every sitemap URL of one market: `GET /v1/site` once, then for each type a cursor walk of `GET /v1/sitemap` from
- * `cursor=start` along `nextCursor`. hreflang tags are real BCP 47 tags (`sv-SE`, never the market code `se`), with a
- * self-reference, and `x-default` only when the site's default market has the page. An epoch `updatedAt` (collections)
+ * Every sitemap URL of one binding: `GET /v1/site`, then for each type a cursor walk of `GET /v1/sitemap?binding=` from
+ * `cursor=start` along `nextCursor` (each cursor is bound to the binding, type and `since` it was issued for, and to the catalog
+ * generation the walk started on). hreflang tags are the bindings' compiled BCP 47 tags (`sv-SE`, never the market code `se`),
+ * with a self-reference, and `x-default` only when the site's default binding has the page. An epoch `updatedAt` (collections)
  * is left out rather than printed as 1970.
+ *
+ * A walk restarts once, whole (the site and every type), and the new walk's entries replace the old ones. A `409 CURSOR_EXPIRED` (the
+ * cursor's generation is gone, or the cursor is over an hour old) stops it at once. Responses that name more than one `X-Config-Version`
+ * (a publish between two types, which no cursor sees) let it read on to the end, so a list is never cut short for that: a second such
+ * walk gives every entry with `complete: false`, and so does a restart that stops early, with the first walk's entries.
+ *
+ * So `complete: true` proves this much: each type finished on its own generation, and the config version did not change between types. The
+ * API names no generation in a response, so a rebuild at the same config version between two types is not detected. That is acceptable
+ * for a sitemap: two generations at one config version carry the same URL model, and the next render reads the newer one.
+ *
+ * `400 INVALID_CURSOR` is no restart: a cursor of another scope is a fault, so it throws. A preview key meets it when the walk's generation
+ * kind flips (its draft is created or published mid-walk), which is another scope, not an expiry: run the walk again.
  */
 export declare function sitemapEntries(client: Client<StorefrontPaths>, opts: SitemapOptions): Promise<SitemapResult>;
 /** Next.js `app/sitemap.ts` shape: `alternates` → `{ languages: { [hreflang]: href } }`, `x-default` included. */

package/dist/seo/sitemap.js

@@ -1,38 +1,65 @@
-import { alternateSet } from "./shared.js";
+import { alternateSet, requireBinding } from "./shared.js";
 import { SeoError } from "./types.js";
 const ALL_TYPES = ["product", "collection", "brand"];
 const RETRYABLE = new Set(["INDEX_UNAVAILABLE", "SITE_REGISTRY_WARMING"]);
 /** The walk stops here, partial: the API is unavailable, not wrong. */
 const UNAVAILABLE = Symbol("unavailable");
+/** The walk stops here and may start over: it outlived its catalog generation. */
+const EXPIRED = Symbol("expired");
 /**
- * Every sitemap URL of one market: `GET /v1/site` once, then for each type a cursor walk of `GET /v1/sitemap` from
- * `cursor=start` along `nextCursor`. hreflang tags are real BCP 47 tags (`sv-SE`, never the market code `se`), with a
- * self-reference, and `x-default` only when the site's default market has the page. An epoch `updatedAt` (collections)
+ * Every sitemap URL of one binding: `GET /v1/site`, then for each type a cursor walk of `GET /v1/sitemap?binding=` from
+ * `cursor=start` along `nextCursor` (each cursor is bound to the binding, type and `since` it was issued for, and to the catalog
+ * generation the walk started on). hreflang tags are the bindings' compiled BCP 47 tags (`sv-SE`, never the market code `se`),
+ * with a self-reference, and `x-default` only when the site's default binding has the page. An epoch `updatedAt` (collections)
  * is left out rather than printed as 1970.
+ *
+ * A walk restarts once, whole (the site and every type), and the new walk's entries replace the old ones. A `409 CURSOR_EXPIRED` (the
+ * cursor's generation is gone, or the cursor is over an hour old) stops it at once. Responses that name more than one `X-Config-Version`
+ * (a publish between two types, which no cursor sees) let it read on to the end, so a list is never cut short for that: a second such
+ * walk gives every entry with `complete: false`, and so does a restart that stops early, with the first walk's entries.
+ *
+ * So `complete: true` proves this much: each type finished on its own generation, and the config version did not change between types. The
+ * API names no generation in a response, so a rebuild at the same config version between two types is not detected. That is acceptable
+ * for a sitemap: two generations at one config version carry the same URL model, and the next render reads the newer one.
+ *
+ * `400 INVALID_CURSOR` is no restart: a cursor of another scope is a fault, so it throws. A preview key meets it when the walk's generation
+ * kind flips (its draft is created or published mid-walk), which is another scope, not an expiry: run the walk again.
  */
 export async function sitemapEntries(client, opts) {
+    const first = await walk(client, opts);
+    const second = first.expired ? await walk(client, opts) : first;
+    // The restart's result stands, unless it stopped early and the first walk finished. A first walk a 409 stopped is no finished list, however
+    // much it read, so a restart cut short after one is returned as it is.
+    const { entries, complete } = first.finished && !second.finished ? first : second;
+    return { entries, complete };
+}
+async function walk(client, opts) {
     const entries = [];
     const pageSize = opts.pageSize ?? 1000;
-    const site = await read(() => client.GET("/v1/site", {}));
-    if (site === UNAVAILABLE)
-        return { entries, complete: false };
-    // The API matches market codes case-insensitively; alternateSet does not, so the configured spelling is passed on.
-    const wanted = opts.market.toLowerCase();
-    const market = site.markets.find((m) => m.code.toLowerCase() === wanted)?.code;
-    if (market === undefined)
-        throw new SeoError(`market '${opts.market}' is not one of the site's markets (${site.markets.map((m) => m.code).join(", ")})`);
+    const versions = new Set();
+    const seen = (response) => {
+        const version = response.headers.get("X-Config-Version");
+        if (version !== null)
+            versions.add(version);
+    };
+    const stopped = (reason) => ({ entries, complete: false, finished: false, expired: reason === EXPIRED });
+    const site = await read(() => client.GET("/v1/site", {}), seen);
+    if (site === UNAVAILABLE || site === EXPIRED)
+        return stopped(site);
+    const binding = requireBinding(site, opts.binding);
     for (const type of opts.types ?? ALL_TYPES) {
         let cursor = "start";
         for (;;) {
-            const page = await read(() => client.GET("/v1/sitemap", { params: { query: { type, cursor, pageSize } } }));
-            if (page === UNAVAILABLE)
-                return { entries, complete: false };
+            const query = { type, cursor, pageSize, binding: binding.id, ...(opts.since === undefined ? {} : { since: opts.since }) };
+            const page = await read(() => client.GET("/v1/sitemap", { params: { query } }), seen);
+            if (page === UNAVAILABLE || page === EXPIRED)
+                return stopped(page);
             // An API older than cursor paging ignores ?cursor= and answers one page without the field: that must never read as
             // the end of the walk, or the sitemap would silently shrink to its first page.
             if (!Object.hasOwn(page, "nextCursor"))
                 throw new Error("the Storefront API does not support sitemap cursors; deploy the API first");
             for (const item of page.items)
-                entries.push(toSitemapUrl(site, market, item));
+                entries.push(toSitemapUrl(site, binding, item));
             if (page.nextCursor === null)
                 break;
             if (page.nextCursor === cursor)
@@ -40,7 +67,8 @@ export async function sitemapEntries(client, opts) {
             cursor = page.nextCursor;
         }
     }
-    return { entries, complete: true };
+    const oneVersion = versions.size <= 1;
+    return { entries, complete: oneVersion, finished: true, expired: !oneVersion };
 }
 /** Next.js `app/sitemap.ts` shape: `alternates` → `{ languages: { [hreflang]: href } }`, `x-default` included. */
 export function toNextSitemap(r) {
@@ -53,13 +81,13 @@ export function toNextSitemap(r) {
         return out;
     });
 }
-function toSitemapUrl(site, market, item) {
+function toSitemapUrl(site, binding, item) {
     let alternates = [];
     try {
-        alternates = alternateSet(site, market, item.url, item.alternateUrls).alternates;
+        alternates = alternateSet(site, binding, item.alternates).alternates;
     }
     catch (e) {
-        // Two markets mapping to one hreflang with different URLs is a site config fault: drop this entry's alternates, keep
+        // Two bindings mapping to one hreflang with different URLs is a site config fault: drop this entry's alternates, keep
         // the URL. A config fault must not empty the sitemap.
         if (!(e instanceof SeoError))
             throw e;
@@ -71,7 +99,7 @@ function toSitemapUrl(site, market, item) {
  * One request. Decided on the status first: an empty-body 500 has no `error`, and an HTML 502 has a string one. A thrown
  * request is a transport failure; the catch wraps the request only, never the mapping after it.
  */
-async function read(request) {
+async function read(request, seen) {
     let result;
     try {
         result = await request();
@@ -85,7 +113,10 @@ async function read(request) {
     const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : undefined;
     if (code !== undefined && RETRYABLE.has(code))
         return UNAVAILABLE;
+    if (response.status === 409 && code === "CURSOR_EXPIRED")
+        return EXPIRED;
     if (!response.ok || data === undefined)
         throw new Error(`Storefront API ${response.url} answered ${response.status}${code ? ` ${code}` : ""}`);
+    seen(response);
     return data;
 }

package/dist/seo/types.d.ts

@@ -2,17 +2,20 @@ import type { components } from "../schema";
 type Schemas = components["schemas"];
 export type SiteDto = Schemas["SiteDto"];
 export type MarketDto = Schemas["MarketDto"];
+export type BindingDto = Schemas["BindingDto"];
+export type AlternateDto = Schemas["AlternateDto"];
 export type ProductDto = Schemas["ProductDto"];
 export type VariantDto = Schemas["VariantDto"];
 export type VariantAvailability = Schemas["VariantAvailability"];
 export type CollectionListingResponse = Schemas["CollectionListingResponse"];
 export type CollectionCrumbDto = Schemas["CollectionCrumbDto"];
 export type BrandDetailDto = Schemas["BrandDetailDto"];
-/** Every helper's context. `market` is the code the client sends as X-Market and must be in `site.markets`. */
+/** Every helper's context. `binding` is the id (`{market}/{COUNTRY}/{locale}`) of the page binding the client requested the page
+ * on — the one its `X-Market`, `X-Country` and `X-Locale` resolve to — and must be in `site.bindings` (market model §16.2). */
 export type SeoContext = {
     site: SiteDto;
-    market: string;
-    /** `x-default` target: a market code, or `false` for none. Default: `site.defaultMarket`. */
+    binding: string;
+    /** `x-default` target: a binding id, or `false` for none. Default: `site.defaultBindingId`. */
     xDefault?: string | false;
 };
 /** The `variesBy` targets Google accepts as plain strings (spec §4.3, review #5). */
@@ -28,7 +31,9 @@ export type SeoHead = {
     title: string;
     description: string | null;
     canonical: string;
-    /** Includes `x-default` (last); otherwise sorted by hreflang. */
+    /** `"noindex,follow"` on a secondary (non-indexable) binding, else `null` (market model §16.3). */
+    robots: string | null;
+    /** Includes `x-default` (last); otherwise sorted by hreflang. Empty on a secondary binding: it is in no hreflang cluster. */
     alternates: {
         hreflang: string;
         href: string;
@@ -73,6 +78,7 @@ type AbsoluteTitle = {
 export type NextMetadataLike = {
     title: AbsoluteTitle;
     description?: string;
+    robots?: string;
     alternates: {
         canonical: string;
         languages?: Record<string, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asstio-dev/storefront",
-  "version": "0.31.1",
+  "version": "0.40.0-market.1",
   "description": "Typed client for the Asstio Storefront API (generated from OpenAPI).",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "test": "vitest run",
     "test:browser": "playwright test -c browser/playwright.config.ts",
     "check": "npm run generate && npm run typecheck-examples && npm test && git diff --exit-code -- src/schema.d.ts && test -z \"$(git status --porcelain -- src/schema.d.ts)\"",
-    "smoke": "node --input-type=module -e \"import(\\\"./dist/index.js\\\").then(m => { for (const f of [\\\"createStorefrontClient\\\", \\\"filterQuery\\\", \\\"encodeFilterValues\\\", \\\"decodeFilterValues\\\", \\\"pictureSources\\\", \\\"mediaUrl\\\", \\\"formatImage\\\", \\\"styleToCss\\\", \\\"startCheckout\\\", \\\"syncCheckout\\\", \\\"completeCheckout\\\", \\\"getCheckoutStatus\\\", \\\"liveShippingFor\\\", \\\"getOrder\\\", \\\"awaitCompletion\\\", \\\"mountCheckout\\\", \\\"productJsonLd\\\", \\\"gtinJsonLd\\\", \\\"breadcrumbJsonLd\\\", \\\"productHead\\\", \\\"collectionHead\\\", \\\"brandHead\\\", \\\"toNextMetadata\\\", \\\"sitemapEntries\\\", \\\"toNextSitemap\\\", \\\"jsonLdScript\\\", \\\"SeoError\\\", \\\"productFacts\\\", \\\"toGa4Item\\\", \\\"toGa4Ecommerce\\\", \\\"longestCategory\\\", \\\"AnalyticsError\\\", \\\"trackSearchEvents\\\", \\\"variantUrl\\\", \\\"readVariantParam\\\", \\\"variantQueryForApi\\\", \\\"redirectTarget\\\"]) if (typeof m[f] !== \\\"function\\\") throw new Error(\\\"missing export \\\" + f) })\" && npm run smoke:account",
+    "smoke": "node --input-type=module -e \"import(\\\"./dist/index.js\\\").then(m => { for (const f of [\\\"createStorefrontClient\\\", \\\"filterQuery\\\", \\\"encodeFilterValues\\\", \\\"decodeFilterValues\\\", \\\"pictureSources\\\", \\\"mediaUrl\\\", \\\"formatImage\\\", \\\"styleToCss\\\", \\\"startCheckout\\\", \\\"syncCheckout\\\", \\\"completeCheckout\\\", \\\"getCheckoutStatus\\\", \\\"liveShippingFor\\\", \\\"getOrder\\\", \\\"awaitCompletion\\\", \\\"mountCheckout\\\", \\\"productJsonLd\\\", \\\"gtinJsonLd\\\", \\\"breadcrumbJsonLd\\\", \\\"productHead\\\", \\\"collectionHead\\\", \\\"brandHead\\\", \\\"toNextMetadata\\\", \\\"sitemapEntries\\\", \\\"toNextSitemap\\\", \\\"jsonLdScript\\\", \\\"SeoError\\\", \\\"productFacts\\\", \\\"toGa4Item\\\", \\\"toGa4Ecommerce\\\", \\\"longestCategory\\\", \\\"AnalyticsError\\\", \\\"trackSearchEvents\\\", \\\"variantUrl\\\", \\\"readVariantParam\\\", \\\"variantQueryForApi\\\", \\\"redirectTarget\\\", \\\"displayPrice\\\", \\\"isPriceVisible\\\", \\\"isBuyable\\\", \\\"requireBinding\\\", \\\"hreflangFor\\\", \\\"isCheckoutContextMismatch\\\"]) if (typeof m[f] !== \\\"function\\\") throw new Error(\\\"missing export \\\" + f) })\" && npm run smoke:account",
     "smoke:account": "node --input-type=module -e \"const checks = { \\\"./dist/account/index.js\\\": [\\\"createShopperClient\\\", \\\"startSignIn\\\", \\\"verifySignIn\\\", \\\"signOut\\\", \\\"switchPrincipal\\\", \\\"getSession\\\", \\\"getMe\\\", \\\"getMyCompany\\\", \\\"linkChallengeId\\\", \\\"linkToken\\\", \\\"sessionCookie\\\", \\\"signInCookie\\\", \\\"cartCookie\\\", \\\"browserCartCookie\\\", \\\"copyBrowserCart\\\", \\\"CopyBrowserCartError\\\", \\\"cookieSecurity\\\", \\\"readSignInCookie\\\", \\\"serializeCookie\\\", \\\"shopperIpFrom\\\", \\\"assertSameOrigin\\\", \\\"safeReturnPath\\\", \\\"CrossOriginError\\\"], \\\"./dist/account/browser.js\\\": [\\\"readLinkFragment\\\"], \\\"./dist/account/next.js\\\": [\\\"startSignInAction\\\", \\\"verifySignInAction\\\", \\\"signOutAction\\\", \\\"switchPrincipalAction\\\", \\\"shopperClient\\\", \\\"copyBrowserCartAction\\\"] }; for (const [file, names] of Object.entries(checks)) { const m = await import(file); for (const f of names) if (typeof m[f] !== \\\"function\\\") throw new Error(\\\"missing export \\\" + f + \\\" in \\\" + file); }\""
   },
   "dependencies": {