@evinvest/kitstart 0.1.0

package/dist/next/routes.js

@@ -0,0 +1,50 @@
+import { headers } from "next/headers.js";
+import { createRouting } from "../core/routing.js";
+import { robotsFor, sitemapFor } from "../core/seo/sitemap.js";
+/**
+ * `app/sitemap.ts`, `app/robots.ts` and `app/health/route.ts` in three lines
+ * each. The two metadata routes read the `Host` header — a sitemap may only
+ * list URLs on its own host — so the brand's file says
+ * `export const dynamic = "force-dynamic"` itself (Next reads it statically).
+ * They are cheap; the pages are what is cached.
+ */
+async function host() {
+    return (await headers()).get("host") ?? "";
+}
+/**
+ * Strict: with a live source configured, an unreachable one throws, and the
+ * crawler keeps its last copy — an empty or truncated sitemap would tell it
+ * the place is gone.
+ */
+export function sitemapRoute(site, source) {
+    const routing = createRouting(site);
+    return async () => {
+        const h = await host();
+        // A host's sitemap lists at most its own place, so that is the one fetch;
+        // the apex of a subdomains site lists only the brand page and asks nothing.
+        const slug = routing.hostSlug(h);
+        if (slug === null)
+            return sitemapFor(site, h, []);
+        const place = await source.getPlaceStrict(slug, site.i18n.defaultLocale);
+        return sitemapFor(site, h, place ? [place] : []);
+    };
+}
+export function robotsRoute(site) {
+    return async () => robotsFor(site, await host());
+}
+/**
+ * The readiness probe: the process answers. `check` is for a brand that wants
+ * more (the lead store's `health()`); a failing check answers 503.
+ */
+export function healthRoute(check) {
+    return async () => {
+        try {
+            await check?.();
+        }
+        catch (error) {
+            console.error("health: check failed", error);
+            return new Response("unavailable", { status: 503, headers: { "Content-Type": "text/plain; charset=utf-8" } });
+        }
+        return new Response("ok", { headers: { "Content-Type": "text/plain; charset=utf-8" } });
+    };
+}

package/dist/proxy/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `@evinvest/kitstart/proxy` — the routing decision applied to a live request.
+ * Edge-safe: it reads only the core and `next/server`.
+ *
+ * It hands a page nothing but the path it rewrites to. A page that read a
+ * request header would render per request, and every page here is cached
+ * (ISR); the link mode rides in the route param instead (`/fr/_royat`). The
+ * one header it sets goes to the 404 route (`GONE_HEADER`), which is not a
+ * page of any segment. A client-sent copy is stripped from every request but
+ * the 404 route's own second pass (see `ownGoneHeader`).
+ *
+ * The brand's `proxy.ts` keeps its `config.matcher` a literal — Next reads it
+ * statically — and takes the handler from here:
+ *
+ * ```ts
+ * export const proxy = createProxy(site);
+ * export const config = { matcher: ["/((?!_next/).*)"] };
+ * ```
+ */
+import { NextResponse, type NextRequest } from "next/server.js";
+import type { Site } from "../core/site.js";
+/**
+ * The matcher the brand's `proxy.ts` spells out: everything but the build
+ * output. Paths with an extension come in too — let past, `/wp-login.php`
+ * would be a cached bare 404 — and `decide`, which owns the list of what is
+ * not a page, passes the real files. Exported so a contract test can compare
+ * the brand's literal against it.
+ */
+export declare const PROXY_MATCHER = "/((?!_next/).*)";
+export declare function createProxy<L extends string, P extends string>(site: Site<L, P>): (request: NextRequest) => NextResponse;
+export { GONE_HEADER, LANG_COOKIE, LANG_COOKIE_MAX_AGE } from "../core/routing.js";

package/dist/proxy/index.js

@@ -0,0 +1,108 @@
+/**
+ * `@evinvest/kitstart/proxy` — the routing decision applied to a live request.
+ * Edge-safe: it reads only the core and `next/server`.
+ *
+ * It hands a page nothing but the path it rewrites to. A page that read a
+ * request header would render per request, and every page here is cached
+ * (ISR); the link mode rides in the route param instead (`/fr/_royat`). The
+ * one header it sets goes to the 404 route (`GONE_HEADER`), which is not a
+ * page of any segment. A client-sent copy is stripped from every request but
+ * the 404 route's own second pass (see `ownGoneHeader`).
+ *
+ * The brand's `proxy.ts` keeps its `config.matcher` a literal — Next reads it
+ * statically — and takes the handler from here:
+ *
+ * ```ts
+ * export const proxy = createProxy(site);
+ * export const config = { matcher: ["/((?!_next/).*)"] };
+ * ```
+ */
+// `next/server.js`, not `next/server`: `next` has no `exports` map, so plain
+// Node ESM resolves only the file name. Every bundler accepts both.
+import { NextResponse } from "next/server.js";
+import { createRouting, GONE_HEADER, goneHeader, gonePath, LANG_COOKIE, LANG_COOKIE_MAX_AGE, parseGoneHeader, parsePlaceParam } from "../core/routing.js";
+/** The bare URL's answer depends on both; a shared cache must key on them. */
+const VARY = "Accept-Language, Cookie";
+/** A redirect chosen for this visitor: no cache may keep it for the next. */
+const PER_VISITOR = "private, no-store";
+/**
+ * The matcher the brand's `proxy.ts` spells out: everything but the build
+ * output. Paths with an extension come in too — let past, `/wp-login.php`
+ * would be a cached bare 404 — and `decide`, which owns the list of what is
+ * not a page, passes the real files. Exported so a contract test can compare
+ * the brand's literal against it.
+ */
+export const PROXY_MATCHER = "/((?!_next/).*)";
+export function createProxy(site) {
+    const routing = createRouting(site);
+    /**
+     * Next renders a rewrite target by running this proxy again on it, so the
+     * 404 route arrives here carrying the header the first pass set. It is kept
+     * there, and only there, when it names that path's language and a real
+     * place: forged by hand, it can at most pick another real place's phone.
+     */
+    const ownGoneHeader = (request) => {
+        const path = /^\/([^/]+)\/404\/404$/.exec(request.nextUrl.pathname);
+        if (!path || gonePath(path[1] ?? "") !== request.nextUrl.pathname)
+            return false;
+        const gone = parseGoneHeader(request.headers.get(GONE_HEADER));
+        if (gone.locale !== path[1])
+            return false;
+        return gone.location === undefined || site.placeSlugs.includes(parsePlaceParam(gone.location).slug);
+    };
+    /** Onward, minus a client-sent gone header; untouched (no override) when there is none. */
+    const onward = (request, rewrite) => {
+        if (!request.headers.has(GONE_HEADER) || ownGoneHeader(request))
+            return rewrite ? NextResponse.rewrite(rewrite) : NextResponse.next();
+        const headers = new Headers(request.headers);
+        headers.delete(GONE_HEADER);
+        return rewrite ? NextResponse.rewrite(rewrite, { request: { headers } }) : NextResponse.next({ request: { headers } });
+    };
+    return function proxy(request) {
+        const url = request.nextUrl;
+        const decision = routing.decide({
+            host: request.headers.get("host") ?? url.host,
+            pathname: url.pathname,
+            query: url.searchParams,
+            acceptLanguage: request.headers.get("accept-language"),
+            cookieLang: request.cookies.get(LANG_COOKIE)?.value ?? null,
+        });
+        switch (decision.kind) {
+            case "pass":
+                return onward(request, null);
+            case "moved":
+                return NextResponse.redirect(new URL(decision.location, url), 301);
+            case "negotiate": {
+                const response = NextResponse.redirect(new URL(decision.location, url), 302);
+                response.headers.set("Vary", VARY);
+                response.headers.set("Cache-Control", PER_VISITOR);
+                return response;
+            }
+            case "choose": {
+                const response = NextResponse.redirect(new URL(decision.location, url), 303);
+                response.headers.set("Cache-Control", PER_VISITOR);
+                response.cookies.set(LANG_COOKIE, decision.locale, {
+                    path: "/",
+                    maxAge: LANG_COOKIE_MAX_AGE,
+                    sameSite: "lax",
+                    httpOnly: true,
+                    secure: true,
+                });
+                return response;
+            }
+            case "serve":
+                // No `Vary`: every page's language is in its path, so a prefixed page
+                // is the same bytes for every visitor (and Next overwrites `Vary` on
+                // rendered pages anyway).
+                return onward(request, decision.pathname === url.pathname ? null : new URL(`${decision.pathname}${url.search}`, url));
+            case "gone": {
+                // To a path no route matches, which Next answers 404 from
+                // `app/global-not-found.tsx` — the one reader of the header.
+                const headers = new Headers(request.headers);
+                headers.set(GONE_HEADER, goneHeader(decision.locale, decision.location));
+                return NextResponse.rewrite(new URL(gonePath(decision.locale), url), { request: { headers } });
+            }
+        }
+    };
+}
+export { GONE_HEADER, LANG_COOKIE, LANG_COOKIE_MAX_AGE } from "../core/routing.js";

package/dist/react/AnalyticsBoundary.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+import { type AnalyticsTarget } from "../core/analytics.js";
+/**
+ * The only client island analytics needs. Everything it wraps stays server
+ * rendered; this adds one delegated listener (capture phase, never cancelling
+ * the navigation) and a page-view beacon. With no key it sends nothing, and it
+ * writes no cookie. `target` is plain data from the server layout — the key
+ * is read from the container when the page renders, never inlined.
+ */
+export declare function AnalyticsBoundary({ target, placeSlug, children }: {
+    target: AnalyticsTarget;
+    placeSlug: string | null;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/react/AnalyticsBoundary.js

@@ -0,0 +1,55 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ContactLinkTracker } from "@evinvest/marketing/tracker";
+import { usePathname } from "next/navigation.js";
+import { useEffect, useMemo } from "react";
+import { analyticsSink, countsAsPageView, EVENTS } from "../core/analytics.js";
+/** `data-intent` on a link or button marks a conversion intent that is not a contact link. */
+const INTENT_ATTR = "data-intent";
+const INTENTS = ["form_open", "booking"];
+function source() {
+    const utm = new URLSearchParams(window.location.search).get("utm_source");
+    if (utm)
+        return utm.slice(0, 64);
+    if (!document.referrer)
+        return "direct";
+    try {
+        const host = new URL(document.referrer).hostname;
+        return host === window.location.hostname ? "internal" : host;
+    }
+    catch {
+        return "unknown";
+    }
+}
+/**
+ * The only client island analytics needs. Everything it wraps stays server
+ * rendered; this adds one delegated listener (capture phase, never cancelling
+ * the navigation) and a page-view beacon. With no key it sends nothing, and it
+ * writes no cookie. `target` is plain data from the server layout — the key
+ * is read from the container when the page renders, never inlined.
+ */
+export function AnalyticsBoundary({ target, placeSlug, children }) {
+    // On the target's values: a server layout hands a fresh object every render.
+    const { key, host, brandId } = target;
+    const sink = useMemo(() => analyticsSink({ key, host, brandId }, placeSlug), [key, host, brandId, placeSlug]);
+    const pathname = usePathname();
+    useEffect(() => {
+        if (!countsAsPageView(pathname))
+            return;
+        sink.capture(EVENTS.pageView, {
+            source: source(),
+            device: window.matchMedia("(max-width: 767px)").matches ? "mobile" : "desktop",
+        });
+    }, [sink, pathname]);
+    useEffect(() => {
+        const onClick = (event) => {
+            const el = event.target instanceof Element ? event.target.closest(`[${INTENT_ATTR}]`) : null;
+            const channel = el?.getAttribute(INTENT_ATTR);
+            if (channel && INTENTS.some(i => i === channel))
+                sink.capture(EVENTS.intent, { channel }, { transport: "beacon" });
+        };
+        document.addEventListener("click", onClick, { capture: true });
+        return () => document.removeEventListener("click", onClick, { capture: true });
+    }, [sink]);
+    return (_jsx(ContactLinkTracker, { channels: ["phone", "whatsapp"], onContact: ({ channel }) => sink.capture(EVENTS.intent, { channel }, { transport: "beacon" }), children: children }));
+}

package/dist/react/AreaChips.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Where the van goes, as chips. A visitor's first question is whether you
+ * come to them at all; a service-area business has no map to show instead.
+ */
+export declare function AreaChips({ areas, className }: {
+    areas: readonly string[];
+    className?: string;
+}): import("react").JSX.Element | null;

package/dist/react/AreaChips.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from "@evinvest/uikit";
+/**
+ * Where the van goes, as chips. A visitor's first question is whether you
+ * come to them at all; a service-area business has no map to show instead.
+ */
+export function AreaChips({ areas, className }) {
+    if (areas.length === 0)
+        return null;
+    return (_jsx("ul", { className: cn("flex flex-wrap gap-2 md:gap-2.5", className), children: areas.map(area => (_jsx("li", { className: "rounded-full border border-border bg-muted px-4 py-2 text-sm font-medium text-ink-mid", children: area }, area))) }));
+}

package/dist/react/CallBar.d.ts

@@ -0,0 +1,29 @@
+import type { CallBarText, CopySlice } from "../core/content.js";
+import type { PartClassNames } from "./parts.js";
+export type CallBarPart = "call" | "whatsapp" | "quote";
+/**
+ * Pinned to the bottom, mobile only. The header scrolls away with the hero,
+ * so without this there is no contact channel on a phone between the hero and
+ * the closing band. `sticky`, not `fixed`: it is the last thing in the flow,
+ * so it reserves its own height instead of the page guessing it back.
+ *
+ * The form and WhatsApp lead; the phone keeps a square of its own. A channel
+ * the place does not have is left out, never rendered dead.
+ */
+export interface CallBarProps<L extends string, F> {
+    copy: CopySlice<L, CallBarText<F>, F>;
+    phone: string | null;
+    whatsapp: string | null;
+    /** Where the form is: `view.href("#quote")`. */
+    quoteHref: string;
+    /** The bar's accessible name: "Contact". */
+    label: string;
+    /** For a page that anchors or shoots the bar (`#callbar` in e2e). */
+    id?: string;
+    className?: string;
+    /** The brand's CTA face (type, weight), applied to every button. */
+    buttonClassName?: string;
+    /** Per button, after `buttonClassName`: the geometry of each channel. */
+    classNames?: PartClassNames<CallBarPart>;
+}
+export declare function CallBar<L extends string, F>({ copy, phone, whatsapp, quoteHref, label, id, className, buttonClassName, classNames: c }: CallBarProps<L, F>): import("react").JSX.Element;

package/dist/react/CallBar.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { telHref, whatsappHref } from "@evinvest/marketing";
+import { Button, cn } from "@evinvest/uikit";
+export function CallBar({ copy, phone, whatsapp, quoteHref, label, id, className, buttonClassName, classNames: c }) {
+    const { t, f } = copy;
+    return (_jsxs("nav", { id: id, "aria-label": label, className: cn("sticky bottom-0 z-30 flex gap-2 border-t border-border bg-background px-3 py-2.5 shadow-overlay md:hidden", className), children: [phone && (_jsx(Button, { href: telHref(phone), size: "xl", variant: "outline", "aria-label": t.callLabel(f), className: cn("shrink-0 px-4", buttonClassName, c?.call), children: _jsx("span", { "aria-hidden": "true", children: "\u260E" }) })), whatsapp && (_jsx(Button, { href: whatsappHref(whatsapp, t.whatsappMessage(f)), size: "xl", variant: "outline", className: cn("flex-1 px-3", buttonClassName, c?.whatsapp), children: t.whatsappShort })), _jsx(Button, { href: quoteHref, size: "xl", "data-intent": "form_open", className: cn("flex-1 px-3", buttonClassName, c?.quote), children: t.ctaShort })] }));
+}

package/dist/react/Coverage.d.ts

@@ -0,0 +1,24 @@
+import type { ReactNode } from "react";
+import { type Place } from "../core/place/types.js";
+import type { PartClassNames } from "./parts.js";
+export type CoveragePart = "chips" | "landmark" | "map";
+/**
+ * Where a place works: its communes as chips, and — for a storefront only —
+ * its landmark and a map behind a click. A service-area business has no
+ * address in its type, so it gets neither, by construction. The band around
+ * it (a `Section`, a heading) is the brand's.
+ */
+export interface CoverageProps<L extends string> {
+    place: Place<L>;
+    locale: L;
+    /** The map button's words; the map is left out when absent. */
+    map?: {
+        title: string;
+        show: string;
+    };
+    /** Anything the brand puts above the chips: its section head. */
+    head?: ReactNode;
+    className?: string;
+    classNames?: PartClassNames<CoveragePart>;
+}
+export declare function Coverage<L extends string>({ place, locale, map, head, className, classNames: c }: CoverageProps<L>): import("react").JSX.Element;

package/dist/react/Coverage.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "@evinvest/uikit";
+import { servedLocalities, storefrontOf } from "../core/place/types.js";
+import { AreaChips } from "./AreaChips.js";
+import { MapFacade } from "./MapFacade.js";
+export function Coverage({ place, locale, map, head, className, classNames: c }) {
+    const front = storefrontOf(place);
+    const address = front && `${front.address.street}, ${front.address.postalCode} ${front.address.locality}`;
+    return (_jsxs("div", { className: cn("flex flex-col gap-6 md:gap-8", className), children: [head, _jsx(AreaChips, { areas: servedLocalities(place), ...(c?.chips ? { className: c.chips } : {}) }), front?.landmark && _jsx("p", { className: cn("text-sm text-ink-soft", c?.landmark), children: front.landmark[locale] }), address && map && _jsx(MapFacade, { query: `${place.gbpName}, ${address}`, title: map.title, show: map.show, address: address, ...(c?.map ? { className: c.map } : {}) })] }));
+}

package/dist/react/Faq.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from "react";
+import type { QuestionAnswer } from "../core/seo/ld.js";
+import type { PartClassNames } from "./parts.js";
+export type FaqPart = "list" | "item" | "summary" | "question" | "icon" | "answer";
+/**
+ * `<details>`, not an accordion component: it opens without hydration, is
+ * keyboard- and screen-reader-correct for free, and the FAQPage JSON-LD
+ * (`faqPageNode`) reads the same strings.
+ */
+export interface FaqProps {
+    items: readonly QuestionAnswer[];
+    head?: ReactNode;
+    id?: string;
+    className?: string;
+    classNames?: PartClassNames<FaqPart>;
+}
+export declare function Faq({ items, head, id, className, classNames: c }: FaqProps): import("react").JSX.Element;

package/dist/react/Faq.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "@evinvest/uikit";
+export function Faq({ items, head, id = "faq", className, classNames: c }) {
+    return (_jsxs("div", { id: id, className: cn("flex flex-col gap-6 md:gap-11", className), children: [head, _jsx("div", { className: cn("overflow-hidden rounded-xl border border-border bg-background", c?.list), children: items.map(item => (_jsxs("details", { className: cn("group border-b border-border last:border-b-0", c?.item), children: [_jsxs("summary", { className: cn("flex cursor-pointer list-none items-start gap-4 px-5 py-5 md:px-8 md:py-6 [&::-webkit-details-marker]:hidden", c?.summary), children: [_jsx("span", { className: cn("flex-1 font-display text-lg font-bold leading-snug text-ink", c?.question), children: item.q }), _jsx("span", { className: cn("text-lg text-primary-ink transition-transform group-open:rotate-45", c?.icon), "aria-hidden": "true", children: "+" })] }), _jsx("p", { className: cn("px-5 pb-5 text-base leading-relaxed text-ink-soft md:px-8 md:pb-6", c?.answer), children: item.a })] }, item.q))) })] }));
+}

package/dist/react/LangSwitch.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `FR · EN`, each linking to the same page in that language. The `?lang=` is
+ * what mints the cookie in the proxy, so the choice survives the next bare
+ * visit and the negotiator stops fighting the visitor — with no JavaScript.
+ * A screen reader hears each language's own name, not its code.
+ */
+export interface LangSwitchProps<L extends string> {
+    current: L;
+    /** Switcher order: the registry's `locales`. */
+    locales: readonly L[];
+    /** The page's URL in each language, before `?lang=` is added; may carry a query or `#`. */
+    hrefs: Readonly<Record<L, string>>;
+    /** Each language's name in itself — the registry's `labels`. Codes when absent. */
+    labels?: Readonly<Record<L, string>>;
+    /** The navigation's accessible name. */
+    label?: string;
+    className?: string;
+}
+/**
+ * `href` with `lang=<locale>` set, keeping its query and fragment — and its
+ * origin when it has one: a place's page in path mode links to another host.
+ */
+export declare function withLang(href: string, locale: string): string;
+export declare function LangSwitch<L extends string>({ current, locales, hrefs, labels, label, className }: LangSwitchProps<L>): import("react").JSX.Element;

package/dist/react/LangSwitch.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "@evinvest/uikit";
+/**
+ * `href` with `lang=<locale>` set, keeping its query and fragment — and its
+ * origin when it has one: a place's page in path mode links to another host.
+ */
+export function withLang(href, locale) {
+    const url = new URL(href, "https://x.invalid");
+    url.searchParams.set("lang", locale);
+    const rest = `${url.pathname}${url.search}${url.hash}`;
+    if (href.startsWith("//"))
+        return `//${url.host}${rest}`;
+    return /^[a-z][a-z0-9+.-]*:/i.test(href) ? `${url.origin}${rest}` : rest;
+}
+export function LangSwitch({ current, locales, hrefs, labels, label = "Language", className }) {
+    return (_jsx("nav", { "aria-label": label, className: cn("flex items-center gap-1.5", className), children: locales.map((locale, i) => (_jsxs("span", { className: "flex items-center gap-1.5", children: [i > 0 && (_jsx("span", { "aria-hidden": "true", className: "opacity-40", children: "\u00B7" })), _jsx("a", { href: withLang(hrefs[locale], locale), hrefLang: locale, lang: locale, "aria-label": labels?.[locale], "aria-current": locale === current ? "true" : undefined, className: locale === current ? "font-semibold" : "opacity-60 hover:opacity-100", children: locale.toUpperCase() })] }, locale))) }));
+}

package/dist/react/MapFacade.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Google's map behind a click. Until the visitor asks, the page holds a button
+ * and nothing else — no Google request, no cookie — so a cookieless page stays
+ * cookieless and the first load carries no map. The keyless `output=embed`
+ * URL needs no API key in the build.
+ */
+export interface MapFacadeProps {
+    /** What Google searches for: the place's GBP name and address. */
+    query: string;
+    /** The iframe's accessible title. */
+    title: string;
+    /** The button's call to action. */
+    show: string;
+    /** The address, printed under the call to action. */
+    address: string;
+    className?: string;
+}
+export declare function MapFacade({ query, title, show, address, className }: MapFacadeProps): import("react").JSX.Element;

package/dist/react/MapFacade.js

@@ -0,0 +1,8 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ClickToLoad } from "@evinvest/marketing/click-to-load";
+import { cn } from "@evinvest/uikit";
+export function MapFacade({ query, title, show, address, className }) {
+    const src = `https://www.google.com/maps?q=${encodeURIComponent(query)}&output=embed`;
+    return (_jsx(ClickToLoad, { className: cn("relative aspect-video w-full overflow-hidden rounded-xl border border-border bg-muted md:aspect-[21/9]", className), placeholder: load => (_jsxs("button", { type: "button", onClick: load, className: "flex size-full flex-col items-center justify-center gap-2 px-6 text-center hover:bg-hover", children: [_jsx("span", { className: "font-display text-lg font-bold text-ink", children: show }), _jsx("span", { className: "text-sm text-ink-soft", children: address })] })), children: _jsx("iframe", { title: title, src: src, loading: "lazy", referrerPolicy: "no-referrer-when-downgrade", className: "absolute inset-0 size-full border-0" }) }));
+}

package/dist/react/PlaceDirectory.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from "react";
+import { type Place } from "../core/place/types.js";
+import type { PartClassNames } from "./parts.js";
+export type PlaceDirectoryPart = "list" | "card" | "name" | "address" | "phone" | "link";
+/**
+ * The apex's one job on a `subdomains` site: send the visitor to their place.
+ * Each card links to the place's canonical home and carries its phone, so the
+ * emergency visitor need not click through at all. A service-area place shows
+ * no address.
+ */
+export interface PlaceDirectoryProps<L extends string> {
+    places: readonly Place<L>[];
+    locale: L;
+    /** Each place's canonical home: `placeUrl(site, slug, locale, "")`. */
+    hrefOf: (place: Place<L>) => string;
+    /** Each place's phone: `contactOf(site, place).phone`. */
+    phoneOf: (place: Place<L>) => string | null;
+    /** The link's label: "Open the page". */
+    openLabel: string;
+    head?: ReactNode;
+    id?: string;
+    className?: string;
+    classNames?: PartClassNames<PlaceDirectoryPart>;
+}
+export declare function PlaceDirectory<L extends string>(props: PlaceDirectoryProps<L>): import("react").JSX.Element;

package/dist/react/PlaceDirectory.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "@evinvest/uikit";
+import { telHref } from "@evinvest/marketing";
+import { storefrontOf } from "../core/place/types.js";
+export function PlaceDirectory(props) {
+    const { places, head, id = "points", className } = props;
+    return (_jsxs("div", { id: id, className: cn("flex flex-col gap-7 md:gap-10", className), children: [head, _jsx("ul", { className: cn("grid gap-4 sm:grid-cols-2 lg:grid-cols-3", props.classNames?.list), children: places.map(place => (_jsx(PlaceCard, { place: place, ...props }, place.slug))) })] }));
+}
+function PlaceCard({ place, locale, hrefOf, phoneOf, openLabel, classNames: c }) {
+    const phone = phoneOf(place);
+    const front = storefrontOf(place);
+    return (_jsxs("li", { className: cn("flex flex-col gap-3 rounded-xl border border-border bg-card p-6 md:p-7", c?.card), children: [_jsx("p", { className: cn("font-display text-xl font-bold text-ink", c?.name), children: place.name[locale] }), front && (_jsxs("address", { className: cn("text-sm not-italic leading-relaxed text-ink-soft", c?.address), children: [front.address.street, _jsx("br", {}), front.address.postalCode, " ", front.address.locality] })), phone && (_jsx("a", { href: telHref(phone), className: cn("font-display text-lg font-bold text-primary-ink", c?.phone), children: phone })), _jsxs("a", { href: hrefOf(place), className: cn("mt-auto text-sm font-medium text-ink underline-offset-4 hover:underline", c?.link), children: [openLabel, " \u2192"] })] }));
+}

package/dist/react/QuoteFormShell.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from "react";
+/**
+ * The quote form's frame: a plain `<form method="post" action="/quote">`
+ * answered with a 303, so it works before any JavaScript arrives — which is
+ * when the visitor standing in water submits it. The shell owns what the
+ * funnel reads (the hidden place, locale, form id and render stamp, and the
+ * honeypot); the visible fields and the submit button are the brand's
+ * `children`, named after `site.lead.wire`.
+ */
+export interface QuoteFormShellProps {
+    /** The place the lead is for, or `null` on the brand's own pages. */
+    placeSlug: string | null;
+    locale: string;
+    /**
+     * When the page rendered, ms since the epoch: the time trap's stamp. Under
+     * ISR that is when the cache was filled, not when the visitor arrived — so
+     * the stamp only ever marks a lead `too-fast`, it never withholds one.
+     */
+    renderedAt: number;
+    /** The honeypot's label — read only by a bot filling every field. */
+    honeypotLabel: string;
+    formId?: string;
+    action?: string;
+    id?: string;
+    className?: string;
+    children: ReactNode;
+}
+/** The mobile field's attributes: the numeric keypad and the phone's autofill. */
+export declare const PHONE_INPUT_PROPS: {
+    readonly type: "tel";
+    readonly inputMode: "tel";
+    readonly autoComplete: "tel";
+};
+export declare function QuoteFormShell(props: QuoteFormShellProps): import("react").JSX.Element;

package/dist/react/QuoteFormShell.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "@evinvest/uikit";
+import { FORM_ID_FIELD, LOCALE_FIELD, LOCATION_FIELD } from "../core/accept.js";
+import { HONEYPOT_FIELD, RENDERED_AT_FIELD } from "../core/antispam.js";
+/** The mobile field's attributes: the numeric keypad and the phone's autofill. */
+export const PHONE_INPUT_PROPS = { type: "tel", inputMode: "tel", autoComplete: "tel" };
+export function QuoteFormShell(props) {
+    const { placeSlug, locale, renderedAt, honeypotLabel, formId = "quote", action = "/quote", id = "quote", className, children } = props;
+    return (_jsxs("form", { id: id, method: "post", action: action, className: cn("relative flex w-full flex-col gap-5", className), children: [placeSlug && _jsx("input", { type: "hidden", name: LOCATION_FIELD, value: placeSlug }), _jsx("input", { type: "hidden", name: LOCALE_FIELD, value: locale }), _jsx("input", { type: "hidden", name: FORM_ID_FIELD, value: formId }), _jsx("input", { type: "hidden", name: RENDERED_AT_FIELD, value: String(renderedAt) }), children, _jsx("div", { "aria-hidden": "true", style: { position: "absolute", left: "-10000px", width: 1, height: 1, overflow: "hidden" }, children: _jsxs("label", { children: [honeypotLabel, _jsx("input", { type: "text", name: HONEYPOT_FIELD, tabIndex: -1, autoComplete: "off", defaultValue: "" })] }) })] }));
+}

package/dist/react/StatusScreen.d.ts

@@ -0,0 +1,36 @@
+import type { ReactNode } from "react";
+import type { CopySlice, StatusCopy, StatusScreenText } from "../core/content.js";
+import type { StatusTarget } from "../core/status.js";
+import type { PartClassNames } from "./parts.js";
+export type StatusScreenPart = "header" | "logo" | "phone" | "main" | "eyebrow" | "code" | "headline" | "body" | "actions" | "primaryButton" | "secondaryButton" | "strip" | "footer";
+/**
+ * The 404, the 500 and the post-submit confirmation: one screen over a
+ * `StatusCopy`, differing only in eyebrow, numeral, headline and buttons. A
+ * visitor who hit a 404 still gets the offer — the strip is the hero's terms,
+ * compressed — and the phone is always one tap away.
+ *
+ * Renders on either side: the error boundary is a client component, so this
+ * takes the brand's name and marks as props, never the site config.
+ *
+ * It sets its own `text-ink`: shown on a polarity other than the page's (a
+ * dark screen in a light site), anything uncoloured inside — the outline
+ * button's label — would inherit the `<body>`'s ink and vanish at 1:1.
+ */
+export interface StatusScreenProps<L extends string, F> {
+    copy: CopySlice<L, StatusScreenText<F>, F>;
+    status: StatusCopy<F>;
+    target: Pick<StatusTarget<L>, "phone" | "home" | "retry" | "langHrefs">;
+    locales: readonly L[];
+    /** Each language's name in itself, for the switch. */
+    labels?: Readonly<Record<L, string>>;
+    /** The accessible name of the home link around `logo`. */
+    brandName: string;
+    /** The brand's lock-up, in the header. */
+    logo?: ReactNode;
+    /** The brand's mark, above the eyebrow. */
+    mark?: ReactNode;
+    className?: string;
+    buttonClassName?: string;
+    classNames?: PartClassNames<StatusScreenPart>;
+}
+export declare function StatusScreen<L extends string, F>(props: StatusScreenProps<L, F>): import("react").JSX.Element;

package/dist/react/StatusScreen.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { telHref } from "@evinvest/marketing";
+import { Button, Check, cn } from "@evinvest/uikit";
+import { LangSwitch } from "./LangSwitch.js";
+export function StatusScreen(props) {
+    const { copy, status, target, locales, labels, brandName, logo, mark, className, buttonClassName, classNames: c } = props;
+    const { t, f } = copy;
+    const action = (a) => a === "call"
+        ? target.phone
+            ? { href: telHref(target.phone), label: t.callLabel(f) }
+            : null
+        : a === "home"
+            ? { href: target.home, label: t.backHome }
+            : { href: target.retry, label: t.tryAgain };
+    // A brand with no phone falls back to "home" rather than a dead button.
+    const primary = action(status.primary) ?? action("home");
+    const secondary = action(status.secondary);
+    return (_jsxs("div", { className: cn("relative flex min-h-screen flex-col bg-background text-ink", className), children: [_jsxs("header", { className: cn("relative flex flex-wrap items-center gap-x-4 gap-y-2 border-b border-border px-5 py-3 md:flex-nowrap md:gap-5 md:px-12 md:py-5", c?.header), children: [_jsx("a", { href: target.home, "aria-label": brandName, className: cn("shrink-0 text-ink", c?.logo), children: logo ?? _jsx("span", { className: "font-display text-lg font-bold md:text-xl", children: brandName }) }), _jsx("div", { className: "flex-1" }), _jsx(LangSwitch, { current: copy.locale, locales: locales, hrefs: target.langHrefs, ...(labels ? { labels } : {}), className: "order-last w-full text-sm font-medium text-ink-soft md:order-none md:w-auto" }), target.phone && (_jsx("a", { href: telHref(target.phone), className: cn("whitespace-nowrap font-display text-base font-bold text-primary-ink md:text-xl", c?.phone), children: target.phone }))] }), _jsxs("main", { className: cn("relative flex flex-1 flex-col items-center gap-5 px-5 py-12 text-center md:gap-6 md:py-24", c?.main), children: [mark, _jsx("p", { className: cn("text-xs font-medium tracking-widest text-primary-ink", c?.eyebrow), children: status.eyebrow }), _jsx("p", { className: cn("font-display text-8xl font-bold leading-none tracking-tight text-ink md:text-9xl", c?.code), children: status.code }), _jsxs("h1", { className: cn("font-display text-2xl font-bold leading-snug text-ink md:text-4xl", c?.headline), children: [status.headline[0], _jsx("span", { className: "text-primary-ink", children: status.headline[1] })] }), _jsx("p", { className: cn("max-w-2xl text-base leading-relaxed text-ink-soft md:text-lg", c?.body), children: status.body(f) }), _jsxs("div", { className: cn("flex flex-col gap-3.5 sm:flex-row", c?.actions), children: [primary && (_jsx(Button, { href: primary.href, size: "xl", className: cn(buttonClassName, c?.primaryButton), children: primary.label })), secondary && secondary.href !== primary?.href && (
+                            // The kit's outline border is `--border`, 14 % ink: 1.4:1 on the
+                            // dark polarity. Half ink clears 3:1 for a control on either one.
+                            _jsx(Button, { href: secondary.href, size: "xl", variant: "outline", className: cn("border-ink/50", buttonClassName, c?.secondaryButton), children: secondary.label }))] }), _jsx("ul", { className: cn("flex flex-col items-center gap-3 text-sm sm:flex-row sm:gap-6", c?.strip), children: t.statusStrip.map(term => (_jsxs("li", { className: "flex items-center gap-2", children: [_jsx(Check, {}), _jsx("span", { className: "font-medium text-ink-soft", children: term })] }, term))) })] }), _jsx("footer", { className: cn("relative border-t border-border px-5 py-6 text-xs uppercase tracking-wider text-ink-soft md:px-12 md:py-7", c?.footer), children: _jsx("p", { children: t.facts(f).join(" · ") }) })] }));
+}