@evinvest/kitstart 0.1.0

package/dist/core/seo/ld.js

@@ -0,0 +1,161 @@
+import { ldCompact, localBusiness } from "@evinvest/marketing";
+import { freshRating } from "../place/rating.js";
+import { servedLocalities, storefrontOf } from "../place/types.js";
+import { placeOrigin, siteOrigin } from "../place/view.js";
+import { contactOf } from "../site.js";
+const origin = (o) => o ?? "";
+export const organizationId = (site) => `${origin(siteOrigin(site))}/#organization`;
+// Language-free: the French and the English page describe one business.
+export const businessId = (site, slug) => `${origin(placeOrigin(site, slug))}/#business`;
+export const websiteId = (site, slug) => `${origin(placeOrigin(site, slug))}/#website`;
+export function organizationNode(site) {
+    return ldCompact({
+        "@type": "Organization",
+        "@id": organizationId(site),
+        name: site.brand.name,
+        legalName: site.brand.legalName,
+        url: siteOrigin(site),
+        email: site.brand.email,
+    });
+}
+function days(place) {
+    return place.hours?.map(h => ({
+        "@type": "OpeningHoursSpecification",
+        dayOfWeek: h.days,
+        opens: h.opens,
+        closes: h.closes,
+    }));
+}
+/**
+ * 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 function areaServedNodes(place) {
+    const type = place.presence.kind === "service-area" ? "City" : "Place";
+    const named = servedLocalities(place).map(name => ({ "@type": type, name }));
+    const circles = (place.serviceArea ?? []).flatMap(area => area.kind === "radius"
+        ? [
+            {
+                "@type": "GeoCircle",
+                geoMidpoint: { "@type": "GeoCoordinates", latitude: area.center.lat, longitude: area.center.lng },
+                geoRadius: area.km * 1000,
+            },
+        ]
+        : []);
+    return [...named, ...circles];
+}
+/** The business behind one place. */
+export function businessNode(site, view, now) {
+    const { place } = view;
+    const front = storefrontOf(place);
+    const rating = freshRating(place, now);
+    return localBusiness({
+        id: businessId(site, place.slug),
+        type: site.brand.businessType,
+        name: place.gbpName,
+        url: view.url(site.pages.home),
+        telephone: contactOf(site, place).phone ?? undefined,
+        email: site.brand.email ?? undefined,
+        image: front?.storefrontPhoto ?? undefined,
+        address: front
+            ? {
+                streetAddress: front.address.street,
+                postalCode: front.address.postalCode,
+                addressLocality: front.address.locality,
+                addressRegion: front.address.region,
+                addressCountry: front.address.country,
+            }
+            : undefined,
+        geo: front?.geo ?? undefined,
+        parentOrganization: { "@id": organizationId(site) },
+    }, ldCompact({
+        priceRange: site.brand.priceRange,
+        areaServed: areaServedNodes(place),
+        openingHoursSpecification: days(place),
+        aggregateRating: rating
+            ? { "@type": "AggregateRating", ratingValue: rating.value, reviewCount: rating.count, bestRating: 5 }
+            : undefined,
+    }));
+}
+/** The town an offer is priced for: a storefront's own, or the first commune served. */
+function cityOf(place) {
+    const name = storefrontOf(place)?.address.locality ?? servedLocalities(place)[0];
+    return name === undefined ? undefined : { "@type": "City", name };
+}
+/** One `Service` + `Offer` per price row: the same integer as the table cell, tax included. */
+export function offerNodes(site, place, offers) {
+    return offers.map(row => {
+        const currency = row.currency ?? "EUR";
+        return ldCompact({
+            "@type": "Service",
+            name: row.name,
+            serviceType: row.name,
+            provider: { "@id": businessId(site, place.slug) },
+            areaServed: cityOf(place),
+            offers: {
+                "@type": "Offer",
+                price: row.price,
+                priceCurrency: currency,
+                availability: "https://schema.org/InStock",
+                priceSpecification: {
+                    "@type": "PriceSpecification",
+                    minPrice: row.price,
+                    priceCurrency: currency,
+                    valueAddedTaxIncluded: true,
+                },
+            },
+        });
+    });
+}
+export function faqPageNode(items) {
+    return {
+        "@type": "FAQPage",
+        mainEntity: items.map(item => ({
+            "@type": "Question",
+            name: item.q,
+            acceptedAnswer: { "@type": "Answer", text: item.a },
+        })),
+    };
+}
+/** Home → page. The chain is the route, so a new page cannot forget it. */
+export function breadcrumbNode(site, view, page, copy) {
+    const items = [
+        { "@type": "ListItem", position: 1, name: `${site.brand.name} ${copy.placeName}`, item: view.url(site.pages.home) },
+    ];
+    if (page !== "home") {
+        items.push({ "@type": "ListItem", position: 2, name: copy.title, item: view.url(site.pages[page]) });
+    }
+    return { "@type": "BreadcrumbList", itemListElement: items };
+}
+/** The `@graph` for one of a place's pages in one language. */
+export function placeGraph(site, view, page, copy, now) {
+    const { place } = view;
+    const url = view.url(site.pages[page]);
+    const nodes = [
+        organizationNode(site),
+        businessNode(site, view, now),
+        {
+            "@type": "WebSite",
+            "@id": websiteId(site, place.slug),
+            url: origin(placeOrigin(site, place.slug)),
+            name: `${site.brand.name} ${copy.placeName}`,
+        },
+        {
+            "@type": "WebPage",
+            "@id": `${url}#page`,
+            url,
+            name: copy.title,
+            description: copy.description,
+            inLanguage: site.i18n.hreflangOf(view.locale),
+            isPartOf: { "@id": websiteId(site, place.slug) },
+            about: { "@id": businessId(site, place.slug) },
+        },
+        breadcrumbNode(site, view, page, copy),
+    ];
+    if (copy.offers && copy.offers.length > 0)
+        nodes.push(...offerNodes(site, place, copy.offers));
+    if (copy.faq && copy.faq.length > 0)
+        nodes.push(faqPageNode(copy.faq));
+    return { "@context": "https://schema.org", "@graph": nodes };
+}

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

@@ -0,0 +1,52 @@
+import type { Place } from "../place/types.js";
+import type { Site } from "../site.js";
+/**
+ * One sitemap per host: a sitemap may only list URLs on its own host, and a
+ * place's canonical host is its subdomain (the apex on a `single` site). The
+ * apex of a `subdomains` site lists the brand page.
+ *
+ * Each language version is its own entry, annotated with the whole set
+ * *including itself*. No `lastmod`: a deploy timestamp that moves without the
+ * content moving is a lie. An unpublished place is left out entirely, and a
+ * site with no domain lists nothing.
+ *
+ * Shapes match Next's `MetadataRoute.Sitemap` / `MetadataRoute.Robots`, so
+ * `./next` returns them as they are.
+ */
+export interface SitemapEntry {
+    url: string;
+    priority: number;
+    alternates: {
+        languages: Record<string, string>;
+    };
+}
+export interface RobotsRule {
+    userAgent: string | string[];
+    allow?: string;
+    disallow?: string;
+}
+export interface RobotsFile {
+    rules: RobotsRule[];
+    sitemap?: string;
+}
+/**
+ * The sitemap for a request's host. `places` is the list as the live source
+ * sees it now — the caller fetches it strictly: an unreachable source must
+ * fail the sitemap (a 5xx a crawler retries), never shrink it (a list of
+ * places a crawler drops).
+ */
+export declare function sitemapFor<L extends string, P extends string>(site: Site<L, P>, host: string, places: readonly Place<L>[]): SitemapEntry[];
+/** Crawlers named explicitly: several treat a bare wildcard as ambiguous. */
+export declare const AI_CRAWLERS: string[];
+/**
+ * Allow everything, and point at the host's own sitemap. Unpublished places
+ * are held back by `noindex`, not here, so a crawler can still read the
+ * `noindex`. A site with no domain is not ready to be crawled at all.
+ */
+export declare function robotsFor<L extends string, P extends string>(site: Site<L, P>, host: string): RobotsFile;
+/** The OG card URL: on the apex, so it never needs a rewrite. */
+export declare function ogImageUrl<L extends string, P extends string>(site: Site<L, P>, query: {
+    slug?: string;
+    locale: L;
+    page?: string;
+}): string;

package/dist/core/seo/sitemap.js

@@ -0,0 +1,60 @@
+import { isPublished } from "../place/publication.js";
+import { placeOrigin, siteOrigin } from "../place/view.js";
+import { createRouting } from "../routing.js";
+function cluster(site, origin, suffix, priority) {
+    const languages = site.i18n.languageAlternates(suffix || "/", origin);
+    return site.i18n.locales.map(locale => ({
+        url: `${origin}${site.i18n.localePath(locale, suffix || "/")}`,
+        priority,
+        alternates: { languages },
+    }));
+}
+/**
+ * The sitemap for a request's host. `places` is the list as the live source
+ * sees it now — the caller fetches it strictly: an unreachable source must
+ * fail the sitemap (a 5xx a crawler retries), never shrink it (a list of
+ * places a crawler drops).
+ */
+export function sitemapFor(site, host, places) {
+    const apex = siteOrigin(site);
+    if (apex === null)
+        return [];
+    const slug = createRouting(site).hostSlug(host);
+    if (slug === null)
+        return cluster(site, apex, "", 1);
+    const place = places.find(p => p.slug === slug);
+    const origin = placeOrigin(site, slug);
+    if (!place || origin === null || !isPublished(place, site.publication, site.brand))
+        return [];
+    return site.pageKeys.flatMap(page => cluster(site, origin, site.pages[page], page === "home" ? 1 : 0.8));
+}
+/** Crawlers named explicitly: several treat a bare wildcard as ambiguous. */
+export const AI_CRAWLERS = ["GPTBot", "ClaudeBot", "PerplexityBot", "Google-Extended"];
+/**
+ * Allow everything, and point at the host's own sitemap. Unpublished places
+ * are held back by `noindex`, not here, so a crawler can still read the
+ * `noindex`. A site with no domain is not ready to be crawled at all.
+ */
+export function robotsFor(site, host) {
+    const apex = siteOrigin(site);
+    if (apex === null)
+        return { rules: [{ userAgent: "*", disallow: "/" }] };
+    const slug = createRouting(site).hostSlug(host);
+    const origin = (slug === null ? null : placeOrigin(site, slug)) ?? apex;
+    return {
+        rules: [
+            { userAgent: "*", allow: "/" },
+            { userAgent: [...AI_CRAWLERS], allow: "/" },
+        ],
+        sitemap: `${origin}/sitemap.xml`,
+    };
+}
+/** The OG card URL: on the apex, so it never needs a rewrite. */
+export function ogImageUrl(site, query) {
+    const params = new URLSearchParams({ lang: query.locale });
+    if (query.slug)
+        params.set("l", query.slug);
+    if (query.page)
+        params.set("p", query.page);
+    return `${siteOrigin(site) ?? ""}/og?${params.toString()}`;
+}

package/dist/core/site.d.ts

@@ -0,0 +1,118 @@
+import type { LocaleRegistry } from "@evinvest/i18n";
+import type { LeadSchema } from "./lead.js";
+import type { PublicationPolicy } from "./place/publication.js";
+import type { Place } from "./place/types.js";
+/**
+ * The composition root of a landing site: every brand fact the machinery reads
+ * — routing, the lead funnel, schema.org, analytics, mail — arrives through one
+ * object built by `defineSite`, instead of each slice importing the brand's
+ * constants. Pure: no React, no Next, no `node:*`.
+ */
+export interface BrandFacts {
+    /** `brand_id` in analytics, the `data-brand` palette scope. */
+    id: string;
+    name: string;
+    legalName: string;
+    email: string | null;
+    /** As printed, international; `null` → no `tel:` channel. */
+    phone: string | null;
+    /** The apex; `null` → nothing is indexable and robots disallow everything. */
+    domain: string | null;
+    /** schema.org type of each place's business node: `"Plumber"`, `"LocalBusiness"`… */
+    businessType: string;
+    priceRange?: string;
+}
+/**
+ * How places map onto hosts. `subdomains`: one place per `<slug>.<domain>`,
+ * the apex a directory of them. `single`: the whole site is one place, and
+ * its canonical origin is the apex.
+ */
+export type Topology = {
+    kind: "subdomains";
+    apex: "directory";
+} | {
+    kind: "single";
+    place: string;
+};
+/** A locale- and place-free page suffix: `""` is home, `"/prices"` a subpage. */
+export type PageSuffix = `/${string}` | "";
+/**
+ * A path an earlier site served. `to` gets the path's locale prefix (`null`
+ * when unprefixed) and answers where it moved, or `null` when that twin is
+ * still a live page.
+ */
+export interface LegacyRedirect<L extends string> {
+    from: string;
+    to: (locale: L | null) => string | null;
+}
+export interface SiteConfig<L extends string, P extends string> {
+    brand: BrandFacts;
+    i18n: LocaleRegistry<L>;
+    /**
+     * `og:locale` per language — a region is required there, unlike `hreflang`.
+     * A locale left out is derived from its `hreflang` (`fr-FR` → `fr_FR`).
+     */
+    ogLocale?: Readonly<Partial<Record<L, string>>>;
+    topology: Topology;
+    /** Every indexable page of a place; `home` is required. */
+    pages: Readonly<Record<P | "home", PageSuffix>>;
+    /** Every place the site has, baked; a live source may overlay them. */
+    places: readonly Place<L>[];
+    /** Which fields a place must fill before it may be indexed. */
+    publication: PublicationPolicy;
+    /** What the quote form asks and what a lead must have. */
+    lead: LeadSchema<string>;
+    legacyRedirects?: readonly LegacyRedirect<L>[];
+    /**
+     * Paths the brand serves as files besides the routes every landing has
+     * (`NON_PAGE_ROUTES`): what is in `public/` and the app-root metadata files
+     * (`/icon.svg`, `/favicon.ico`). Exact paths; any other path is a page or
+     * the 404, with or without an extension. `describeLandingContract` with
+     * `root` checks the list against the tree.
+     */
+    publicFiles?: readonly string[];
+}
+export interface Site<L extends string, P extends string = string> extends SiteConfig<L, P> {
+    /** Page keys in declaration order, `home` first as declared. */
+    readonly pageKeys: readonly (P | "home")[];
+    readonly placeSlugs: readonly string[];
+}
+export declare function defineSite<const L extends string, const P extends string>(config: SiteConfig<L, P>): Site<L, P>;
+/** One value per locale of the site, in its order. */
+export declare function perLocale<L extends string, T>(site: {
+    i18n: LocaleRegistry<L>;
+}, fn: (locale: L) => T): Record<L, T>;
+/** `og:locale` for a language: the configured one, else its `hreflang` with `_`. */
+export declare function ogLocaleOf<L extends string>(site: Pick<SiteConfig<L, string>, "i18n" | "ogLocale">, locale: L): string;
+/**
+ * A card fact `withLanding` inlined at build (`process.env.SITE_CARD_PHONE`…):
+ * `""` is a fact the card leaves out, `undefined` a build that skipped the
+ * card — and a site that silently lost its phone number is worse than one that
+ * does not build.
+ */
+export declare function cardFact(name: string, value: string | undefined): string | null;
+/**
+ * A fact the owner has not supplied yet, rendered as a placeholder until then.
+ * Listed once in the brand's `site.ts`, instead of discovered on the page.
+ */
+export interface OwnerTodo {
+    field: string;
+    why: string;
+    /** A domain (launch) is refused while any of these is open. */
+    blocksLaunch: boolean;
+}
+/** The owner facts that stand between the site and a domain. */
+export declare function openLaunchBlockers(todos: readonly OwnerTodo[]): OwnerTodo[];
+/** Throws while a blocking owner fact is open and the site has a domain. */
+export declare function assertLaunchable(site: {
+    brand: {
+        domain: string | null;
+    };
+}, todos: readonly OwnerTodo[]): void;
+/** The baked place for a slug, if the site has it. */
+export declare function bakedPlace<L extends string, P extends string>(site: Site<L, P>, slug: string): Place<L> | undefined;
+/** The numbers a place answers on: its own, or the brand's until it has one. */
+export declare function contactOf(site: Pick<SiteConfig<string, string>, "brand">, place: Place<string>): {
+    phone: string | null;
+    whatsapp: string | null;
+};

package/dist/core/site.js

@@ -0,0 +1,84 @@
+export function defineSite(config) {
+    const pageKeys = Object.keys(config.pages).filter((k) => Object.hasOwn(config.pages, k));
+    if (!pageKeys.includes("home"))
+        throw new Error("defineSite: pages.home is required");
+    for (const key of pageKeys) {
+        // One spelling per page: `/prices/` would be a second URL for `/prices`.
+        const suffix = config.pages[key];
+        if (suffix.endsWith("/") || suffix.includes("//"))
+            throw new Error(`defineSite: page "${key}" suffix "${suffix}" must not end in "/"`);
+    }
+    const placeSlugs = config.places.map(p => p.slug);
+    const dup = placeSlugs.find((s, i) => placeSlugs.indexOf(s) !== i);
+    if (dup !== undefined)
+        throw new Error(`defineSite: place slug "${dup}" is listed twice`);
+    for (const slug of placeSlugs) {
+        // The host-mode route param is `_<slug>`; a slug starting with the mark
+        // would read back as a different place.
+        if (!/^[a-z0-9][a-z0-9-]*$/.test(slug))
+            throw new Error(`defineSite: place slug "${slug}" must be [a-z0-9-], not starting with "-"`);
+        // `/<locale>/404/404` is the proxy's route to the 404 (see `GONE`).
+        if (slug === "404")
+            throw new Error(`defineSite: place slug "404" is reserved for the 404 route`);
+    }
+    for (const file of config.publicFiles ?? []) {
+        if (!file.startsWith("/") || file.endsWith("/") || file.startsWith("/_next/"))
+            throw new Error(`defineSite: public file "${file}" must be a path like "/icon.svg"`);
+        // `decide` passes a file only without a language: under one it is a page path.
+        if (config.i18n.isLocale(file.split("/")[1] ?? ""))
+            throw new Error(`defineSite: public file "${file}" must not sit under a language`);
+    }
+    if (config.topology.kind === "single" && !placeSlugs.includes(config.topology.place)) {
+        throw new Error(`defineSite: topology.place "${config.topology.place}" is not one of the places`);
+    }
+    return { ...config, pageKeys, placeSlugs };
+}
+/** One value per locale of the site, in its order. */
+export function perLocale(site, fn) {
+    const out = {};
+    for (const locale of site.i18n.locales)
+        out[locale] = fn(locale);
+    if (!isComplete(out, site.i18n.locales))
+        throw new Error("perLocale: a locale produced no value");
+    return out;
+}
+function isComplete(record, locales) {
+    return locales.every(locale => Object.hasOwn(record, locale));
+}
+/** `og:locale` for a language: the configured one, else its `hreflang` with `_`. */
+export function ogLocaleOf(site, locale) {
+    return site.ogLocale?.[locale] ?? site.i18n.hreflangOf(locale).replace("-", "_");
+}
+/**
+ * A card fact `withLanding` inlined at build (`process.env.SITE_CARD_PHONE`…):
+ * `""` is a fact the card leaves out, `undefined` a build that skipped the
+ * card — and a site that silently lost its phone number is worse than one that
+ * does not build.
+ */
+export function cardFact(name, value) {
+    if (value === undefined)
+        throw new Error(`${name} was not inlined — build through withLanding (next.config.ts)`);
+    return value === "" ? null : value;
+}
+/** The owner facts that stand between the site and a domain. */
+export function openLaunchBlockers(todos) {
+    return todos.filter(t => t.blocksLaunch);
+}
+/** Throws while a blocking owner fact is open and the site has a domain. */
+export function assertLaunchable(site, todos) {
+    const open = openLaunchBlockers(todos);
+    if (site.brand.domain !== null && open.length > 0) {
+        throw new Error(`not launchable: ${open.map(t => `${t.field} (${t.why})`).join("; ")}`);
+    }
+}
+/** The baked place for a slug, if the site has it. */
+export function bakedPlace(site, slug) {
+    return site.places.find(p => p.slug === slug);
+}
+/** The numbers a place answers on: its own, or the brand's until it has one. */
+export function contactOf(site, place) {
+    return {
+        phone: place.channels.phone ?? site.brand.phone,
+        whatsapp: place.channels.whatsapp ?? site.brand.phone,
+    };
+}

package/dist/core/status.d.ts

@@ -0,0 +1,47 @@
+import type { Place } from "./place/types.js";
+import { type Site } from "./site.js";
+/**
+ * Where a status screen's buttons go and which phone it prints. Every
+ * status page — the 404, the 500, the thank-you page — answers in the page's
+ * language with the right place's phone, and its language switch goes home
+ * (a dead URL has no twin in the other language).
+ */
+export interface StatusTarget<L extends string> {
+    locale: L;
+    /** The place the URL named, baked, or `null` for the brand's own pages. */
+    place: Place<L> | null;
+    phone: string | null;
+    home: string;
+    /** Where "try again" goes. */
+    retry: string;
+    langHrefs: Record<L, string>;
+}
+/**
+ * The brand's own status target from two facts — for a client boundary
+ * (`error.tsx`, the `notFound()` boundary), which must not import the site
+ * config: it would carry every place into every page's bundle.
+ */
+export declare function brandStatusTarget<L extends string>(facts: {
+    locales: readonly L[];
+    phone: string | null;
+}, locale: L, options?: {
+    retry?: string;
+    thanks?: boolean;
+}): StatusTarget<L>;
+/**
+ * Server side — the global not-found page, a thank-you page: the target for
+ * the place the params name. Not for a client module (see
+ * {@link brandStatusTarget}).
+ *
+ * Read from the route params alone — `useParams()` in a client boundary, or a
+ * page's `params` — never from the request: a not-found boundary is rendered
+ * into every cached page, and a `headers()` there would make each one
+ * per-request again. The link mode rides in the `location` param (`_royat`).
+ */
+export declare function statusTarget<L extends string, P extends string>(site: Site<L, P>, params: {
+    locale?: string | string[] | undefined;
+    location?: string | string[] | undefined;
+}, options?: {
+    retry?: string;
+    thanks?: boolean;
+}): StatusTarget<L>;

package/dist/core/status.js

@@ -0,0 +1,62 @@
+import { createPlaceView } from "./place/view.js";
+import { parsePlaceParam, THANKS } from "./routing.js";
+import { bakedPlace, contactOf, perLocale } from "./site.js";
+function complete(r, locales) {
+    return locales.every(l => typeof r[l] === "string");
+}
+/**
+ * The brand's own status target from two facts — for a client boundary
+ * (`error.tsx`, the `notFound()` boundary), which must not import the site
+ * config: it would carry every place into every page's bundle.
+ */
+export function brandStatusTarget(facts, locale, options = {}) {
+    const suffix = options.thanks ? THANKS : "";
+    const langHrefs = {};
+    for (const l of facts.locales)
+        langHrefs[l] = `/${l}${suffix}`;
+    if (!complete(langHrefs, facts.locales))
+        throw new Error("brandStatusTarget: a locale was skipped");
+    return {
+        locale,
+        place: null,
+        phone: facts.phone,
+        home: `/${locale}`,
+        retry: options.retry ?? `/${locale}`,
+        langHrefs,
+    };
+}
+/**
+ * Server side — the global not-found page, a thank-you page: the target for
+ * the place the params name. Not for a client module (see
+ * {@link brandStatusTarget}).
+ *
+ * Read from the route params alone — `useParams()` in a client boundary, or a
+ * page's `params` — never from the request: a not-found boundary is rendered
+ * into every cached page, and a `headers()` there would make each one
+ * per-request again. The link mode rides in the `location` param (`_royat`).
+ */
+export function statusTarget(site, params, options = {}) {
+    const locale = typeof params.locale === "string" && site.i18n.isLocale(params.locale) ? params.locale : site.i18n.defaultLocale;
+    const suffix = options.thanks ? THANKS : "";
+    const param = typeof params.location === "string" ? parsePlaceParam(params.location) : null;
+    const place = param ? (bakedPlace(site, param.slug) ?? null) : null;
+    if (place && param) {
+        const view = createPlaceView(site, place, locale, param.mode);
+        return {
+            locale,
+            place,
+            phone: contactOf(site, place).phone,
+            home: view.href(""),
+            retry: options.retry ?? view.href(""),
+            langHrefs: perLocale(site, l => view.href(suffix, l)),
+        };
+    }
+    return {
+        locale,
+        place: null,
+        phone: site.brand.phone,
+        home: `/${locale}`,
+        retry: options.retry ?? `/${locale}`,
+        langHrefs: perLocale(site, l => `/${l}${suffix}`),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `@evinvest/kitstart` — the core. Pure: no React, no Next, no `node:*`, so
+ * the proxy (edge), a client island and a server module can all import it.
+ * Runtime-bound halves live on their own subpaths.
+ */
+export { assertLaunchable, bakedPlace, cardFact, contactOf, defineSite, ogLocaleOf, openLaunchBlockers, perLocale, type BrandFacts, type LegacyRedirect, type OwnerTodo, type PageSuffix, type Site, type SiteConfig, type Topology, } from "./core/site.js";
+export { createPlaceView, freshRating, parseInstant, isPublished, mergeLive, parsePlaceLive, placeHref, placeOrigin, placeUrl, publicationGaps, RATING_MAX_AGE_DAYS, servedLocalities, SERVICE_AREA_GATE, siteOrigin, STOREFRONT_GATE, storefrontOf, type DayOfWeek, type Geo, type LinkBase, type LinkMode, type OpeningHours, type OriginFacts, type Place, type PlaceLive, type PlaceView, type PostalAddress, type Presence, type PublicationField, type PublicationPolicy, type Rating, type ServiceArea, } from "./core/place/index.js";
+export { createRouting, GONE, GONE_HEADER, gonePath, goneHeader, HOST_MARK, LANG_COOKIE, LANG_COOKIE_MAX_AGE, NON_PAGE_ROUTES, parseGoneHeader, parsePlaceParam, PASS_PATHS, placeParam, pointSuffixes, THANKS, type Decision, type RequestFacts, type Routing, } from "./core/routing.js";
+export { LEAD_SCHEMA_VERSION, MAX_FIELD, readCandidate, validateCandidate, type Lead, type LeadCandidate, type LeadExtra, type LeadSchema, type LeadStore, type LeadWire, type SpamVerdict, } from "./core/lead.js";
+export { checkTiming, HONEYPOT_FIELD, LEGACY_HONEYPOT_FIELDS, MIN_FILL_MS, RATE_LIMIT_MAX_KEYS, RateLimiter, RENDERED_AT_FIELD, screen, type Screening, } from "./core/antispam.js";
+export { createAcceptLead, FORM_ID_FIELD, LOCALE_FIELD, LOCATION_FIELD, type AcceptDeps, type Outcome, } from "./core/accept.js";
+export { areaServedNodes, breadcrumbNode, businessId, businessNode, faqPageNode, offerNodes, organizationId, organizationNode, placeGraph, websiteId, type OfferInput, type PageGraphCopy, type QuestionAnswer, } from "./core/seo/ld.js";
+export { AI_CRAWLERS, ogImageUrl, robotsFor, sitemapFor, type RobotsFile, type RobotsRule, type SitemapEntry, } from "./core/seo/sitemap.js";
+export { ALLOWED_PROPS, analyticsSink, countsAsPageView, EVENTS, type AnalyticsTarget, type IntentChannel, } from "./core/analytics.js";
+export type { CallBarText, CopySlice, CoreText, PageMetaCopy, QuoteFormCopy, Said, StatusAction, StatusCopy, StatusScreenText, } from "./core/content.js";
+export { brandStatusTarget, statusTarget, type StatusTarget } from "./core/status.js";
+export { createLocaleRegistry, type LocaleRegistry } from "@evinvest/i18n";
+export { contactChannel, ldCompact, localBusiness, telHref, whatsappHref, type ContactChannel, type JsonLdNode, } from "@evinvest/marketing";
+export { createBeaconSink, noopSink, type AnalyticsSink } from "@evinvest/analytics";

package/dist/index.js

@@ -0,0 +1,20 @@
+/**
+ * `@evinvest/kitstart` — the core. Pure: no React, no Next, no `node:*`, so
+ * the proxy (edge), a client island and a server module can all import it.
+ * Runtime-bound halves live on their own subpaths.
+ */
+export { assertLaunchable, bakedPlace, cardFact, contactOf, defineSite, ogLocaleOf, openLaunchBlockers, perLocale, } from "./core/site.js";
+export { createPlaceView, freshRating, parseInstant, isPublished, mergeLive, parsePlaceLive, placeHref, placeOrigin, placeUrl, publicationGaps, RATING_MAX_AGE_DAYS, servedLocalities, SERVICE_AREA_GATE, siteOrigin, STOREFRONT_GATE, storefrontOf, } from "./core/place/index.js";
+export { createRouting, GONE, GONE_HEADER, gonePath, goneHeader, HOST_MARK, LANG_COOKIE, LANG_COOKIE_MAX_AGE, NON_PAGE_ROUTES, parseGoneHeader, parsePlaceParam, PASS_PATHS, placeParam, pointSuffixes, THANKS, } from "./core/routing.js";
+export { LEAD_SCHEMA_VERSION, MAX_FIELD, readCandidate, validateCandidate, } from "./core/lead.js";
+export { checkTiming, HONEYPOT_FIELD, LEGACY_HONEYPOT_FIELDS, MIN_FILL_MS, RATE_LIMIT_MAX_KEYS, RateLimiter, RENDERED_AT_FIELD, screen, } from "./core/antispam.js";
+export { createAcceptLead, FORM_ID_FIELD, LOCALE_FIELD, LOCATION_FIELD, } from "./core/accept.js";
+export { areaServedNodes, breadcrumbNode, businessId, businessNode, faqPageNode, offerNodes, organizationId, organizationNode, placeGraph, websiteId, } from "./core/seo/ld.js";
+export { AI_CRAWLERS, ogImageUrl, robotsFor, sitemapFor, } from "./core/seo/sitemap.js";
+export { ALLOWED_PROPS, analyticsSink, countsAsPageView, EVENTS, } from "./core/analytics.js";
+export { brandStatusTarget, statusTarget } from "./core/status.js";
+// A landing needs these beside the machinery; re-exported by name so a brand
+// imports one package and the list here is the whole surface.
+export { createLocaleRegistry } from "@evinvest/i18n";
+export { contactChannel, ldCompact, localBusiness, telHref, whatsappHref, } from "@evinvest/marketing";
+export { createBeaconSink, noopSink } from "@evinvest/analytics";

package/dist/next/config/build-env.d.ts

@@ -0,0 +1,32 @@
+export interface CardFacts {
+    /** As printed: international, spaced. `tel:` and `wa.me` derive from it; `null` → no phone channel. */
+    phone: string | null;
+    email: string | null;
+    /** The domain; `null` → a site before launch (noindex everywhere). */
+    site: string | null;
+}
+type Table = Record<string, string>;
+/**
+ * The slice of TOML these two files use for the values read here: `[a.b]`
+ * headers and `key = "basic string"` lines; everything else (arrays, numbers,
+ * comments) is skipped — not the kit's `parseToml`, to keep `next.config.ts`
+ * free of the kit. `evinvest-palette` still validates brand.toml in full.
+ */
+export declare function readStringTables(text: string): Record<string, Table>;
+export declare function readCard(root: string): CardFacts;
+/**
+ * The inner markup of `assets/mark.svg` — the path, not the `<svg>` wrapper,
+ * which the component writes itself so it can size and colour it. The fill is
+ * `currentColor`, which an `<img>` could not inherit.
+ */
+export declare function readMarkPath(root: string): string;
+export type OgPalette = Record<"background" | "card" | "ink" | "inkSoft" | "primary", string>;
+/**
+ * The dark scope's values for the OG card. `ImageResponse` draws with inline
+ * styles and cannot read a custom property, so the card takes the palette's
+ * values at build time instead of a second copy of them in code.
+ */
+export declare function readOgPalette(root: string): OgPalette;
+/** Everything inlined as `process.env.*`, under the names app code reads. */
+export declare function buildEnv(root: string): Record<string, string>;
+export {};