@bitbaum/sitekit 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mao Nakamoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# @bitbaum/sitekit
+
+A website as data.
+
+A site is pages; a page is sections; sections come from a **closed** union of
+shapes validated by Zod at runtime. One set of React renderers draws every
+site. A provenance sidecar records where every generated field came from — so
+"we fabricated nothing" is an assertion, not a promise.
+
+Extracted from [substrata](https://github.com/bitbaum/substrata)'s hosted-site
+model (2026-08). Decided in orangecat's ADR-0003 (the Site Factory).
+
+## Why a closed union
+
+A generator emitting **data against this schema** is a task with a
+machine-checkable result; a generator emitting components is not. Per-site
+quality becomes a property of the renderers — fixing the `cards` renderer
+improves every site ever generated. And the schema is where review happens:
+`validateSite()` returns `path: message` errors a model can act on directly.
+
+The current kinds: `hero` (with optional CTAs), `prose`, `stats`, `meter`,
+`cards`, `definitions`, `feature` (a figure beside a story), `contact`
+(locations, address, hours — the fields provenance exists to protect), `faq`,
+`index`, `table`. Most kinds take an optional `anchor`, and the schema rejects
+any index entry or hero action that points at a fragment nothing carries. Extending the union is a deliberate act in THIS repo — a new
+kind lands with its schema, its renderer, and its tests in one commit, and
+every consumer gets it on the next version bump.
+
+## Install
+
+```bash
+pnpm add @bitbaum/sitekit
+```
+
+ESM-only. `react >= 18` is a peer dependency of `@bitbaum/sitekit/react`; the root
+export is framework-free (a Node generator or CI check can use it without React).
+
+## Use
+
+```ts
+import { validateSite, siteNavItems, sitePageAt, pageRendersOwnHeader } from '@bitbaum/sitekit';
+
+const result = validateSite(generatorOutput);
+if (!result.success) throw new Error(result.errors.join('\n'));
+const site = result.data; // fully typed SiteSpec from here on
+```
+
+```tsx
+import Link from 'next/link';
+import { SiteMasthead, SiteFooter, SiteSections } from '@bitbaum/sitekit/react';
+
+<SiteMasthead chrome={site.chrome} navItems={siteNavItems(site.pages)} currentPath={path} Link={Link} />
+<SiteSections sections={page.sections} />
+<SiteFooter chrome={site.chrome} />
+```
+
+`Link` is the one framework seam: it defaults to a plain `<a>`, which is
+correct everywhere; a Next.js app passes `next/link` to get client-side
+navigation back.
+
+## Provenance — the check behind "fabricate no facts"
+
+A closed schema invites completion: a model handed a `stats` section wants
+numbers in it. So absence is first-class and typed. The generator emits a
+sidecar keyed by JSON path:
+
+```ts
+import { assertDeliverable, notFoundPaths } from '@bitbaum/sitekit';
+
+const provenance = {
+  'chrome.name':                    { kind: 'scraped', url: 'https://cafe-beispiel.ch/' },
+  'pages.0.sections.1.paragraphs.0':{ kind: 'operator' },   // a human typed it
+  'pages.0.sections.4.cards.0.meta':{ kind: 'inferred' },   // a model invented it
+  'pages.0.sections.7.rows.0.1':    { kind: 'not-found' },  // we looked; it isn't public
+};
+
+assertDeliverable(provenance); // throws: names the inferred path
+notFoundPaths(provenance);     // the honest gaps — in a pitch, these ARE the pitch
+```
+
+`not-found` is the difference between *unknown* and *empty*: it records that
+the looking happened, which is what makes "here is what we could not find out
+about you" an honest sentence instead of an excuse.
+
+## The styling contract
+
+The renderers emit **semantic utility classes and nothing else** — no colours,
+faces, or radii ship in this package. Each consumer defines the tokens, which
+is how fifty sites share one renderer without looking like one company.
+(Uniform everywhere except aesthetics. Do NOT point consumers at
+`@fleet/design-tokens` values — those make things look like the fleet;
+inherit the *shape*, choose your own values.)
+
+Classes the renderers use, to be defined by the consumer's Tailwind theme:
+
+| Group | Classes |
+|---|---|
+| Text | `text-fg-primary` `text-fg-secondary` `text-fg-tertiary` `text-fg-muted` |
+| Surfaces | `bg-surface-page` `bg-surface-raised` |
+| Borders | `border-subtle` `border-strong` `divide-subtle` |
+| Accent & status | `bg-accent` `decoration-accent` `bg-status-positive` `bg-status-warning` `bg-status-negative` |
+| Type | `font-heading` `font-mono` `tracking-caps` `tracking-display` |
+| Layout | `max-w-shell` `max-w-prose` `scrollbar-hide` |
+
+With Tailwind 4, define them as `@theme` variables (`--color-fg-primary`,
+`--font-heading`, …) and add the package to content scanning:
+
+```css
+@import 'tailwindcss';
+@source '../node_modules/@bitbaum/sitekit/dist';
+```
+
+Substrata's `app/globals.css` is the reference implementation of the contract.
+
+## Not in this package
+
+- **No design tokens.** See above — that is the point.
+- **No scraper.** `siteFromUrl()` (extraction from a live site, with
+  provenance) is the planned next module; the schema is its target.
+- **No HTTP, no framework.** Same rule as every package in this fleet.
+
+## Verify
+
+```bash
+pnpm run verify  # lint + typecheck + build + test — same command CI runs
+```
+
+Tests import the package by **name** (`@bitbaum/sitekit`, `@bitbaum/sitekit/react`), so a broken
+`exports` map fails in CI, not at the first consumer.

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @bitbaum/sitekit — a website as data.
+ *
+ * This root export is framework-free: schemas, inferred types, validation and
+ * provenance. The React renderers live behind `@bitbaum/sitekit/react` so a generator
+ * or a CI check can depend on the model without pulling in React.
+ */
+export { siteSpecSchema, sitePageSchema, siteChromeSchema, siteSectionSchema, siteNavItemSchema, heroSectionSchema, proseSectionSchema, statsSectionSchema, meterSectionSchema, cardsSectionSchema, definitionsSectionSchema, featureSectionSchema, contactSectionSchema, faqSectionSchema, indexSectionSchema, tableSectionSchema, siteActionSchema, siteImageSchema, siteLocationSchema, siteFaqItemSchema, siteStatSchema, siteCardSchema, siteDefinitionSchema, siteIndexEntrySchema, type SiteSpec, type SitePage, type SiteChrome, type SiteSection, type SiteSectionKind, type SiteNavItem, type SiteStat, type SiteCard, type SiteDefinition, type SiteIndexEntry, type SiteAction, type SiteImage, type SiteLocation, type SiteFaqItem, } from './schema.js';
+export { provenanceSchema, provenanceEntrySchema, type Provenance, type ProvenanceEntry, inferredPaths, notFoundPaths, assertDeliverable, } from './provenance.js';
+export { validateSite, siteNavItems, pageRendersOwnHeader, sitePageAt, href } from './model.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * @bitbaum/sitekit — a website as data.
+ *
+ * This root export is framework-free: schemas, inferred types, validation and
+ * provenance. The React renderers live behind `@bitbaum/sitekit/react` so a generator
+ * or a CI check can depend on the model without pulling in React.
+ */
+export { 
+// schemas (Zod is the SSOT; every type below is inferred from one of these)
+siteSpecSchema, sitePageSchema, siteChromeSchema, siteSectionSchema, siteNavItemSchema, heroSectionSchema, proseSectionSchema, statsSectionSchema, meterSectionSchema, cardsSectionSchema, definitionsSectionSchema, featureSectionSchema, contactSectionSchema, faqSectionSchema, indexSectionSchema, tableSectionSchema, siteActionSchema, siteImageSchema, siteLocationSchema, siteFaqItemSchema, siteStatSchema, siteCardSchema, siteDefinitionSchema, siteIndexEntrySchema, } from './schema.js';
+export { provenanceSchema, provenanceEntrySchema, inferredPaths, notFoundPaths, assertDeliverable, } from './provenance.js';
+export { validateSite, siteNavItems, pageRendersOwnHeader, sitePageAt, href } from './model.js';

package/dist/model.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pure helpers over a validated site. No React, no framework — a Node script
+ * generating sites can use everything in this file.
+ */
+import { type SiteNavItem, type SitePage, type SiteSpec } from './schema.js';
+/**
+ * Validate anything claiming to be a site — typically a generator's raw
+ * output. Structured result in the house shape; `errors` are `path: message`
+ * lines a model (or a person) can act on directly.
+ */
+export declare function validateSite(input: unknown): {
+    success: true;
+    data: SiteSpec;
+} | {
+    success: false;
+    errors: string[];
+};
+/** Nav entries in page order. Pages without a `navLabel` are omitted. */
+export declare function siteNavItems(pages: SitePage[]): SiteNavItem[];
+/**
+ * True when the page opens with its own hero, in which case the shell must not
+ * also print a title block. One rule, checked in one place.
+ */
+export declare function pageRendersOwnHeader(page: SitePage): boolean;
+/** @returns the page at this path, or null. */
+export declare function sitePageAt(pages: SitePage[], path: string): SitePage | null;
+/** An in-site link. Root is '/', everything else '/segment'. */
+export declare function href(path?: string): string;

package/dist/model.js

@@ -0,0 +1,42 @@
+/**
+ * Pure helpers over a validated site. No React, no framework — a Node script
+ * generating sites can use everything in this file.
+ */
+import { siteSpecSchema } from './schema.js';
+/**
+ * Validate anything claiming to be a site — typically a generator's raw
+ * output. Structured result in the house shape; `errors` are `path: message`
+ * lines a model (or a person) can act on directly.
+ */
+export function validateSite(input) {
+    const result = siteSpecSchema.safeParse(input);
+    if (result.success)
+        return { success: true, data: result.data };
+    return {
+        success: false,
+        errors: result.error.issues.map((issue) => `${issue.path.join('.') || '(root)'}: ${issue.message}`),
+    };
+}
+/** Nav entries in page order. Pages without a `navLabel` are omitted. */
+export function siteNavItems(pages) {
+    return pages
+        .filter((page) => Boolean(page.navLabel))
+        .map((page) => ({ path: page.path, label: page.navLabel }));
+}
+/**
+ * True when the page opens with its own hero, in which case the shell must not
+ * also print a title block. One rule, checked in one place.
+ */
+export function pageRendersOwnHeader(page) {
+    return page.sections[0]?.kind === 'hero';
+}
+/** @returns the page at this path, or null. */
+export function sitePageAt(pages, path) {
+    const normalised = path.replace(/^\/+|\/+$/g, '');
+    return pages.find((page) => page.path === normalised) ?? null;
+}
+/** An in-site link. Root is '/', everything else '/segment'. */
+export function href(path = '') {
+    const clean = path.replace(/^\/+|\/+$/g, '');
+    return clean ? `/${clean}` : '/';
+}

package/dist/provenance.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Where every generated field came from — the check behind "we fabricate no
+ * facts".
+ *
+ * A closed schema invites completion: a model handed a `stats` section wants
+ * numbers in it, and a plausible-but-wrong street number is the one detail
+ * that actively damages the business a pitch is meant to win. So provenance
+ * makes absence first-class and typed:
+ *
+ *   - `scraped`   — read from the subject's own public web, with the URL
+ *   - `operator`  — a human typed it and answers for it
+ *   - `inferred`  — a model filled it in. NEVER deliverable in a real pitch.
+ *   - `not-found` — we looked and could not find it. Unknown is not empty:
+ *                   this is the record that the looking happened, and it is
+ *                   what makes "here is what we could not find out about you"
+ *                   an honest sentence instead of an excuse.
+ *
+ * The map is a sidecar keyed by JSON path (e.g. `pages.0.sections.2.cards.1.body`)
+ * rather than annotations woven through the content, so the renderers stay
+ * ignorant of it and the check stays one function.
+ */
+import { z } from 'zod';
+export declare const provenanceEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"scraped">;
+    url: z.ZodURL;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"operator">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"inferred">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"not-found">;
+}, z.core.$strip>], "kind">;
+export type ProvenanceEntry = z.infer<typeof provenanceEntrySchema>;
+/** JSON path → where that field came from. */
+export declare const provenanceSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"scraped">;
+    url: z.ZodURL;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"operator">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"inferred">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"not-found">;
+}, z.core.$strip>], "kind">>;
+export type Provenance = z.infer<typeof provenanceSchema>;
+/** Fields a model invented. A deliverable site has none. */
+export declare function inferredPaths(provenance: Provenance): string[];
+/**
+ * Fields we looked for and could not find. These are not defects — shown
+ * honestly, they are the pitch: what we could not learn about you in five
+ * minutes is what your customers also cannot.
+ */
+export declare function notFoundPaths(provenance: Provenance): string[];
+/**
+ * Throws unless every field is scraped, operator-entered, or honestly absent.
+ * Call this before anything generated is shown to, or handed to, a real
+ * business. The error names every offending path so the fix is a lookup, not
+ * a hunt.
+ */
+export declare function assertDeliverable(provenance: Provenance): void;

package/dist/provenance.js

@@ -0,0 +1,61 @@
+/**
+ * Where every generated field came from — the check behind "we fabricate no
+ * facts".
+ *
+ * A closed schema invites completion: a model handed a `stats` section wants
+ * numbers in it, and a plausible-but-wrong street number is the one detail
+ * that actively damages the business a pitch is meant to win. So provenance
+ * makes absence first-class and typed:
+ *
+ *   - `scraped`   — read from the subject's own public web, with the URL
+ *   - `operator`  — a human typed it and answers for it
+ *   - `inferred`  — a model filled it in. NEVER deliverable in a real pitch.
+ *   - `not-found` — we looked and could not find it. Unknown is not empty:
+ *                   this is the record that the looking happened, and it is
+ *                   what makes "here is what we could not find out about you"
+ *                   an honest sentence instead of an excuse.
+ *
+ * The map is a sidecar keyed by JSON path (e.g. `pages.0.sections.2.cards.1.body`)
+ * rather than annotations woven through the content, so the renderers stay
+ * ignorant of it and the check stays one function.
+ */
+import { z } from 'zod';
+export const provenanceEntrySchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('scraped'), url: z.url() }),
+    z.object({ kind: z.literal('operator') }),
+    z.object({ kind: z.literal('inferred') }),
+    z.object({ kind: z.literal('not-found') }),
+]);
+/** JSON path → where that field came from. */
+export const provenanceSchema = z.record(z.string(), provenanceEntrySchema);
+function pathsOf(provenance, kind) {
+    return Object.entries(provenance)
+        .filter(([, entry]) => entry.kind === kind)
+        .map(([path]) => path)
+        .sort();
+}
+/** Fields a model invented. A deliverable site has none. */
+export function inferredPaths(provenance) {
+    return pathsOf(provenance, 'inferred');
+}
+/**
+ * Fields we looked for and could not find. These are not defects — shown
+ * honestly, they are the pitch: what we could not learn about you in five
+ * minutes is what your customers also cannot.
+ */
+export function notFoundPaths(provenance) {
+    return pathsOf(provenance, 'not-found');
+}
+/**
+ * Throws unless every field is scraped, operator-entered, or honestly absent.
+ * Call this before anything generated is shown to, or handed to, a real
+ * business. The error names every offending path so the fix is a lookup, not
+ * a hunt.
+ */
+export function assertDeliverable(provenance) {
+    const inferred = inferredPaths(provenance);
+    if (inferred.length > 0) {
+        throw new Error(`site is not deliverable: ${inferred.length} field(s) were inferred rather than ` +
+            `sourced or left honestly absent:\n  ${inferred.join('\n  ')}`);
+    }
+}

package/dist/react/NavAutoScroll.d.ts

@@ -0,0 +1,3 @@
+export declare function NavAutoScroll({ currentPath }: {
+    currentPath: string;
+}): null;

package/dist/react/NavAutoScroll.js

@@ -0,0 +1,26 @@
+'use client';
+/**
+ * The one client-side behaviour in the chrome, isolated so everything else
+ * stays server-renderable.
+ *
+ * With eight sections the nav scrolls sideways on a phone, and the active
+ * item is frequently off-screen at rest — a visitor arriving on a deep page
+ * would see a row of links with no indication that any of them is the page
+ * they are on. Scrolling it into view on mount fixes that; there is no
+ * CSS-only way to do it.
+ *
+ * Deliberately takes ONLY serialisable props. The nav itself (with its
+ * injected Link component) must stay a server component — a component
+ * function cannot cross the server→client boundary, which is exactly the
+ * build error this split prevents.
+ */
+import { useEffect } from 'react';
+export function NavAutoScroll({ currentPath }) {
+    useEffect(() => {
+        const active = document.querySelector('[data-sitekit-nav] [aria-current="page"]');
+        // `nearest` keeps the page itself still — `center` would scroll the whole
+        // document to the top of the masthead on every navigation.
+        active?.scrollIntoView({ inline: 'nearest', block: 'nearest' });
+    }, [currentPath]);
+    return null;
+}

package/dist/react/SiteChrome.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Masthead and footer.
+ *
+ * The masthead is a rule, not a bar. It sticks so the nav stays reachable on
+ * a long page, but it carries no shadow, no fill beyond the page's own
+ * surface, and no logo — a hairline and a wordmark are enough, and anything
+ * heavier competes with the document.
+ *
+ * There is deliberately no "hosted on" or "built by" line. A generated site
+ * belongs to its subject; its footer has no business advertising anyone else.
+ */
+import type { SiteChrome as SiteChromeSpec, SiteNavItem } from '../schema.js';
+import { type LinkLike } from './link.js';
+interface Props {
+    chrome: SiteChromeSpec;
+    navItems: SiteNavItem[];
+    currentPath: string;
+    /** Framework link component (e.g. next/link). Defaults to a plain anchor. */
+    Link?: LinkLike;
+}
+export declare function SiteMasthead({ chrome, navItems, currentPath, Link }: Props): import("react").JSX.Element;
+export declare function SiteFooter({ chrome }: {
+    chrome: SiteChromeSpec;
+}): import("react").JSX.Element;
+export {};

package/dist/react/SiteChrome.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Masthead and footer.
+ *
+ * The masthead is a rule, not a bar. It sticks so the nav stays reachable on
+ * a long page, but it carries no shadow, no fill beyond the page's own
+ * surface, and no logo — a hairline and a wordmark are enough, and anything
+ * heavier competes with the document.
+ *
+ * There is deliberately no "hosted on" or "built by" line. A generated site
+ * belongs to its subject; its footer has no business advertising anyone else.
+ */
+import { href } from '../model.js';
+import { DefaultLink } from './link.js';
+import { SiteNav } from './SiteNav.js';
+export function SiteMasthead({ chrome, navItems, currentPath, Link = DefaultLink }) {
+    return (_jsx("header", { className: "sticky top-0 z-30 border-b border-subtle bg-surface-page/85 backdrop-blur", children: _jsx("div", { className: "mx-auto max-w-shell px-4 sm:px-6 lg:px-8", children: _jsxs("div", { className: "flex items-center justify-between gap-6 py-2", children: [_jsx(Link, { href: href(), className: "inline-flex min-h-11 shrink-0 items-center rounded focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-accent", children: _jsx("span", { className: "font-heading text-lg font-semibold tracking-display text-fg-primary", children: chrome.name }) }), _jsx(SiteNav, { items: navItems, currentPath: currentPath, Link: Link })] }) }) }));
+}
+export function SiteFooter({ chrome }) {
+    return (_jsx("footer", { className: "mt-24 border-t border-subtle", children: _jsxs("div", { className: "mx-auto max-w-shell px-4 py-12 sm:px-6 lg:px-8", children: [_jsx("p", { className: "max-w-prose text-sm leading-relaxed text-fg-secondary", children: chrome.footerNote }), _jsxs("div", { className: "mt-8 flex flex-col gap-2 border-t border-subtle pt-6 font-mono text-xs uppercase tracking-caps text-fg-muted sm:flex-row sm:items-center sm:justify-between", children: [chrome.host && _jsx("span", { children: chrome.host }), _jsxs("span", { className: "normal-case tracking-normal", children: ["\u00A9 ", chrome.name] })] })] }) }));
+}

package/dist/react/SiteNav.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The masthead's section nav.
+ *
+ * A server component, deliberately: the injected `Link` is a component
+ * function, and functions cannot cross into a 'use client' boundary. The one
+ * client behaviour — scrolling the active item into view — lives in
+ * `NavAutoScroll`, which takes only a string.
+ */
+import type { SiteNavItem } from '../schema.js';
+import { type LinkLike } from './link.js';
+interface Props {
+    /**
+     * Deliberately NOT `SitePage[]`. Everything the nav receives ends up in the
+     * payload of every page it renders on.
+     */
+    items: SiteNavItem[];
+    currentPath: string;
+    /** Framework link component (e.g. next/link). Defaults to a plain anchor. */
+    Link?: LinkLike;
+}
+export declare function SiteNav({ items, currentPath, Link }: Props): import("react").JSX.Element;
+export {};

package/dist/react/SiteNav.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The masthead's section nav.
+ *
+ * A server component, deliberately: the injected `Link` is a component
+ * function, and functions cannot cross into a 'use client' boundary. The one
+ * client behaviour — scrolling the active item into view — lives in
+ * `NavAutoScroll`, which takes only a string.
+ */
+import { href } from '../model.js';
+import { DefaultLink } from './link.js';
+import { NavAutoScroll } from './NavAutoScroll.js';
+export function SiteNav({ items, currentPath, Link = DefaultLink }) {
+    return (_jsxs("nav", { "data-sitekit-nav": true, "aria-label": "Sections", className: "scrollbar-hide -mx-1 flex flex-nowrap items-center gap-x-1 overflow-x-auto", children: [items.map((item) => {
+                const isCurrent = item.path === currentPath;
+                return (_jsx(Link, { href: href(item.path), "aria-current": isCurrent ? 'page' : undefined, className: [
+                        // min-h-11 is the 44px touch floor. `px-2 py-1` on text-xs came out
+                        // around 28px, which is a fiddly target on a phone and below the
+                        // floor the rest of the fleet holds. The masthead row drops from
+                        // py-4 to py-2 to pay for it, so the sticky header does NOT get
+                        // taller — see the comment in SiteChrome.
+                        'inline-flex min-h-11 shrink-0 items-center rounded px-2 font-mono text-xs uppercase tracking-caps transition-colors',
+                        // A consumer's CSS reset can remove the UA focus ring, and this
+                        // package shipped nothing to replace it — so keyboard users had no
+                        // visible position in the nav on every site that installs it.
+                        'focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-accent',
+                        isCurrent
+                            ? 'text-fg-primary underline decoration-accent decoration-2 underline-offset-8'
+                            : 'text-fg-tertiary hover:text-fg-primary',
+                    ].join(' '), children: item.label }, item.path || 'home'));
+            }), _jsx(NavAutoScroll, { currentPath: currentPath })] }));
+}

package/dist/react/SiteSections.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Dispatches a page's sections to their renderers, and numbers them.
+ *
+ * One renderer for every site is the point: it is what stops fifty customer
+ * websites becoming fifty stylesheets, and it is why a site inherits
+ * typography, dark mode and reading measure without its owner thinking about
+ * any of them. Section shapes are the closed set in the schema.
+ *
+ * Numbering counts only sections that carry a heading, so an unheaded lead
+ * paragraph or a bare table does not consume a number and leave a gap in the
+ * sequence a reader can see.
+ */
+import type { SiteSection } from '../schema.js';
+export declare function SiteSections({ sections }: {
+    sections: SiteSection[];
+}): import("react").JSX.Element;

package/dist/react/SiteSections.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { HeroSection } from './sections/HeroSection.js';
+import { MeterSection, StatsSection } from './sections/FigureSections.js';
+import { CardsSection, DefinitionsSection, ProseSection } from './sections/ProseSections.js';
+import { IndexSection, TableSection } from './sections/DataSections.js';
+import { ContactSection, FaqSection, FeatureSection } from './sections/BusinessSections.js';
+/** True when a section shows a heading, and therefore takes the next number. */
+function isNumbered(section) {
+    return section.kind !== 'hero' && section.kind !== 'table' && Boolean(section.heading);
+}
+export function SiteSections({ sections }) {
+    let counter = 0;
+    return (_jsx("div", { className: "space-y-16", children: sections.map((section, key) => {
+            const index = isNumbered(section) ? ++counter : undefined;
+            switch (section.kind) {
+                case 'hero':
+                    return _jsx(HeroSection, { section: section }, key);
+                case 'prose':
+                    return _jsx(ProseSection, { section: section, index: index }, key);
+                case 'stats':
+                    return _jsx(StatsSection, { section: section, index: index }, key);
+                case 'meter':
+                    return _jsx(MeterSection, { section: section, index: index }, key);
+                case 'cards':
+                    return _jsx(CardsSection, { section: section, index: index }, key);
+                case 'definitions':
+                    return _jsx(DefinitionsSection, { section: section, index: index }, key);
+                case 'feature':
+                    return _jsx(FeatureSection, { section: section, index: index }, key);
+                case 'contact':
+                    return _jsx(ContactSection, { section: section, index: index }, key);
+                case 'faq':
+                    return _jsx(FaqSection, { section: section, index: index }, key);
+                case 'index':
+                    return _jsx(IndexSection, { section: section, index: index }, key);
+                case 'table':
+                    return _jsx(TableSection, { section: section }, key);
+                default:
+                    return null;
+            }
+        }) }));
+}

package/dist/react/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @bitbaum/sitekit/react — the one set of renderers every generated site shares.
+ *
+ * Emits SEMANTIC utility classes only (`text-fg-primary`, `bg-surface-page`,
+ * `font-heading`, …) and ships no colours, faces or radii: each consumer
+ * defines those tokens in its own stylesheet. Uniform system, divergent
+ * aesthetics — the class contract is in the README.
+ */
+export { SiteSections } from './SiteSections.js';
+export { SiteMasthead, SiteFooter } from './SiteChrome.js';
+export { SiteNav } from './SiteNav.js';
+export { NavAutoScroll } from './NavAutoScroll.js';
+export { DefaultLink, type LinkLike, type LinkProps } from './link.js';
+export { SectionHeading, Blurb, SectionBody } from './sections/Primitives.js';
+export { HeroSection } from './sections/HeroSection.js';
+export { ProseSection, CardsSection, DefinitionsSection } from './sections/ProseSections.js';
+export { StatsSection, MeterSection } from './sections/FigureSections.js';
+export { IndexSection, TableSection } from './sections/DataSections.js';
+export { FeatureSection, ContactSection, FaqSection } from './sections/BusinessSections.js';

package/dist/react/index.js

@@ -0,0 +1,19 @@
+/**
+ * @bitbaum/sitekit/react — the one set of renderers every generated site shares.
+ *
+ * Emits SEMANTIC utility classes only (`text-fg-primary`, `bg-surface-page`,
+ * `font-heading`, …) and ships no colours, faces or radii: each consumer
+ * defines those tokens in its own stylesheet. Uniform system, divergent
+ * aesthetics — the class contract is in the README.
+ */
+export { SiteSections } from './SiteSections.js';
+export { SiteMasthead, SiteFooter } from './SiteChrome.js';
+export { SiteNav } from './SiteNav.js';
+export { NavAutoScroll } from './NavAutoScroll.js';
+export { DefaultLink } from './link.js';
+export { SectionHeading, Blurb, SectionBody } from './sections/Primitives.js';
+export { HeroSection } from './sections/HeroSection.js';
+export { ProseSection, CardsSection, DefinitionsSection } from './sections/ProseSections.js';
+export { StatsSection, MeterSection } from './sections/FigureSections.js';
+export { IndexSection, TableSection } from './sections/DataSections.js';
+export { FeatureSection, ContactSection, FaqSection } from './sections/BusinessSections.js';

package/dist/react/link.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The one framework seam in the package.
+ *
+ * The chrome needs to render links, and every framework has its own Link with
+ * its own prefetching. Rather than depending on any of them, components that
+ * link accept a `Link` component and default to a plain anchor — correct
+ * everywhere, and a Next.js consumer passes `next/link` to get client-side
+ * navigation back.
+ */
+import { type ComponentType, type ReactNode } from 'react';
+export interface LinkProps {
+    href: string;
+    className?: string;
+    'aria-current'?: 'page';
+    children?: ReactNode;
+}
+export type LinkLike = ComponentType<LinkProps>;
+export declare const DefaultLink: LinkLike;

package/dist/react/link.js

@@ -0,0 +1,11 @@
+/**
+ * The one framework seam in the package.
+ *
+ * The chrome needs to render links, and every framework has its own Link with
+ * its own prefetching. Rather than depending on any of them, components that
+ * link accept a `Link` component and default to a plain anchor — correct
+ * everywhere, and a Next.js consumer passes `next/link` to get client-side
+ * navigation back.
+ */
+import { createElement } from 'react';
+export const DefaultLink = (props) => createElement('a', props);