@evinvest/kitstart 0.1.0

package/dist/testing/landing-contract.d.ts

@@ -0,0 +1,33 @@
+import { type OwnerTodo, type Site } from "../core/site.js";
+/**
+ * What every brand's site config must hold for the machinery to work — run
+ * from the brand's own tests:
+ *
+ * ```ts
+ * describeLandingContract(site, {
+ *   globalsCss: readFileSync("app/globals.css", "utf8"),
+ *   proxySource: readFileSync("proxy.ts", "utf8"),
+ *   root: process.cwd(),
+ *   text: TEXT,
+ * });
+ * ```
+ */
+export interface LandingContractOptions<L extends string> {
+    /** `app/globals.css`: Tailwind must be told to scan the package. */
+    globalsCss?: string;
+    /** `proxy.ts`: its literal matcher must be the package's. */
+    proxySource?: string;
+    /**
+     * The brand's directory: every file `app/` and `public/` serve outside
+     * `[locale]` must pass the proxy — be a `NON_PAGE_ROUTES` path or in
+     * `site.publicFiles` — or it answers 404; and every listed file must exist.
+     */
+    root?: string;
+    /** The brand's copy, one per locale — every locale must have one. */
+    text?: Readonly<Partial<Record<L, unknown>>>;
+    /** Places that must be published once the owner's fields are in. */
+    mustPublish?: readonly string[];
+    /** The brand's open owner facts: a domain (launch) is refused while one that blocks launch is open. */
+    ownerTodo?: readonly OwnerTodo[];
+}
+export declare function describeLandingContract<L extends string, P extends string>(site: Site<L, P>, options?: LandingContractOptions<L>): void;

package/dist/testing/landing-contract.js

@@ -0,0 +1,95 @@
+import { describe, expect, it } from "vitest";
+import { isPublished, publicationGaps } from "../core/place/publication.js";
+import { createRouting, NON_PAGE_ROUTES, pointSuffixes, THANKS } from "../core/routing.js";
+import { openLaunchBlockers } from "../core/site.js";
+import { servedPaths } from "./served-files.js";
+const SOURCE_LINE = /@source\s+["'][^"']*node_modules\/@evinvest\/kitstart\/dist["']/;
+const MATCHER = "/((?!_next/).*)";
+export function describeLandingContract(site, options = {}) {
+    describe(`landing contract: ${site.brand.id}`, () => {
+        it("has a home page and no page at the thank-you path", () => {
+            expect(site.pages.home).toBe("");
+            expect(pointSuffixes(site).filter(s => s === THANKS)).toHaveLength(1);
+            for (const key of site.pageKeys)
+                expect(site.pages[key], key).toMatch(/^(\/[a-z0-9-]+)*$/);
+        });
+        it("routes every page of every place to itself, in every locale", () => {
+            const routing = createRouting(site);
+            const host = (slug) => (site.topology.kind === "single" ? (site.brand.domain ?? "localhost") : `${slug}.${site.brand.domain ?? "localhost"}`);
+            for (const slug of site.placeSlugs) {
+                for (const locale of site.i18n.locales) {
+                    for (const key of site.pageKeys) {
+                        const decision = routing.decide({
+                            host: host(slug),
+                            pathname: site.i18n.localePath(locale, site.pages[key] || "/"),
+                            query: new URLSearchParams(),
+                            acceptLanguage: null,
+                            cookieLang: null,
+                        });
+                        expect(decision, `${slug} ${locale} ${key}`).toEqual({ kind: "serve", pathname: `/${locale}/_${slug}${site.pages[key]}` });
+                    }
+                }
+            }
+        });
+        // On a single site the apex *is* the place, so a legacy path that is also
+        // a page suffix would move a live page away.
+        it("lets no legacy redirect shadow a live page", () => {
+            if (site.topology.kind !== "single")
+                return;
+            const suffixes = pointSuffixes(site);
+            for (const redirect of site.legacyRedirects ?? []) {
+                const moves = site.i18n.locales.some(locale => redirect.to(locale) !== null);
+                expect(moves && suffixes.includes(redirect.from), redirect.from).toBe(false);
+            }
+        });
+        it("publishes nothing without a domain", () => {
+            if (site.brand.domain !== null)
+                return;
+            for (const place of site.places)
+                expect(isPublished(place, site.publication, site.brand), place.slug).toBe(false);
+        });
+        if (options.mustPublish) {
+            it("publishes the places the owner has completed", () => {
+                for (const slug of options.mustPublish ?? []) {
+                    const place = site.places.find(p => p.slug === slug);
+                    expect(place, slug).toBeDefined();
+                    if (place)
+                        expect(publicationGaps(place, site.publication), slug).toEqual([]);
+                }
+            });
+        }
+        if (options.ownerTodo) {
+            it("launches only with every blocking owner fact in", () => {
+                if (site.brand.domain === null)
+                    return;
+                expect(openLaunchBlockers(options.ownerTodo ?? []).map(t => t.field)).toEqual([]);
+            });
+        }
+        if (options.text) {
+            it("has copy for every locale", () => {
+                for (const locale of site.i18n.locales)
+                    expect(options.text?.[locale], locale).toBeDefined();
+            });
+        }
+        if (options.globalsCss !== undefined) {
+            it("lets Tailwind scan the package", () => {
+                expect(options.globalsCss).toMatch(SOURCE_LINE);
+            });
+        }
+        if (options.root !== undefined) {
+            const root = options.root;
+            it("passes exactly the files it serves", () => {
+                const served = servedPaths(root);
+                const listed = site.publicFiles ?? [];
+                const passed = [...NON_PAGE_ROUTES, ...listed];
+                expect(served.filter(p => !passed.includes(p)), "served, but the proxy sends it to the 404: list it in site.publicFiles").toEqual([]);
+                expect(listed.filter(p => !served.includes(p)), "in site.publicFiles, but neither app/ nor public/ serves it").toEqual([]);
+            });
+        }
+        if (options.proxySource !== undefined) {
+            it("spells the package's matcher in proxy.ts", () => {
+                expect(options.proxySource).toContain(`"${MATCHER}"`);
+            });
+        }
+    });
+}

package/dist/testing/lead-store-contract.d.ts

@@ -0,0 +1,13 @@
+import { type LeadStore } from "../core/lead.js";
+/**
+ * What every `LeadStore` adapter promises the funnel, whatever it keeps leads
+ * in. An adapter passes this suite before `LEADS_DB_URL` may select it.
+ *
+ * `open` gets a fresh, empty store; `reopen` (durable adapters) a second
+ * handle on the same data after the first was closed.
+ */
+export interface LeadStoreHarness {
+    open(): Promise<LeadStore>;
+    reopen?(): Promise<LeadStore>;
+}
+export declare function describeLeadStoreContract(name: string, harness: () => LeadStoreHarness): void;

package/dist/testing/lead-store-contract.js

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { LEAD_SCHEMA_VERSION } from "../core/lead.js";
+const lead = (over = {}) => ({
+    subject: "blocked_drain",
+    locality: "63130",
+    mobile: "06 12 34 56 78",
+    extras: {},
+    placeSlug: "royat",
+    spamVerdict: null,
+    ...over,
+});
+export function describeLeadStoreContract(name, harness) {
+    describe(`LeadStore contract: ${name}`, () => {
+        it("answers each insert with a new, increasing id, and counts what it holds", async () => {
+            const store = await harness().open();
+            expect(await store.count()).toBe(0);
+            const first = await store.insert(lead());
+            const second = await store.insert(lead({ placeSlug: null, spamVerdict: "honeypot" }));
+            expect(second).toBeGreaterThan(first);
+            expect(await store.count()).toBe(2);
+            await store.close();
+        });
+        it("takes every shape the funnel produces: no place, a verdict, extras, a long value", async () => {
+            const store = await harness().open();
+            for (const variant of [
+                lead({ placeSlug: null }),
+                lead({ spamVerdict: "too-fast" }),
+                lead({ spamVerdict: "rate-limited", extras: { surface_m2: "40", notes: "3e étage, digicode 12B" } }),
+                lead({ subject: "x".repeat(200), locality: "Clermont-Ferrand — 63000" }),
+            ]) {
+                expect(await store.insert(variant)).toBeGreaterThan(0);
+            }
+            expect(await store.count()).toBe(4);
+            await store.close();
+        });
+        it("stands at the current schema version and reports itself healthy", async () => {
+            const store = await harness().open();
+            expect(await store.schemaVersion()).toBe(LEAD_SCHEMA_VERSION);
+            await expect(store.health()).resolves.toBeUndefined();
+            await store.close();
+        });
+        it("keeps what it acknowledged across a close and a reopen", async () => {
+            const h = harness();
+            if (!h.reopen)
+                return;
+            const store = await h.open();
+            await store.insert(lead());
+            await store.close();
+            const again = await h.reopen();
+            expect(await again.count()).toBe(1);
+            expect(await again.schemaVersion()).toBe(LEAD_SCHEMA_VERSION);
+            await again.close();
+        });
+    });
+}

package/dist/testing/served-files.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Every path a brand tree serves outside `[locale]`: `app/`'s route folders
+ * (`/og`), its root metadata files (`app/robots.ts` → `/robots.txt`,
+ * `app/icon.svg`) and everything under `public/`. A layout, a stylesheet or
+ * a route group serves nothing of its own here.
+ */
+export declare function servedPaths(root: string): string[];

package/dist/testing/served-files.js

@@ -0,0 +1,41 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+/** Next's app-root metadata routes generated by code, served without an extension. */
+const CODE_ROUTES = { robots: "/robots.txt", sitemap: "/sitemap.xml", manifest: "/manifest.webmanifest" };
+const IMAGE_ROUTE = /^(icon|apple-icon|opengraph-image|twitter-image)\d*$/;
+const CODE = /\.(ts|tsx|js|jsx|mjs)$/;
+const STATIC = /^(favicon\.ico|robots\.txt|sitemap\.xml|manifest\.(json|webmanifest)|(icon|apple-icon|opengraph-image|twitter-image)\d*\.(ico|jpe?g|png|gif|svg))$/;
+/**
+ * Every path a brand tree serves outside `[locale]`: `app/`'s route folders
+ * (`/og`), its root metadata files (`app/robots.ts` → `/robots.txt`,
+ * `app/icon.svg`) and everything under `public/`. A layout, a stylesheet or
+ * a route group serves nothing of its own here.
+ */
+export function servedPaths(root) {
+    const served = [];
+    const app = join(root, "app");
+    for (const entry of existsSync(app) ? readdirSync(app, { withFileTypes: true }) : []) {
+        if (entry.isDirectory()) {
+            // `[locale]` is the pages; `(group)`, `_private` and `@slot` add no segment.
+            if (!/^[[(_@]/.test(entry.name))
+                served.push(`/${entry.name}`);
+            continue;
+        }
+        if (STATIC.test(entry.name)) {
+            served.push(`/${entry.name}`);
+            continue;
+        }
+        if (!CODE.test(entry.name))
+            continue;
+        const base = entry.name.replace(CODE, "");
+        const route = CODE_ROUTES[base] ?? (IMAGE_ROUTE.test(base) ? `/${base}` : undefined);
+        if (route)
+            served.push(route);
+    }
+    const pub = join(root, "public");
+    for (const entry of existsSync(pub) ? readdirSync(pub, { withFileTypes: true, recursive: true }) : []) {
+        if (entry.isFile())
+            served.push(`/${relative(pub, join(entry.parentPath, entry.name)).split(sep).join("/")}`);
+    }
+    return served.sort();
+}

package/package.json

@@ -0,0 +1,129 @@
+{
+  "name": "@evinvest/kitstart",
+  "version": "0.1.0",
+  "description": "Landing-site machinery for local-service brands: a site composition root, the Place/Presence/ServiceArea model with a publication gate, host/locale routing, schema.org and SEO builders, the lead funnel with its antispam, and analytics events. Pure core at '.', more subpaths per runtime.",
+  "license": "BlueOak-1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EV-invest/lib.git",
+    "directory": "ts/kitstart"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    },
+    "./proxy": {
+      "types": "./dist/proxy/index.d.ts",
+      "import": "./dist/proxy/index.js",
+      "default": "./dist/proxy/index.js"
+    },
+    "./next": {
+      "types": "./dist/next/index.d.ts",
+      "import": "./dist/next/index.js",
+      "default": "./dist/next/index.js"
+    },
+    "./next/config": {
+      "types": "./dist/next/config/index.d.ts",
+      "import": "./dist/next/config/index.js",
+      "default": "./dist/next/config/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js",
+      "default": "./dist/react/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js",
+      "default": "./dist/testing/index.js"
+    },
+    "./testing/e2e": {
+      "types": "./dist/testing/e2e.d.ts",
+      "import": "./dist/testing/e2e.js",
+      "default": "./dist/testing/e2e.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "bin": {
+    "kitstart-size": "./dist/cli/kitstart-size.js"
+  },
+  "files": [
+    "dist",
+    "template"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22.13"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && node scripts/fully-specify.mjs dist",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "prepare": "npm run build",
+    "prepublishOnly": "node scripts/verify-pack.mjs",
+    "check:template": "node scripts/check-template.mjs"
+  },
+  "peerDependencies": {
+    "@evinvest/analytics": ">=0.3.0 <1",
+    "@evinvest/i18n": ">=0.9.0 <1",
+    "@evinvest/marketing": ">=0.3.0 <1",
+    "@evinvest/uikit": ">=0.20.0 <1",
+    "next": "^16",
+    "react": "^19",
+    "server-only": "*"
+  },
+  "peerDependenciesMeta": {
+    "@evinvest/uikit": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "server-only": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@evinvest/analytics": "^0.3.0",
+    "@evinvest/i18n": "^0.9.0",
+    "@evinvest/marketing": "file:../marketing",
+    "@evinvest/uikit": "file:../uikit",
+    "@playwright/test": "^1.63.0",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.3",
+    "@types/node": "^22.10.0",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "eslint": "^9.39.5",
+    "jsdom": "^25.0.1",
+    "next": "^16.3.6",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "server-only": "^0.0.1",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.46.0",
+    "vitest": "^3.2.4"
+  },
+  "kitstartPack": [
+    "template/package.json",
+    "template/proxy.ts",
+    "template/app/[locale]/[location]/layout.tsx",
+    "dist/cli/kitstart-size.js"
+  ]
+}

package/template/README.md

@@ -0,0 +1,55 @@
+# Brand landing — skeleton
+
+A landing on `@evinvest/kitstart`: the machinery (routing, places, the lead
+funnel, SEO) is the package's; the copy, the palette, the sections and the
+config are yours. As shipped it is one service-area place on one site, before
+launch — `noindex` everywhere until `assets/card.toml` gets a `site`.
+
+## Twelve steps
+
+1. Copy this directory into the new repo; `npm install`.
+2. `flake.nix` calls the lib flake's `mkLanding` (the build, the image, the
+   smoke, the bundle-budget check); `nix develop`.
+3. `assets/brand.toml` → `npm run palette` (writes `app/brand.css`; the OG card
+   takes `[colors.dark]` from the same file at build).
+4. `assets/card.toml`: the email now; `phone` and `site` when the owner has them.
+5. `assets/mark.svg`; the faces in `assets/fonts/` and `src/shared/ui/fonts.ts`
+   (`next/font/local`, literal paths); the OG route reads the `.ttf`.
+6. `src/shared/config/site.ts`: brand facts, topology (`single`, or
+   `subdomains` for a network), pages, the publication gate, `OWNER_TODO`
+   (a domain is refused while a blocking one is open).
+7. `src/shared/config/places.ts`: the places, storefront or service area.
+8. `src/entities/content`: `Text extends CoreText`, one object per language,
+   checked with `satisfies`. Every word on a page comes from here.
+9. `src/shared/config/lead.ts`: what the form asks (`subjects`, `wire`, `extras`).
+10. `src/views/`: the brand's sections around the package's widgets.
+11. Tests: `tests/contract.test.ts` runs the landing contract; add the copy's
+    own, the e2e sections (`tests/e2e`, baselines from CI on Linux) and set
+    `tests/bundle_budget.txt` from the first `npm run size`. `npm run lint` is
+    eslint (with the client-boundary rule) and steiger (FSD).
+12. `deploy/config.nix` (`TRUSTED_PROXY`, the leads volume), gitops. Without a
+    domain the deploy is noindex.
+
+## What must stay a literal
+
+Next reads these statically, so they live in the route files, not the package:
+`export const dynamic`, `revalidate`, `generateStaticParams`, `config.matcher`
+in `proxy.ts`, and every `next/font/local` path. Everything else is a factory
+call.
+
+## The rules that keep pages cached
+
+No page, layout or boundary reads the request (`headers()`, `cookies()`): the
+link mode rides in the `[location]` param. A page that did would render per
+request again. The quote route, the sitemap, robots and the 404 are dynamic
+on purpose.
+
+## The 404
+
+Next 16 answers a `notFound()` with an empty shell it fills in after
+hydration — blank without JavaScript. So the proxy sends every dead path it
+can recognise to `app/global-not-found.tsx`, which renders the brand's screen
+on the server with the right language and place. The `[locale]/not-found.tsx`
+boundary is only for what the proxy cannot foresee (a place the live source
+withdrew); it and `error.tsx` are client modules that read `BRAND_PUBLIC`,
+never the site config.

package/template/app/[locale]/[location]/layout.tsx

@@ -0,0 +1,29 @@
+import { AnalyticsBoundary } from "@evinvest/kitstart/react";
+import type { ReactNode } from "react";
+import { loadPlace } from "@/views/place/server";
+import { serverEnv } from "@/shared/config/env";
+import { site } from "@/shared/config/site";
+
+/**
+ * Incremental static regeneration. Nothing is prerendered at build — in a
+ * sandbox with no network that would bake the fallback into the artefact —
+ * so the list is empty: the first request renders a page, the result is
+ * cached, and it re-renders in the background after the live data's TTL.
+ */
+export function generateStaticParams(): { locale: string; location: string }[] {
+  return [];
+}
+
+/** A literal: Next reads it statically. The place source's TTL. */
+export const revalidate = 600;
+
+export default async function PlaceLayout({ children, params }: { children: ReactNode; params: Promise<{ locale: string; location: string }> }) {
+  const { view } = await loadPlace(params);
+  const env = serverEnv();
+  // The key is read from the container when the page renders, never inlined.
+  return (
+    <AnalyticsBoundary target={{ key: env.posthogKey, host: env.posthogHost, brandId: site.brand.id }} placeSlug={view.place.slug}>
+      {children}
+    </AnalyticsBoundary>
+  );
+}

package/template/app/[locale]/[location]/page.tsx

@@ -0,0 +1,18 @@
+import { placeMetadata } from "@evinvest/kitstart/next";
+import type { Metadata } from "next";
+import { loadPlace } from "@/views/place/server";
+import { site } from "@/shared/config/site";
+import { PlaceHome } from "@/views/home";
+
+type Props = { params: Promise<{ locale: string; location: string }> };
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { view, copy } = await loadPlace(params);
+  const page = copy.t.pages.home;
+  return placeMetadata(site, view, "home", { title: page.title(copy.f), description: page.description(copy.f) });
+}
+
+export default async function PlaceHomePage({ params }: Props) {
+  const { view, copy, renderedAt } = await loadPlace(params);
+  return <PlaceHome view={view} copy={copy} renderedAt={renderedAt} />;
+}

package/template/app/[locale]/[location]/prices/page.tsx

@@ -0,0 +1,26 @@
+import { faqPageNode } from "@evinvest/kitstart";
+import { placeMetadata } from "@evinvest/kitstart/next";
+import { Faq, JsonLd, Section } from "@evinvest/kitstart/react";
+import type { Metadata } from "next";
+import { loadPlace } from "@/views/place/server";
+import { site } from "@/shared/config/site";
+
+type Props = { params: Promise<{ locale: string; location: string }> };
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { view, copy } = await loadPlace(params);
+  const page = copy.t.pages.prices;
+  return placeMetadata(site, view, "prices", { title: page.title(copy.f), description: page.description(copy.f) });
+}
+
+export default async function PricesPage({ params }: Props) {
+  const { copy } = await loadPlace(params);
+  return (
+    <main>
+      <JsonLd data={faqPageNode(copy.t.faqs)} />
+      <Section>
+        <Faq items={copy.t.faqs} />
+      </Section>
+    </main>
+  );
+}

package/template/app/[locale]/[location]/thanks/page.tsx

@@ -0,0 +1,20 @@
+import { statusTarget } from "@evinvest/kitstart";
+import { statusMetadata } from "@evinvest/kitstart/next";
+import { StatusScreen } from "@evinvest/kitstart/react";
+import type { Metadata } from "next";
+import { loadPlace } from "@/views/place/server";
+import { site } from "@/shared/config/site";
+
+type Props = { params: Promise<{ locale: string; location: string }> };
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { copy } = await loadPlace(params);
+  return statusMetadata(site, copy.t.thanks.title);
+}
+
+/** The form's receipt, on the place's own links: not indexed, not a page view. */
+export default async function PlaceThanks({ params }: Props) {
+  const { copy } = await loadPlace(params);
+  const target = statusTarget(site, await params, { thanks: true });
+  return <StatusScreen copy={copy} status={copy.t.thanks} target={target} locales={site.i18n.locales} brandName={site.brand.name} />;
+}

package/template/app/[locale]/error.tsx

@@ -0,0 +1,14 @@
+"use client";
+
+import dynamic from "next/dynamic";
+
+/**
+ * The 500, loaded on demand: an error boundary ships with every page under
+ * it, so whatever it imports is paid by every visitor, error or not. It never
+ * imports the site config — see `BRAND_PUBLIC`.
+ */
+const Screen = dynamic(() => import("@/views/server-error").then(m => m.ServerError));
+
+export default function ErrorBoundary() {
+  return <Screen />;
+}

package/template/app/[locale]/layout.tsx

@@ -0,0 +1,28 @@
+import "../globals.css";
+import { loadLocale, metadataBase } from "@evinvest/kitstart/next";
+import type { Metadata, Viewport } from "next";
+import type { ReactNode } from "react";
+import { site } from "@/shared/config/site";
+import { text } from "@/shared/ui/fonts";
+
+/**
+ * The root layout lives under `[locale]` so `<html lang>` is the page's own
+ * language on the first byte. The brand scope and the polarity sit on
+ * `<html>`, so overlays portalled to `body` stay inside both.
+ */
+export const metadata: Metadata = {
+  metadataBase: metadataBase(site),
+  applicationName: site.brand.name,
+  formatDetection: { telephone: false },
+};
+
+export const viewport: Viewport = { width: "device-width", initialScale: 1 };
+
+export default async function RootLayout({ children, params }: { children: ReactNode; params: Promise<{ locale: string }> }) {
+  const locale = await loadLocale(site, params);
+  return (
+    <html lang={locale} data-brand={site.brand.id} className={`light ${text.variable}`}>
+      <body>{children}</body>
+    </html>
+  );
+}

package/template/app/[locale]/not-found.tsx

@@ -0,0 +1,18 @@
+"use client";
+
+import dynamic from "next/dynamic";
+
+/**
+ * The boundary for a `notFound()` the proxy could not foresee — a place the
+ * live source withdrew. Every dead path the proxy recognises goes to
+ * `app/global-not-found.tsx` instead: Next 16 answers a `notFound()` with an
+ * empty shell and renders this boundary only in the browser.
+ *
+ * Rendered into every page under the segment, so it must not read the request
+ * and should not weigh on pages that never 404: a lazily loaded client module.
+ */
+const Screen = dynamic(() => import("@/views/not-found").then(m => m.NotFound));
+
+export default function NotFound() {
+  return <Screen />;
+}

package/template/app/[locale]/page.tsx

@@ -0,0 +1,40 @@
+import { brandMetadata, loadLocale } from "@evinvest/kitstart/next";
+import { PlaceDirectory } from "@evinvest/kitstart/react";
+import { contactOf, placeUrl } from "@evinvest/kitstart";
+import type { Metadata } from "next";
+import { TEXT } from "@/entities/content";
+import { places } from "@/shared/config/env";
+import { site } from "@/shared/config/site";
+
+/**
+ * The apex of a `subdomains` site: a directory of its places. On a `single`
+ * site the proxy rewrites `/fr` to the place's own route and this never renders.
+ */
+export function generateStaticParams(): { locale: string }[] {
+  return [];
+}
+
+export const revalidate = 600;
+
+type Props = { params: Promise<{ locale: string }> };
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const locale = await loadLocale(site, params);
+  const { title, description } = TEXT[locale].brandPage;
+  return brandMetadata(site, locale, { title, description });
+}
+
+export default async function BrandPage({ params }: Props) {
+  const locale = await loadLocale(site, params);
+  return (
+    <main className="p-8">
+      <PlaceDirectory
+        places={await places.listPlaces(locale, "page")}
+        locale={locale}
+        hrefOf={p => placeUrl(site, p.slug, locale, "")}
+        phoneOf={p => contactOf(site, p).phone}
+        openLabel={TEXT[locale].brandPage.open}
+      />
+    </main>
+  );
+}

package/template/app/[locale]/thanks/page.tsx

@@ -0,0 +1,21 @@
+import { statusTarget } from "@evinvest/kitstart";
+import { loadLocale, statusMetadata } from "@evinvest/kitstart/next";
+import { StatusScreen } from "@evinvest/kitstart/react";
+import type { Metadata } from "next";
+import { copyFor } from "@/entities/content";
+import { site } from "@/shared/config/site";
+
+/** Where a lead with no place lands. The lead is stored all the same. */
+type Props = { params: Promise<{ locale: string }> };
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const locale = await loadLocale(site, params);
+  return statusMetadata(site, copyFor(locale, { place: site.brand.name, phone: site.brand.phone }).t.thanks.title);
+}
+
+export default async function BrandThanks({ params }: Props) {
+  const locale = await loadLocale(site, params);
+  const target = statusTarget(site, { locale }, { thanks: true });
+  const copy = copyFor(locale, { place: site.brand.name, phone: target.phone });
+  return <StatusScreen copy={copy} status={copy.t.thanks} target={target} locales={site.i18n.locales} brandName={site.brand.name} />;
+}