@evinvest/kitstart 0.1.0

package/dist/core/place/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The place model. Three words, one each:
+ *
+ * - **Place** — the aggregate: one point of the business, baked config merged
+ *   with the live source;
+ * - **Presence** — how the place exists for a visitor: a storefront with an
+ *   address, or a service area with none;
+ * - **ServiceArea** — where the van goes.
+ *
+ * A service-area business has no address *in the type*, so no builder can
+ * render one for it by accident — schema.org, the map and the footer all have
+ * to ask `presence.kind` first.
+ */
+export type DayOfWeek = "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday";
+export interface PostalAddress {
+    street: string;
+    postalCode: string;
+    locality: string;
+    /** Région administrative, as schema.org `addressRegion`. */
+    region: string;
+    /** ISO 3166-1 alpha-2. */
+    country: string;
+}
+export interface Geo {
+    lat: number;
+    lng: number;
+}
+export interface OpeningHours {
+    days: readonly DayOfWeek[];
+    /** `HH:MM`, local time. */
+    opens: string;
+    closes: string;
+}
+/**
+ * Google's rating for the place, mirrored from the Business Profile API. Never
+ * baked: it exists only when the live source supplied it, and the API's terms
+ * cap how long a copy may be shown, so `fetchedAt` travels with it.
+ */
+export interface Rating {
+    value: number;
+    count: number;
+    /** ISO 8601. */
+    fetchedAt: string;
+}
+/** Where the van goes: named communes, or a radius around a centre. */
+export type ServiceArea = {
+    kind: "localities";
+    names: readonly string[];
+} | {
+    kind: "radius";
+    center: Geo;
+    km: number;
+};
+export type Presence<L extends string> = {
+    kind: "storefront";
+    address: PostalAddress;
+    geo: Geo | null;
+    /** Absolute URL of the storefront or van photo taken at the place. */
+    storefrontPhoto: string | null;
+    /** How a visitor recognises the place — a local landmark, per language. */
+    landmark: Readonly<Record<L, string>> | null;
+} | {
+    kind: "service-area";
+};
+export interface Place<L extends string> {
+    /** The subdomain, or the path segment through the apex. */
+    slug: string;
+    /** The Google Business Profile's own name — the schema.org `name`. */
+    gbpName: string;
+    /** The short place name the copy uses: "Royat", "Lyon 3e". */
+    name: Readonly<Record<L, string>>;
+    presence: Presence<L>;
+    serviceArea: readonly ServiceArea[] | null;
+    /** International numbers as printed; `null` → the brand's own. */
+    channels: {
+        phone: string | null;
+        whatsapp: string | null;
+    };
+    hours: readonly OpeningHours[] | null;
+    /** Live only. */
+    rating: Rating | null;
+}
+/** The storefront half of a place, or `null` for a service-area business. */
+export declare function storefrontOf<L extends string>(place: Place<L>): Extract<Presence<L>, {
+    kind: "storefront";
+}> | null;
+/**
+ * The communes a place names. Until the zone is named, a storefront serves its
+ * own town; a radius names no commune.
+ */
+export declare function servedLocalities(place: Place<string>): string[];

package/dist/core/place/types.js

@@ -0,0 +1,27 @@
+/**
+ * The place model. Three words, one each:
+ *
+ * - **Place** — the aggregate: one point of the business, baked config merged
+ *   with the live source;
+ * - **Presence** — how the place exists for a visitor: a storefront with an
+ *   address, or a service area with none;
+ * - **ServiceArea** — where the van goes.
+ *
+ * A service-area business has no address *in the type*, so no builder can
+ * render one for it by accident — schema.org, the map and the footer all have
+ * to ask `presence.kind` first.
+ */
+/** The storefront half of a place, or `null` for a service-area business. */
+export function storefrontOf(place) {
+    return place.presence.kind === "storefront" ? place.presence : null;
+}
+/**
+ * The communes a place names. Until the zone is named, a storefront serves its
+ * own town; a radius names no commune.
+ */
+export function servedLocalities(place) {
+    if (place.serviceArea === null) {
+        return place.presence.kind === "storefront" ? [place.presence.address.locality] : [];
+    }
+    return place.serviceArea.flatMap(area => (area.kind === "localities" ? area.names : []));
+}

package/dist/core/place/view.d.ts

@@ -0,0 +1,56 @@
+import type { Place } from "./types.js";
+/**
+ * How links are written on a place's pages. On its own host a page is
+ * `/fr/prices` (`host`); reached through the apex fallback it is
+ * `/fr/<slug>/prices` (`path`). The proxy says which one a request is by the
+ * route it rewrites to — see `placeParam`.
+ */
+export type LinkMode = "host" | "path";
+/** The part of a site that decides where a place's canonical URLs live. */
+export interface OriginFacts {
+    brand: {
+        domain: string | null;
+    };
+    topology: {
+        kind: "subdomains";
+    } | {
+        kind: "single";
+    };
+}
+/**
+ * A place as one request sees it: the merged record, the language, and how its
+ * links are written on this host. Sections take this instead of eight props.
+ */
+export interface PlaceView<L extends string> {
+    place: Place<L>;
+    locale: L;
+    mode: LinkMode;
+    /** Root-relative link to one of this place's pages in `locale`. */
+    href: (suffix: string, locale?: L) => string;
+    /** Canonical URL — absolute once the site has a domain. */
+    url: (suffix: string, locale?: L) => string;
+}
+/** `https://<domain>`, or `null` for a site with no domain yet. */
+export declare function siteOrigin(site: OriginFacts): string | null;
+/**
+ * Where a place's pages canonically live: its subdomain in a `subdomains`
+ * site, the apex in a `single` one, whichever URL served the request.
+ */
+export declare function placeOrigin(site: OriginFacts, slug: string): string | null;
+/** Where a place's pages link to, given how this request reached it. */
+export interface LinkBase {
+    mode: LinkMode;
+    slug: string;
+}
+/**
+ * A root-relative href to one of the place's pages. `suffix` is a page suffix
+ * and may carry a fragment: `"#quote"`, `"/prices#faq"`.
+ */
+export declare function placeHref(base: LinkBase, locale: string, suffix: string): string;
+/**
+ * The canonical URL of a place's page. A site with no domain has no absolute
+ * URL to give; the root-relative path it serves is the honest answer, and
+ * every page of such a site is `noindex` anyway.
+ */
+export declare function placeUrl(site: OriginFacts, slug: string, locale: string, suffix: string): string;
+export declare function createPlaceView<L extends string>(site: OriginFacts, place: Place<L>, locale: NoInfer<L>, mode: LinkMode): PlaceView<L>;

package/dist/core/place/view.js

@@ -0,0 +1,43 @@
+/** `https://<domain>`, or `null` for a site with no domain yet. */
+export function siteOrigin(site) {
+    return site.brand.domain === null ? null : `https://${site.brand.domain}`;
+}
+/**
+ * Where a place's pages canonically live: its subdomain in a `subdomains`
+ * site, the apex in a `single` one, whichever URL served the request.
+ */
+export function placeOrigin(site, slug) {
+    const { domain } = site.brand;
+    if (domain === null)
+        return null;
+    return site.topology.kind === "single" ? `https://${domain}` : `https://${slug}.${domain}`;
+}
+/**
+ * A root-relative href to one of the place's pages. `suffix` is a page suffix
+ * and may carry a fragment: `"#quote"`, `"/prices#faq"`.
+ */
+export function placeHref(base, locale, suffix) {
+    const prefix = base.mode === "host" ? `/${locale}` : `/${locale}/${base.slug}`;
+    return `${prefix}${suffix}`;
+}
+/**
+ * The canonical URL of a place's page. A site with no domain has no absolute
+ * URL to give; the root-relative path it serves is the honest answer, and
+ * every page of such a site is `noindex` anyway.
+ */
+export function placeUrl(site, slug, locale, suffix) {
+    const origin = placeOrigin(site, slug);
+    if (origin !== null)
+        return `${origin}/${locale}${suffix}`;
+    return placeHref({ mode: site.topology.kind === "single" ? "host" : "path", slug }, locale, suffix);
+}
+export function createPlaceView(site, place, locale, mode) {
+    const base = { mode, slug: place.slug };
+    return {
+        place,
+        locale,
+        mode,
+        href: (suffix, other = locale) => placeHref(base, other, suffix),
+        url: (suffix, other = locale) => placeUrl(site, place.slug, other, suffix),
+    };
+}

package/dist/core/routing.d.ts

@@ -0,0 +1,121 @@
+import type { LinkMode } from "./place/view.js";
+import type { Site } from "./site.js";
+/**
+ * Which place and which language a request gets, decided before any route
+ * renders. Pure, so it is tested without a server — and mirrored by the Rust
+ * `kitstart` feature against `tests/fixtures/kitstart/decide.json`.
+ *
+ * ```text
+ * <slug>.<domain>/fr/prices      → /fr/_<slug>/prices   (host link mode)
+ * <domain>/fr/<slug>/prices      → as it is             (path link mode, apex fallback)
+ * single site: /fr/prices        → /fr/_<place>/prices  (host link mode)
+ * /fr/_<slug>/…                  → as it is             (Next re-enters the proxy with it)
+ * ?lang=<l> on a page            → cookie for a year, 303 to the clean URL
+ * a `legacyRedirects` path       → 301 to where it moved
+ * unprefixed page                → 302 to /<cookie ?? Accept-Language>/…
+ * any other path                 → gone: the 404 in the page's (or the
+ *                                  negotiated) language, for its place
+ * /_next/…, a NON_PAGE_ROUTES path, a site's `publicFiles` → pass
+ * ```
+ *
+ * A path with an extension is no exception: `/wp-login.php` or `/fr/x.php`
+ * let past would reach `[locale]`, whose `notFound()` Next caches as a page —
+ * a bare 404 without the phone, one ISR entry per scanner's guess.
+ *
+ * The link mode rides in the path, never in a request header: a page that read
+ * a header would render per request, and every page here is cached (ISR). In
+ * the path, each mode is its own cache entry, and the two modes' different
+ * links can never share one.
+ *
+ * The negotiation is a **302**, never a 301: the choice is per visitor and
+ * must not be cached as permanent. Only page paths enter it — `/quote`,
+ * `/sitemap.xml`, `/og` and the brand's files pass straight through.
+ */
+/** Not indexable, not in the sitemap, but negotiated like any other page. */
+export declare const THANKS = "/thanks";
+export declare const LANG_COOKIE = "lang";
+export declare const LANG_COOKIE_MAX_AGE = 31536000;
+/** The prefix a `[location]` route param carries in host link mode. */
+export declare const HOST_MARK = "_";
+/**
+ * How a dead path reaches a 404 a visitor without JavaScript can read.
+ *
+ * Next 16 cannot put a `notFound()` boundary into the HTML: that response is
+ * an empty `<html id="__next_error__">` the client fills in after hydration.
+ * What it does render on the server is a path no route matches — through
+ * `app/global-not-found.tsx`. The proxy knows every place and every page, so
+ * it rewrites a dead path to `/<locale>/404/404`, which matches nothing, and
+ * says which language and place the 404 speaks for in {@link GONE_HEADER}.
+ * Reserved: no place may take `404` as its slug.
+ */
+export declare const GONE = "404";
+/** The path no route matches, in a language. */
+export declare function gonePath(locale: string): string;
+/**
+ * Set only by the proxy, on a `gone` rewrite, and stripped from every other
+ * request; read only by the global not-found page, a route of its own — a
+ * page that read it would render per request, and none does.
+ */
+export declare const GONE_HEADER = "x-landing-not-found";
+/** `fr` or `fr/_royat`: the 404's language and, if it has one, its place. */
+export declare function goneHeader(locale: string, location: string | null): string;
+/** Inverse of {@link goneHeader}; anything absent or malformed reads as nothing. */
+export declare function parseGoneHeader(value: string | null): {
+    locale?: string;
+    location?: string;
+};
+/**
+ * The routes every landing has outside `[locale]`, which pass untouched: the
+ * form target, the OG card, the probe, the sitemap and robots. Anything else
+ * without a language but `/_next/…` and the site's `publicFiles` is `gone`.
+ */
+export declare const NON_PAGE_ROUTES: readonly string[];
+/** @deprecated The same list as {@link NON_PAGE_ROUTES}, under its old name. */
+export declare const PASS_PATHS: readonly string[];
+/** The `[location]` param for a slug in a mode: `_royat` on its host, `royat` through the apex. */
+export declare function placeParam(slug: string, mode: LinkMode): string;
+/** Inverse of {@link placeParam}. */
+export declare function parsePlaceParam(param: string): {
+    slug: string;
+    mode: LinkMode;
+};
+/** Every suffix the proxy treats as a page of a place. */
+export declare function pointSuffixes<L extends string, P extends string>(site: Site<L, P>): string[];
+export interface RequestFacts {
+    host: string;
+    pathname: string;
+    query: URLSearchParams;
+    acceptLanguage: string | null;
+    cookieLang: string | null;
+}
+export type Decision<L extends string> = {
+    kind: "pass";
+} | {
+    kind: "negotiate";
+    location: string;
+} | {
+    kind: "choose";
+    location: string;
+    locale: L;
+} | {
+    kind: "moved";
+    location: string;
+} | {
+    kind: "serve";
+    pathname: string;
+}
+/** A dead path: the 404 in `locale`, for a place's param or (`null`) the brand. */
+ | {
+    kind: "gone";
+    locale: L;
+    location: string | null;
+};
+export interface Routing<L extends string> {
+    /**
+     * The place a host names: `royat.<domain>` → `"royat"`, `royat.localhost:3000`
+     * too, for local work. On a `single` site every host is the one place.
+     */
+    hostSlug(host: string): string | null;
+    decide(req: RequestFacts): Decision<L>;
+}
+export declare function createRouting<L extends string, P extends string>(site: Site<L, P>): Routing<L>;

package/dist/core/routing.js

@@ -0,0 +1,198 @@
+/**
+ * Which place and which language a request gets, decided before any route
+ * renders. Pure, so it is tested without a server — and mirrored by the Rust
+ * `kitstart` feature against `tests/fixtures/kitstart/decide.json`.
+ *
+ * ```text
+ * <slug>.<domain>/fr/prices      → /fr/_<slug>/prices   (host link mode)
+ * <domain>/fr/<slug>/prices      → as it is             (path link mode, apex fallback)
+ * single site: /fr/prices        → /fr/_<place>/prices  (host link mode)
+ * /fr/_<slug>/…                  → as it is             (Next re-enters the proxy with it)
+ * ?lang=<l> on a page            → cookie for a year, 303 to the clean URL
+ * a `legacyRedirects` path       → 301 to where it moved
+ * unprefixed page                → 302 to /<cookie ?? Accept-Language>/…
+ * any other path                 → gone: the 404 in the page's (or the
+ *                                  negotiated) language, for its place
+ * /_next/…, a NON_PAGE_ROUTES path, a site's `publicFiles` → pass
+ * ```
+ *
+ * A path with an extension is no exception: `/wp-login.php` or `/fr/x.php`
+ * let past would reach `[locale]`, whose `notFound()` Next caches as a page —
+ * a bare 404 without the phone, one ISR entry per scanner's guess.
+ *
+ * The link mode rides in the path, never in a request header: a page that read
+ * a header would render per request, and every page here is cached (ISR). In
+ * the path, each mode is its own cache entry, and the two modes' different
+ * links can never share one.
+ *
+ * The negotiation is a **302**, never a 301: the choice is per visitor and
+ * must not be cached as permanent. Only page paths enter it — `/quote`,
+ * `/sitemap.xml`, `/og` and the brand's files pass straight through.
+ */
+/** Not indexable, not in the sitemap, but negotiated like any other page. */
+export const THANKS = "/thanks";
+export const LANG_COOKIE = "lang";
+export const LANG_COOKIE_MAX_AGE = 31_536_000;
+/** The prefix a `[location]` route param carries in host link mode. */
+export const HOST_MARK = "_";
+/**
+ * How a dead path reaches a 404 a visitor without JavaScript can read.
+ *
+ * Next 16 cannot put a `notFound()` boundary into the HTML: that response is
+ * an empty `<html id="__next_error__">` the client fills in after hydration.
+ * What it does render on the server is a path no route matches — through
+ * `app/global-not-found.tsx`. The proxy knows every place and every page, so
+ * it rewrites a dead path to `/<locale>/404/404`, which matches nothing, and
+ * says which language and place the 404 speaks for in {@link GONE_HEADER}.
+ * Reserved: no place may take `404` as its slug.
+ */
+export const GONE = "404";
+/** The path no route matches, in a language. */
+export function gonePath(locale) {
+    return `/${locale}/${GONE}/${GONE}`;
+}
+/**
+ * Set only by the proxy, on a `gone` rewrite, and stripped from every other
+ * request; read only by the global not-found page, a route of its own — a
+ * page that read it would render per request, and none does.
+ */
+export const GONE_HEADER = "x-landing-not-found";
+/** `fr` or `fr/_royat`: the 404's language and, if it has one, its place. */
+export function goneHeader(locale, location) {
+    return location ? `${locale}/${location}` : locale;
+}
+/** Inverse of {@link goneHeader}; anything absent or malformed reads as nothing. */
+export function parseGoneHeader(value) {
+    const [locale, location, extra] = (value ?? "").split("/");
+    if (extra !== undefined)
+        return {};
+    return { ...(locale ? { locale } : {}), ...(location ? { location } : {}) };
+}
+/**
+ * The routes every landing has outside `[locale]`, which pass untouched: the
+ * form target, the OG card, the probe, the sitemap and robots. Anything else
+ * without a language but `/_next/…` and the site's `publicFiles` is `gone`.
+ */
+export const NON_PAGE_ROUTES = ["/quote", "/og", "/health", "/sitemap.xml", "/robots.txt"];
+/** @deprecated The same list as {@link NON_PAGE_ROUTES}, under its old name. */
+export const PASS_PATHS = NON_PAGE_ROUTES;
+function isInfrastructure(pathname, publicFiles) {
+    return NON_PAGE_ROUTES.includes(pathname) || publicFiles.includes(pathname) || pathname.startsWith("/_next/");
+}
+/** The `[location]` param for a slug in a mode: `_royat` on its host, `royat` through the apex. */
+export function placeParam(slug, mode) {
+    return mode === "host" ? `${HOST_MARK}${slug}` : slug;
+}
+/** Inverse of {@link placeParam}. */
+export function parsePlaceParam(param) {
+    return param.startsWith(HOST_MARK) ? { slug: param.slice(HOST_MARK.length), mode: "host" } : { slug: param, mode: "path" };
+}
+/** Every suffix the proxy treats as a page of a place. */
+export function pointSuffixes(site) {
+    return [...site.pageKeys.map(k => site.pages[k]), THANKS];
+}
+function withQuery(path, query) {
+    const rest = new URLSearchParams(query);
+    rest.delete("lang");
+    const qs = rest.toString();
+    return qs ? `${path}?${qs}` : path;
+}
+export function createRouting(site) {
+    const { i18n, placeSlugs, topology } = site;
+    const publicFiles = site.publicFiles ?? [];
+    const suffixes = pointSuffixes(site);
+    const hosts = [site.brand.domain, "localhost"].filter((h) => h !== null);
+    function hostSlug(host) {
+        if (topology.kind === "single")
+            return topology.place;
+        const name = host.toLowerCase().replace(/:\d+$/, "");
+        for (const base of hosts) {
+            if (name.endsWith(`.${base}`)) {
+                const sub = name.slice(0, -(base.length + 1));
+                return placeSlugs.includes(sub) ? sub : null;
+            }
+        }
+        return null;
+    }
+    function legacy(locale, rest) {
+        for (const redirect of site.legacyRedirects ?? []) {
+            if (redirect.from !== rest)
+                continue;
+            const to = redirect.to(locale);
+            if (to !== null)
+                return to;
+        }
+        return null;
+    }
+    /** Is `rest` (locale-free) a page this host serves? */
+    function isPage(rest, slug) {
+        if (slug)
+            return suffixes.includes(rest);
+        if (rest === "" || rest === THANKS)
+            return true; // the brand's own pages
+        const [, first = "", ...more] = rest.split("/");
+        const suffix = more.length ? `/${more.join("/")}` : "";
+        return placeSlugs.includes(first) && suffixes.includes(suffix);
+    }
+    function split(pathname) {
+        const trimmed = pathname.length > 1 ? pathname.replace(/\/+$/, "") : pathname;
+        const [, first = "", ...more] = trimmed.split("/");
+        if (i18n.isLocale(first))
+            return { locale: first, rest: more.length ? `/${more.join("/")}` : "" };
+        return { locale: null, rest: trimmed === "/" ? "" : trimmed };
+    }
+    function decide(req) {
+        const { locale, rest } = split(req.pathname);
+        if (locale === null && isInfrastructure(req.pathname, publicFiles))
+            return { kind: "pass" };
+        if (locale !== null) {
+            // The 404's own target passes, keeping the header it was sent with.
+            if (rest === `/${GONE}/${GONE}`)
+                return { kind: "serve", pathname: req.pathname };
+            // Next renders a cached page by running the proxy again, host-less, on
+            // the path it was rewritten to; that path must come out as it went in.
+            const [, first = "", ...more] = rest.split("/");
+            if (first.startsWith(HOST_MARK)) {
+                const named = parsePlaceParam(first);
+                if (!placeSlugs.includes(named.slug))
+                    return { kind: "gone", locale, location: null };
+                const suffix = more.length ? `/${more.join("/")}` : "";
+                return suffixes.includes(suffix) ? { kind: "serve", pathname: req.pathname } : { kind: "gone", locale, location: first };
+            }
+        }
+        const slug = hostSlug(req.host);
+        if (!slug || topology.kind === "single") {
+            const moved = legacy(locale, rest);
+            if (moved)
+                return { kind: "moved", location: withQuery(moved, req.query) };
+        }
+        const page = isPage(rest, slug);
+        if (page) {
+            const asked = req.query.get("lang");
+            if (i18n.isLocale(asked)) {
+                // The visitor chose, so record it and take the query back out — a shared
+                // or bookmarked link should not keep re-asserting a language.
+                return { kind: "choose", locale: asked, location: withQuery(i18n.localePath(asked, rest || "/"), req.query) };
+            }
+        }
+        if (locale === null) {
+            const chosen = i18n.isLocale(req.cookieLang) ? req.cookieLang : i18n.negotiate(req.acceptLanguage);
+            if (page)
+                return { kind: "negotiate", location: withQuery(i18n.localePath(chosen, rest || "/"), req.query) };
+            // Junk without a language still gets a readable 404, in the language the
+            // visitor would have been sent to.
+            return { kind: "gone", locale: chosen, location: slug ? placeParam(slug, "host") : null };
+        }
+        // Every prefixed path on a place's host belongs to that place: `/fr/nope`
+        // is that place's 404, not the brand's.
+        if (slug) {
+            const param = placeParam(slug, "host");
+            return page ? { kind: "serve", pathname: `/${locale}/${param}${rest}` } : { kind: "gone", locale, location: param };
+        }
+        if (page)
+            return { kind: "serve", pathname: req.pathname };
+        const [, first = ""] = rest.split("/");
+        return { kind: "gone", locale, location: placeSlugs.includes(first) ? first : null };
+    }
+    return { hostSlug, decide };
+}

package/dist/core/seo/ld.d.ts

@@ -0,0 +1,58 @@
+import { type JsonLdNode } from "@evinvest/marketing";
+import { type Place } from "../place/types.js";
+import { type PlaceView } from "../place/view.js";
+import { type Site } from "../site.js";
+/**
+ * schema.org, derived from the site, the place and the page's copy — never
+ * authored. One `@graph` per page with shared `@id`s, so Google collapses the
+ * entities instead of reading each as separate. Output is pinned against
+ * aquafix's goldens in `tests/fixtures/kitstart/json-ld.json`, which the Rust
+ * `kitstart` feature reads too.
+ *
+ * A storefront carries its address, pin and photo; a service-area business
+ * has none of the three in its type, so its node says where it goes
+ * (`areaServed`) and nothing about where it is. No `aggregateRating` from
+ * anything baked: only a live rating inside the API's 30-day window.
+ */
+/** One row of a price list, as the page's table prints it. */
+export interface OfferInput {
+    name: string;
+    /** Whole currency units, the same integer the table cell renders. */
+    price: number;
+    /** ISO 4217; `EUR` when left out. */
+    currency?: string;
+}
+export interface QuestionAnswer {
+    q: string;
+    a: string;
+}
+/** The words one page's graph quotes. */
+export interface PageGraphCopy {
+    /** The short place name the copy uses: "Royat". */
+    placeName: string;
+    title: string;
+    description: string;
+    /** Emitted only where the page renders the price list. */
+    offers?: readonly OfferInput[];
+    /** Emitted only where the page renders the FAQ. */
+    faq?: readonly QuestionAnswer[];
+}
+export declare const organizationId: <L extends string, P extends string>(site: Site<L, P>) => string;
+export declare const businessId: <L extends string, P extends string>(site: Site<L, P>, slug: string) => string;
+export declare const websiteId: <L extends string, P extends string>(site: Site<L, P>, slug: string) => string;
+export declare function organizationNode<L extends string, P extends string>(site: Site<L, P>): JsonLdNode;
+/**
+ * A radius as a `GeoCircle`; named communes as `City` for a service-area
+ * business (the design's shape, §3.4) and as `Place` for a storefront, which
+ * is what aquafix's indexed pages already say — its goldens do not move.
+ */
+export declare function areaServedNodes(place: Place<string>): JsonLdNode[];
+/** The business behind one place. */
+export declare function businessNode<L extends string, P extends string>(site: Site<L, P>, view: PlaceView<L>, now: Date): JsonLdNode;
+/** One `Service` + `Offer` per price row: the same integer as the table cell, tax included. */
+export declare function offerNodes<L extends string, P extends string>(site: Site<L, P>, place: Place<L>, offers: readonly OfferInput[]): JsonLdNode[];
+export declare function faqPageNode(items: readonly QuestionAnswer[]): JsonLdNode;
+/** Home → page. The chain is the route, so a new page cannot forget it. */
+export declare function breadcrumbNode<L extends string, P extends string>(site: Site<L, P>, view: PlaceView<L>, page: P | "home", copy: Pick<PageGraphCopy, "placeName" | "title">): JsonLdNode;
+/** The `@graph` for one of a place's pages in one language. */
+export declare function placeGraph<L extends string, P extends string>(site: Site<L, P>, view: PlaceView<L>, page: P | "home", copy: PageGraphCopy, now: Date): JsonLdNode;