@caltho/site-kit 0.0.0-stage → 0.1.0

package/dist/content/index.js

@@ -0,0 +1,190 @@
+// The contract between a site and CalOS: what a site's content is, whatever the site looks like.
+//
+// A site (its `content/site.json`, or CalOS's published version of it) is the business's facts and a
+// list of pages, each a list of blocks. The site decides what blocks there are: it names them and
+// says what fields each has, in `content/schema.ts`, with `defineSite`. This module checks the
+// content against that, says every problem and where it is, checks that links land, and writes the
+// declaration as JSON Schema, which is what CalOS draws its editing forms from.
+//
+// Nothing here knows how a block looks. A custom design adds its own kinds of block and CalOS edits
+// them with no further work.
+import { z } from "zod";
+export { z };
+export const text = z.string().trim().min(1);
+/** Markdown: paragraphs, **bold**, *italic*, [links](/contact), lists, ### small headings. No HTML. */
+export const md = text;
+/** A file in the site's `content/images/` folder. */
+export const file = z.string().regex(/^[\w.\-/]+\.(jpe?g|png|webp|avif|svg)$/i, { error: "An image file in content/images, like team/anna.jpg" });
+/** Describe what's in the picture for someone who can't see it; "" only when it's decoration. */
+export const image = z.object({ src: file, alt: z.string() });
+export const href = z.string().regex(/^(\/[\w\-./#?=&%]*|#[\w-]+|https?:\/\/\S+|tel:\+?[\d\s()-]+|mailto:\S+@\S+)$/, {
+    error: "A link: a page on the site (/services), a part of a page (#contact), a full address (https://…), tel: or mailto:",
+});
+export const link = z.object({ label: text, href, style: z.enum(["primary", "secondary"]).optional() });
+export const time = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, { error: "A time like 08:00 or 17:30" });
+export const DAYS = ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"];
+/** What every block has: a place on the page, for links like /#contact. */
+const blockBase = { id: z.string().regex(/^[a-z][\w-]*$/).optional() };
+const address = z.object({
+    street: text,
+    locality: text,
+    region: text,
+    postcode: text,
+    country: z.string().length(2).default("US"),
+});
+/** The business's facts: the header, footer, hours, contact details and search data all come from here. */
+export const business = z.object({
+    name: text,
+    /** The schema.org kind: Plumber, Electrician, HVACBusiness, Dentist, HairSalon, Restaurant, LocalBusiness… */
+    kind: z.string().regex(/^[A-Z]\w+$/).default("LocalBusiness"),
+    tagline: text.optional(),
+    phone: z.string().regex(/^\+?[\d\s().-]{7,}$/, { error: "A phone number like (555) 010-2030" }).optional(),
+    email: z.email().optional(),
+    address: address.optional(),
+    /** Off for a business that goes to its customers and doesn't take visitors at its address. */
+    showAddress: z.boolean().default(true),
+    areas: z.array(text).default([]),
+    hours: z.array(z.object({ days: z.array(z.enum(DAYS)).min(1), opens: time, closes: time })).default([]),
+    /** A line under the hours: "24/7 emergency line". */
+    hoursNote: text.optional(),
+    logo: image.optional(),
+    founded: z.number().int().min(1800).max(2100).optional(),
+    licence: text.optional(),
+    priceRange: z.string().max(10).optional(),
+    social: z
+        .object({ facebook: z.url(), instagram: z.url(), google: z.url(), yelp: z.url(), nextdoor: z.url(), linkedin: z.url(), youtube: z.url(), tiktok: z.url() })
+        .partial()
+        .default({}),
+});
+const pageBase = {
+    path: z.string().regex(/^\/([a-z0-9-]+\/)*$/, { error: "A path like / or /services/ or /areas/springfield/ (lowercase, ending in /)" }),
+    /** The page's title in search results and the browser tab. The business's name is added after it. */
+    title: text.max(60, { error: "Keep a title under 60 characters so search results show it whole" }),
+    /** What search results show under the title. */
+    description: text.max(160, { error: "Keep a description under 160 characters so search results show it whole" }),
+    /** Its label in the menu; leave out to keep it off the menu. */
+    menu: text.optional(),
+    /** The picture shown when the page is shared; defaults to the first image on it. */
+    share: image.optional(),
+    noindex: z.boolean().default(false),
+};
+/**
+ * A site's content shape from its blocks: each a name and the fields it has. The site's own block
+ * type is `z.output<typeof content.schema>["pages"][number]["blocks"][number]`.
+ */
+export function defineSite(blocks, o = {}) {
+    const names = Object.keys(blocks);
+    if (!names.length)
+        throw new Error("A site needs at least one kind of block");
+    const union = z.discriminatedUnion("type", names.map((type) => z.object({ type: z.literal(type), ...blockBase }).extend(blocks[type].shape)));
+    const page = z.object({ ...pageBase, blocks: z.array(union).min(1) });
+    const schema = z
+        .object({
+        /** The address it's served at once live (its main domain). */
+        url: z.url({ protocol: /^https$/, error: "The site's address, starting https://" }),
+        lang: z.string().default("en-US"),
+        business,
+        /** Where the contact forms post to, if the site has any (a CalOS form's address, or another service's). */
+        form: z.url({ protocol: /^https?$/ }).optional(),
+        /** Old addresses kept answering, when CalOS doesn't supply them at build. */
+        redirects: z.array(z.object({ from: z.string().startsWith("/"), to: href, status: z.union([z.literal(301), z.literal(302)]).default(301) })).default([]),
+        ...o.extend,
+        pages: z.array(page).min(1),
+    })
+        .superRefine((site, ctx) => {
+        const s = site;
+        const paths = new Set();
+        s.pages.forEach((p, i) => {
+            if (paths.has(p.path))
+                ctx.addIssue({ code: "custom", path: ["pages", i, "path"], message: `Two pages at ${p.path}` });
+            paths.add(p.path);
+        });
+        if (!paths.has("/"))
+            ctx.addIssue({ code: "custom", path: ["pages"], message: "There's no home page: add a page with path /" });
+        checkLinks(s, ctx);
+        o.refine?.(s, ctx);
+    });
+    return {
+        schema,
+        /** The content checked, or every problem in it as "where: what" lines. */
+        parse(raw) {
+            const r = schema.safeParse(raw);
+            return r.success ? { site: r.data } : { problems: r.error.issues.map((i) => `${where(raw, i.path)}: ${i.message}`) };
+        },
+        /** The declaration CalOS draws its editing forms from. */
+        jsonSchema: () => z.toJSONSchema(schema, { io: "input", unrepresentable: "any" }),
+    };
+}
+/** Every link to a page of the site must land on one, and every link to a part of a page must have that part. */
+function checkLinks(site, ctx) {
+    const ids = new Map(site.pages.map((p) => [p.path, new Set(p.blocks.map((b) => b.id).filter(Boolean))]));
+    const visit = (value, path, page) => {
+        if (Array.isArray(value))
+            value.forEach((v, i) => visit(v, [...path, i], page));
+        else if (value && typeof value === "object") {
+            for (const [k, v] of Object.entries(value)) {
+                if (k === "href" && typeof v === "string" && (v.startsWith("#") || v.startsWith("/"))) {
+                    const to = v.startsWith("#") && page ? page.path + v : v;
+                    const [p, hash] = to.split("#");
+                    const target = p.split("?")[0];
+                    if (!ids.has(target))
+                        ctx.addIssue({ code: "custom", path: [...path, k], message: `No page at ${target}` });
+                    else if (hash && !ids.get(target).has(hash))
+                        ctx.addIssue({ code: "custom", path: [...path, k], message: `${target} has no block with id "${hash}"` });
+                }
+                else
+                    visit(v, [...path, k], page);
+            }
+        }
+    };
+    site.pages.forEach((p, i) => visit(p.blocks, ["pages", i, "blocks"], p));
+    for (const [k, v] of Object.entries(site))
+        if (k !== "pages" && k !== "redirects")
+            visit(v, [k], null);
+}
+/** "pages[2] (/services/) › blocks[1] (services) › items[0].title", readable in a build log. */
+function where(raw, path) {
+    let at = raw;
+    const out = [];
+    for (const key of path) {
+        at = at && typeof at === "object" ? at[key] : undefined;
+        if (typeof key === "number") {
+            const o = at;
+            const label = o && typeof o === "object" ? (o.path ?? o.type ?? o.title ?? o.name ?? o.label) : undefined;
+            out[out.length - 1] = `${out[out.length - 1] ?? ""}[${key}]${typeof label === "string" ? ` (${label})` : ""}`;
+        }
+        else
+            out.push(String(key));
+    }
+    return out.join(" › ") || "site.json";
+}
+/** "Mon–Fri", "Sat", "Mon, Wed, Fri" for a set of days. */
+export function dayRange(days) {
+    const NAMES = { Mo: "Mon", Tu: "Tue", We: "Wed", Th: "Thu", Fr: "Fri", Sa: "Sat", Su: "Sun" };
+    const idx = [...new Set(days.map((d) => DAYS.indexOf(d)))].sort((a, b) => a - b);
+    const runs = [];
+    for (const i of idx) {
+        const last = runs.at(-1);
+        if (last && last.at(-1) === i - 1)
+            last.push(i);
+        else
+            runs.push([i]);
+    }
+    return runs.map((r) => (r.length >= 3 ? `${NAMES[DAYS[r[0]]]}–${NAMES[DAYS[r.at(-1)]]}` : r.map((i) => NAMES[DAYS[i]]).join(", "))).join(", ");
+}
+/** "8am", "5:30pm". */
+export function clock(t) {
+    const [h, m] = t.split(":").map(Number);
+    const suffix = h >= 12 ? "pm" : "am";
+    const hour = h % 12 || 12;
+    return m ? `${hour}:${String(m).padStart(2, "0")}${suffix}` : `${hour}${suffix}`;
+}
+/** "tel:+15550102030" from however the number is written. */
+export function telHref(phone, country = "US") {
+    const digits = phone.replace(/[^\d+]/g, "");
+    if (digits.startsWith("+"))
+        return `tel:${digits}`;
+    if (country === "US" && digits.length === 10)
+        return `tel:+1${digits}`;
+    return `tel:${digits}`;
+}

package/dist/finish.d.ts

@@ -0,0 +1,3 @@
+type Log = (line: string) => void;
+export declare function finish(root: string, outDir: string, env?: Record<string, string | undefined>, log?: Log): Promise<void>;
+export {};

package/dist/finish.js

@@ -0,0 +1,64 @@
+// What a site's build output needs after the framework is done: a content security policy in every
+// page, naming by hash each inline script and style the page carries (Next.js writes its page data
+// as inline scripts; a static page can't carry a per-request nonce), and Cloudflare Pages' `_headers`
+// and `_redirects` beside the pages.
+import { createHash } from "node:crypto";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { headersFile, loadRedirects } from "./seo.js";
+export async function finish(root, outDir, env = process.env, log = console.log) {
+    const prepared = JSON.parse(await readFile(join(root, ".site", "prepared.json"), "utf8"));
+    const site = prepared.site;
+    const formOrigin = site.form ? new URL(site.form).origin : null;
+    const pages = (await walk(outDir)).filter((f) => f.endsWith(".html"));
+    const attributes = [];
+    for (const file of pages) {
+        let html = await readFile(file, "utf8");
+        const scripts = new Set();
+        const styles = new Set();
+        for (const m of html.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script>/gi)) {
+            const [, attrs, body] = m;
+            if (/\bsrc\s*=/.test(attrs) || /type\s*=\s*["']?application\/ld\+json/i.test(attrs) || !body)
+                continue;
+            scripts.add(hash(body));
+        }
+        for (const m of html.matchAll(/<style\b[^>]*>([\s\S]*?)<\/style>/gi))
+            styles.add(hash(m[1]));
+        // A style attribute can't be allowed by hash without allowing every one: the template uses classes.
+        if (/<[a-z][^>]*\sstyle\s*=/i.test(html))
+            attributes.push(relative(outDir, file));
+        const policy = [
+            "default-src 'self'",
+            `script-src 'self'${[...scripts].map((h) => ` '${h}'`).join("")}`,
+            `style-src 'self'${[...styles].map((h) => ` '${h}'`).join("")}`,
+            "img-src 'self' data:",
+            "font-src 'self'",
+            "connect-src 'self'",
+            `form-action 'self'${formOrigin ? ` ${formOrigin}` : ""}`,
+            "base-uri 'self'",
+            "object-src 'none'",
+        ].join("; ");
+        html = html.replace(/<meta http-equiv="content-security-policy"[^>]*>/i, "");
+        html = html.replace(/<head([^>]*)>/i, `<head$1><meta http-equiv="content-security-policy" content="${policy}">`);
+        await writeFile(file, html);
+    }
+    if (attributes.length) {
+        throw new Error(`These pages have inline style attributes, which the content security policy blocks: ${attributes.join(", ")}. Use a class instead.`);
+    }
+    await writeFile(join(outDir, "_headers"), headersFile());
+    const redirects = await loadRedirects(site, env.CALOS_REDIRECTS_URL);
+    await writeFile(join(outDir, "_redirects"), redirects.file);
+    log(`site-kit: a content security policy in ${pages.length} pages; _headers; _redirects from ${redirects.from}`);
+}
+const hash = (body) => `sha256-${createHash("sha256").update(body, "utf8").digest("base64")}`;
+async function walk(dir) {
+    const out = [];
+    for (const e of await readdir(dir, { withFileTypes: true })) {
+        const p = join(dir, e.name);
+        if (e.isDirectory())
+            out.push(...(await walk(p)));
+        else
+            out.push(p);
+    }
+    return out;
+}

package/dist/images.d.ts

@@ -0,0 +1,5 @@
+import type { Image, Page, Site } from "./content/index.ts";
+/** Every image the content names: the shape of a value with a `src` that's an image file. */
+export declare function imagesIn(value: unknown, found?: Set<string>): Set<string>;
+/** The picture a page shows when it's shared: its own, else its first, else the home page's first. */
+export declare function shareImageOf(site: Site, page: Page): Image | undefined;

package/dist/images.js

@@ -0,0 +1,40 @@
+// Which pictures a site's content names, and which one a page is shared with. Pure: no files, no
+// sharp, so a site's components can use it as well as the build step.
+/** Every image the content names: the shape of a value with a `src` that's an image file. */
+export function imagesIn(value, found = new Set()) {
+    if (Array.isArray(value))
+        value.forEach((v) => imagesIn(v, found));
+    else if (value && typeof value === "object") {
+        const o = value;
+        if (typeof o.src === "string" && "alt" in o && /\.(jpe?g|png|webp|avif|svg)$/i.test(o.src))
+            found.add(o.src);
+        Object.values(o).forEach((v) => imagesIn(v, found));
+    }
+    return found;
+}
+/** The picture a page shows when it's shared: its own, else its first, else the home page's first. */
+export function shareImageOf(site, page) {
+    const first = (p) => [...imagesIn(p.blocks)].map((src) => findImage(p.blocks, src)).find(Boolean);
+    const pick = page.share ?? first(page) ?? first(site.pages.find((p) => p.path === "/"));
+    return pick && !pick.src.endsWith(".svg") ? pick : undefined;
+}
+function findImage(value, src) {
+    if (Array.isArray(value)) {
+        for (const v of value) {
+            const f = findImage(v, src);
+            if (f)
+                return f;
+        }
+    }
+    else if (value && typeof value === "object") {
+        const o = value;
+        if (o.src === src && typeof o.alt === "string")
+            return { src, alt: o.alt };
+        for (const v of Object.values(o)) {
+            const f = findImage(v, src);
+            if (f)
+                return f;
+        }
+    }
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./content/index.ts";
+export { finish } from "./finish.ts";
+export { md, mdInline, plain } from "./markdown.ts";
+export { policy, type Policy } from "./policies.ts";
+export * from "./images.ts";
+export { prepare, type Prepared, type PreparedImage } from "./prepare.ts";
+export * from "./seo.ts";

package/dist/index.js

@@ -0,0 +1,10 @@
+// What every Caltho site shares, whatever it looks like or is built with: the contract with CalOS (what
+// content is and how a site declares its blocks), search and security, the policies, and the steps
+// around a build (prepare, finish). Designs are the sites' own.
+export * from "./content/index.js";
+export { finish } from "./finish.js";
+export { md, mdInline, plain } from "./markdown.js";
+export { policy } from "./policies.js";
+export * from "./images.js";
+export { prepare } from "./prepare.js";
+export * from "./seo.js";

package/dist/lib.d.ts

@@ -0,0 +1,5 @@
+export * from "./content/index.ts";
+export * from "./images.ts";
+export { md, mdInline, plain } from "./markdown.ts";
+export { policy, type Policy } from "./policies.ts";
+export * from "./seo.ts";

package/dist/lib.js

@@ -0,0 +1,8 @@
+// The kit's helpers that touch no files and no sharp, for a site's own components: Markdown that can't
+// run HTML, the generated policies, search data, which pictures a page uses, and the content's words
+// for hours and phone numbers.
+export * from "./content/index.js";
+export * from "./images.js";
+export { md, mdInline, plain } from "./markdown.js";
+export { policy } from "./policies.js";
+export * from "./seo.js";

package/dist/markdown.d.ts

@@ -0,0 +1,6 @@
+/** `top`: the level a "##" heading in it becomes. */
+export declare function md(source: string, top?: number): string;
+/** One line of Markdown without the paragraph around it. */
+export declare function mdInline(source: string): string;
+/** The words alone, for structured data. */
+export declare function plain(source: string): string;

package/dist/markdown.js

@@ -0,0 +1,50 @@
+// The little Markdown site.json allows: paragraphs, emphasis, links, lists and small headings.
+// HTML written into it is shown as text, never run, so content from an owner can't put a script
+// on their page. Headings start a level under the section's own heading (h3, or h2 on a page
+// whose section heading is its h1).
+import { Marked } from "marked";
+const escape = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const make = (top) => new Marked({
+    gfm: true,
+    breaks: false,
+    renderer: {
+        html({ text }) {
+            return escape(text);
+        },
+        heading({ tokens, depth }) {
+            const level = Math.min(6, Math.max(top, depth + top - 2));
+            return `<h${level}>${this.parser.parseInline(tokens)}</h${level}>\n`;
+        },
+        link({ href, title, tokens }) {
+            const text = this.parser.parseInline(tokens);
+            const safe = /^(https?:|mailto:|tel:|\/|#)/i.test(href) ? href : "#";
+            const external = /^https?:/i.test(safe);
+            return `<a href="${escape(safe)}"${title ? ` title="${escape(title)}"` : ""}${external ? ' rel="noopener"' : ""}>${text}</a>`;
+        },
+        image({ text }) {
+            return escape(text);
+        },
+    },
+});
+const parsers = new Map();
+const marked = (top = 3) => parsers.get(top) ?? parsers.set(top, make(top)).get(top);
+/** `top`: the level a "##" heading in it becomes. */
+export function md(source, top = 3) {
+    return marked(top).parse(source, { async: false });
+}
+/** One line of Markdown without the paragraph around it. */
+export function mdInline(source) {
+    return marked().parseInline(source, { async: false });
+}
+/** The words alone, for structured data. */
+export function plain(source) {
+    return md(source)
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/\s+/g, " ")
+        .trim();
+}

package/dist/next/JsonLd.d.ts

@@ -0,0 +1,4 @@
+/** Structured data for search engines, in a script browsers don't run. */
+export declare function JsonLd({ data }: {
+    data: Record<string, unknown> | null;
+}): import("react").JSX.Element | null;

package/dist/next/JsonLd.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ldJson } from "../seo.js";
+/** Structured data for search engines, in a script browsers don't run. */
+export function JsonLd({ data }) {
+    if (!data)
+        return null;
+    return _jsx("script", { type: "application/ld+json", dangerouslySetInnerHTML: { __html: ldJson(data) } });
+}

package/dist/next/data.d.ts

@@ -0,0 +1,7 @@
+import type { Page } from "../content/index.ts";
+import type { Prepared, PreparedImage } from "../prepare.ts";
+export declare function prepared(): Prepared;
+export declare const site: () => import("../content/index.ts").Site;
+export declare function image(src: string): PreparedImage;
+/** The page at a catch-all route's segments (`[[...path]]`), or null. */
+export declare function pageAt(path: string[] | undefined): Page | null;

package/dist/next/data.js

@@ -0,0 +1,27 @@
+// What `site-kit prepare` made ready, read once per build from `.site/prepared.json`.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+let cached = null;
+export function prepared() {
+    if (!cached || process.env.NODE_ENV === "development") {
+        try {
+            cached = JSON.parse(readFileSync(join(process.cwd(), ".site", "prepared.json"), "utf8"));
+        }
+        catch {
+            throw new Error("The site isn't prepared: run `site-kit prepare` before the build (the dev and build scripts do)");
+        }
+    }
+    return cached;
+}
+export const site = () => prepared().site;
+export function image(src) {
+    const found = prepared().images[src];
+    if (!found)
+        throw new Error(`The image "${src}" wasn't prepared: run \`site-kit prepare\` again`);
+    return found;
+}
+/** The page at a catch-all route's segments (`[[...path]]`), or null. */
+export function pageAt(path) {
+    const at = path?.length ? `/${path.join("/")}/` : "/";
+    return site().pages.find((p) => p.path === at) ?? null;
+}

package/dist/next/index.d.ts

@@ -0,0 +1,5 @@
+export { image, pageAt, prepared, site } from "./data.ts";
+export { JsonLd } from "./JsonLd.tsx";
+export { pageMetadata, robots, sitemap, staticParams } from "./metadata.ts";
+export { Img, type Ratio } from "./parts/Img.tsx";
+export { Md } from "./parts/Md.tsx";

package/dist/next/index.js

@@ -0,0 +1,8 @@
+// The plumbing a Next.js site needs from the kit, whatever its design: the prepared content, a page by
+// its path, metadata, picture and Markdown parts, structured data. A site's own components, in its own
+// repository, do the looks. Server components only: nothing here runs in the visitor's browser.
+export { image, pageAt, prepared, site } from "./data.js";
+export { JsonLd } from "./JsonLd.js";
+export { pageMetadata, robots, sitemap, staticParams } from "./metadata.js";
+export { Img } from "./parts/Img.js";
+export { Md } from "./parts/Md.js";

package/dist/next/metadata.d.ts

@@ -0,0 +1,9 @@
+import type { Metadata, MetadataRoute } from "next";
+import type { Page } from "../content/index.ts";
+export declare function pageMetadata(page: Page): Metadata;
+/** For `generateStaticParams` on `app/[[...path]]/page.tsx`. */
+export declare function staticParams(): {
+    path: string[];
+}[];
+export declare function robots(): MetadataRoute.Robots;
+export declare function sitemap(): MetadataRoute.Sitemap;

package/dist/next/metadata.js

@@ -0,0 +1,40 @@
+// The Next.js side of search: each page's metadata, the static routes, robots.txt and the sitemap,
+// all from the prepared content.
+import { shareImageOf } from "../images.js";
+import { canonical, fullTitle } from "../seo.js";
+import { image, site } from "./data.js";
+export function pageMetadata(page) {
+    const s = site();
+    const title = fullTitle(s, page);
+    const url = canonical(s, page.path);
+    const share = shareImageOf(s, page);
+    const shareUrl = share ? image(share.src).share : undefined;
+    return {
+        metadataBase: new URL(s.url),
+        title: { absolute: title },
+        description: page.description,
+        alternates: { canonical: url },
+        robots: page.noindex ? { index: false, follow: true } : undefined,
+        openGraph: {
+            type: "website",
+            siteName: s.business.name,
+            title,
+            description: page.description,
+            url,
+            locale: s.lang.replace("-", "_"),
+            images: shareUrl && share ? [{ url: new URL(shareUrl, s.url).href, width: 1200, height: 630, alt: share.alt }] : undefined,
+        },
+        twitter: { card: shareUrl ? "summary_large_image" : "summary" },
+    };
+}
+/** For `generateStaticParams` on `app/[[...path]]/page.tsx`. */
+export function staticParams() {
+    return site().pages.map((p) => ({ path: p.path.split("/").filter(Boolean) }));
+}
+export function robots() {
+    return { rules: { userAgent: "*", allow: "/" }, sitemap: canonical(site(), "/sitemap.xml") };
+}
+export function sitemap() {
+    const s = site();
+    return s.pages.filter((p) => !p.noindex).map((p) => ({ url: canonical(s, p.path) }));
+}

package/dist/next/parts/Img.d.ts

@@ -0,0 +1,9 @@
+export type Ratio = "1/1" | "3/2" | "4/3" | "4/5" | "16/9";
+export declare function Img({ src, alt, sizes, ratio, eager, className }: {
+    src: string;
+    alt: string;
+    sizes: string;
+    ratio?: Ratio;
+    eager?: boolean;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/next/parts/Img.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// A picture from the site's images, at the widths `site-kit prepare` made: `sizes` says how wide
+// it shows, the browser picks the copy. Cropped to a shape by class (`ratio-4-3`), not by a
+// style attribute, which the content security policy would block. Above the fold (`eager`) it
+// loads first; everywhere else it waits until it's near.
+import { image } from "../data.js";
+export function Img({ src, alt, sizes, ratio, eager = false, className }) {
+    const m = image(src);
+    const [rw, rh] = ratio ? ratio.split("/").map(Number) : [m.width, m.height];
+    const width = m.width;
+    const height = Math.round((width * rh) / rw);
+    const classes = [ratio ? `ratio-${ratio.replace("/", "-")}` : null, className].filter(Boolean).join(" ") || undefined;
+    return (_jsx("img", { src: m.src, srcSet: m.srcset.length ? m.srcset.map((s) => `${s.url} ${s.w}w`).join(", ") : undefined, sizes: m.srcset.length ? sizes : undefined, width: width, height: height, alt: alt, loading: eager ? "eager" : "lazy", decoding: eager ? "sync" : "async", fetchPriority: eager ? "high" : undefined, className: classes }));
+}

package/dist/next/parts/Md.d.ts

@@ -0,0 +1,6 @@
+/** Markdown from the content: HTML in it is shown as text (lib markdown.ts). `top` is the level "##" becomes. */
+export declare function Md({ text, top, className }: {
+    text: string;
+    top?: number;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/next/parts/Md.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { md } from "../../markdown.js";
+/** Markdown from the content: HTML in it is shown as text (lib markdown.ts). `top` is the level "##" becomes. */
+export function Md({ text, top = 3, className }) {
+    return _jsx("div", { className: className ? `prose ${className}` : "prose", dangerouslySetInnerHTML: { __html: md(text, top) } });
+}

package/dist/policies.d.ts

@@ -0,0 +1,12 @@
+import type { Site } from "./content/index.ts";
+export type Policy = {
+    title: string;
+    body: string;
+};
+/**
+ * `collectsFromForm`: the site has a form that takes a visitor's name, email and message, which the
+ * privacy policy says (it defaults to the site having a form address).
+ */
+export declare function policy(site: Site, which: "privacy" | "accessibility" | "terms", o?: {
+    collectsFromForm?: boolean;
+}): Policy;