@caltho/site-kit 0.2.11 → 0.3.0

package/dist/content/lists.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import type { Block, Page } from "./index.ts";
+/** The kinds a list's field may be. */
+export declare const FIELD_KINDS: readonly ["text", "longText", "image", "link", "number", "date"];
+export type FieldKind = (typeof FIELD_KINDS)[number];
+export type ListField = {
+    key: string;
+    label: string;
+    kind: FieldKind;
+};
+/** An item: its id (stable, from CalOS), its address part, and a value per field. */
+export type ListItem = {
+    id: string;
+    slug: string;
+    [field: string]: unknown;
+};
+/** A list's page: where its items live, the fields that title and describe each, and its design. */
+export type ListPage = {
+    path: string;
+    title: string;
+    description?: string;
+    blocks: Block[];
+};
+export type List = {
+    name: string;
+    fields: ListField[];
+    items: ListItem[];
+    page?: ListPage;
+};
+/** An item page's blocks carry the item they're drawn with (read by built sections as `this.`). */
+export declare const THIS_ITEM = "thisItem";
+type WithLists = {
+    pages: Page[];
+    lists?: Record<string, List>;
+    trailingSlash?: boolean;
+};
+/** An item page's address: under its list's page, by its address part. */
+export declare const itemPath: (page: ListPage, slug: string, trailingSlash?: boolean) => string;
+/** Every item page of every list that has a page, as pages: its design's blocks, each carrying the item. */
+export declare function itemPages(site: WithLists): Page[];
+/**
+ * A section's items taken from one of the site's lists, as CalOS sets it when the business picks a
+ * list for a section that repeats things (Services, Team, Reviews): which list, the section's array
+ * it fills (`into`, fixed by the section), and each of an item's fields from which of the list's
+ * (PAGE_LINK: the item's own page). The section's typed items stay, unused, until the list is unpicked.
+ */
+export type FromList = {
+    list: string;
+    into: string;
+    fields: Record<string, string>;
+};
+/** In a FromList's fields: the item's own page, where its list has pages. */
+export declare const PAGE_LINK = "@page";
+/**
+ * The field a section that repeats things adds to say its items can come from a list: `into` names
+ * its array (`items`, `people`). CalOS offers the site's lists for it and matches the fields.
+ */
+export declare const fromList: (into: string) => z.ZodOptional<z.ZodObject<{
+    list: z.ZodString;
+    into: z.ZodDefault<z.ZodLiteral<string>>;
+    fields: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>>;
+/** A block with its items from a list, where it takes them from one (and the list is there): each item's fields as matched. */
+export declare function withListItems(block: Block, site: Pick<WithLists, "lists" | "trailingSlash">): Block;
+/** The site's pages and its lists' item pages: every address the site answers at, each section's items from its list where it takes them from one. */
+export declare const allPages: (site: WithLists) => Page[];
+/** Whether a page is an item page (its blocks carry an item). */
+export declare const itemOf: (page: Page) => ListItem | null;
+export {};

package/dist/content/lists.js

@@ -0,0 +1,77 @@
+// A site's lists (cal-os docs/design/site-lists.md): items of one kind (products, team members,
+// testimonials) kept once in the content, repeated by built sections (Repeats for
+// `lists.<key>.items`), and, where a list has a page, each item at its own address, drawn from one
+// design: `/products/walnut-desk/` is the products page's blocks with that item, read as `this.<field>`.
+// Pure: the build, the preview and CalOS find the same pages.
+import { z } from "zod";
+/** The kinds a list's field may be. */
+export const FIELD_KINDS = ["text", "longText", "image", "link", "number", "date"];
+/** An item page's blocks carry the item they're drawn with (read by built sections as `this.`). */
+export const THIS_ITEM = "thisItem";
+const listsOf = (site) => Object.entries(site.lists ?? {}).filter(([, l]) => l && typeof l === "object");
+/** An item page's address: under its list's page, by its address part. */
+export const itemPath = (page, slug, trailingSlash = true) => `${page.path.replace(/\/$/, "")}/${slug}${trailingSlash ? "/" : ""}`;
+/** Words for a value used as a page's title or description. */
+const words = (v) => (typeof v === "string" ? v : typeof v === "number" ? String(v) : "");
+/** Every item page of every list that has a page, as pages: its design's blocks, each carrying the item. */
+export function itemPages(site) {
+    const out = [];
+    for (const [, list] of listsOf(site)) {
+        const page = list.page;
+        if (!page || !Array.isArray(page.blocks) || !Array.isArray(list.items))
+            continue;
+        // The item's first picture is what it's shared with (no card made for each item).
+        const picture = list.fields.find((f) => f.kind === "image")?.key;
+        for (const item of list.items) {
+            if (!item?.slug)
+                continue;
+            const share = picture ? item[picture] : undefined;
+            out.push({
+                path: itemPath(page, item.slug, site.trailingSlash !== false),
+                title: words(item[page.title]) || item.slug,
+                description: page.description ? words(item[page.description]) : "",
+                noindex: false,
+                ...(share && typeof share === "object" && share.src ? { share } : {}),
+                blocks: page.blocks.map((b) => ({ ...b, [THIS_ITEM]: item })),
+            });
+        }
+    }
+    return out;
+}
+/** In a FromList's fields: the item's own page, where its list has pages. */
+export const PAGE_LINK = "@page";
+/**
+ * The field a section that repeats things adds to say its items can come from a list: `into` names
+ * its array (`items`, `people`). CalOS offers the site's lists for it and matches the fields.
+ */
+export const fromList = (into) => z
+    .object({
+    list: z.string().regex(/^[\w-]{1,60}$/),
+    into: z.literal(into).default(into),
+    fields: z.record(z.string().regex(/^[\w-]{1,60}$/), z.string().regex(/^(@page|[\w-]{1,60})$/)).default({}),
+})
+    .optional()
+    .meta({ title: "Items from a list", "x-ui": "list-source", "x-into": into });
+/** A block with its items from a list, where it takes them from one (and the list is there): each item's fields as matched. */
+export function withListItems(block, site) {
+    const from = block.from;
+    if (!from?.list || !from.into)
+        return block;
+    const list = site.lists?.[from.list];
+    if (!list || !Array.isArray(list.items))
+        return block;
+    const kinds = new Map(list.fields.map((f) => [f.key, f.kind]));
+    const items = list.items.map((item) => Object.fromEntries(Object.entries(from.fields ?? {}).flatMap(([to, src]) => {
+        const v = src === PAGE_LINK ? (list.page && item.slug ? itemPath(list.page, item.slug, site.trailingSlash !== false) : undefined) : item[src];
+        if (v !== undefined && v !== null && v !== "")
+            return [[to, v]];
+        // Words left empty are empty words, so a section drawing them as text has something to draw.
+        const kind = src === PAGE_LINK ? undefined : kinds.get(src);
+        return kind === "text" || kind === "longText" ? [[to, ""]] : [];
+    })));
+    return { ...block, [from.into]: items };
+}
+/** The site's pages and its lists' item pages: every address the site answers at, each section's items from its list where it takes them from one. */
+export const allPages = (site) => [...site.pages, ...itemPages(site)].map((p) => (p.blocks.some((b) => b.from?.list) ? { ...p, blocks: p.blocks.map((b) => withListItems(b, site)) } : p));
+/** Whether a page is an item page (its blocks carry an item). */
+export const itemOf = (page) => page.blocks[0]?.[THIS_ITEM] ?? null;

package/dist/content/lists.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/content/lists.test.js

@@ -0,0 +1,257 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+import { behaviorsIn, classesIn } from "../built/tree.js";
+import { built, node, treeProblems } from "../tree/index.js";
+import { BuiltSection } from "../next/built.js";
+import { pageAt, setPrepared } from "../next/data.js";
+import { sitemap, staticParams } from "../next/metadata.js";
+import { sitemapXml } from "../seo.js";
+import { allPages, defineSite, fromList, itemOf, text, withListItems, z } from "./index.js";
+// Lists (cal-os docs/design/site-lists.md): items kept once in the content, repeated by built
+// sections, and each item of a list with a page at its own address, drawn from one design.
+const content = defineSite({ hero: z.object({ heading: text }), built, list: z.object({ heading: text }) });
+const productPage = {
+    path: "/products/",
+    title: "name",
+    description: "summary",
+    blocks: [
+        {
+            type: "built",
+            root: {
+                id: "prodroot01",
+                tag: "section",
+                class: "p-6",
+                children: [
+                    { id: "prodname01", tag: "h1", class: "text-4xl", bind: { path: "this.name" } },
+                    { id: "prodpric01", tag: "p", bind: { path: "this.price" } },
+                    { id: "prodphot01", tag: "img", bind: { path: "this.photo" } },
+                    { id: "prodrela01", tag: "ul", children: [{ id: "prodrelb01", tag: "li", repeat: { path: "lists.products.items" }, bind: { path: "item.name" } }] },
+                ],
+            },
+        },
+    ],
+};
+const raw = (over = {}) => ({
+    url: "https://acme.example",
+    business: { name: "Acme" },
+    pages: [
+        { path: "/", title: "Acme", description: "Acme does things.", blocks: [{ type: "hero", heading: "Hello" }] },
+        { path: "/products/", title: "Products", description: "What we make.", blocks: [{ type: "hero", heading: "Products" }] },
+    ],
+    lists: {
+        products: {
+            name: "Products",
+            fields: [
+                { key: "name", label: "Name", kind: "text" },
+                { key: "summary", label: "Summary", kind: "longText" },
+                { key: "price", label: "Price", kind: "number" },
+                { key: "photo", label: "Photo", kind: "image" },
+            ],
+            items: [
+                { id: "rec-1", slug: "walnut-desk", name: "Walnut desk", summary: "Solid walnut.", price: 1200, photo: { src: "desk.jpg", alt: "The desk" } },
+                { id: "rec-2", slug: "oak-chair", name: "Oak chair", summary: "Sits well.", price: 300 },
+            ],
+            page: structuredClone(productPage),
+        },
+    },
+    ...over,
+});
+describe("a site's lists", () => {
+    it("takes lists, and a site without any has none", () => {
+        expect(content.parse(raw()).problems).toBeUndefined();
+        const none = raw();
+        delete none.lists;
+        expect(content.parse(none).site.lists).toEqual({});
+    });
+    it("refuses a value of the wrong kind, a field the list hasn't, an address used twice or a page's address, and a title that isn't words", () => {
+        const r = raw();
+        const items = r.lists.products.items;
+        items[0].price = "a lot";
+        items[0].colour = "red";
+        items[1].slug = "walnut-desk";
+        r.pages.push({ path: "/products/oak-table/", title: "Oak table", description: "A page of its own.", blocks: [{ type: "hero", heading: "Oak" }] });
+        items.push({ id: "rec-3", slug: "oak-table", name: "Oak table" });
+        r.lists.products.page.title = "price";
+        const problems = content.parse(r).problems.join("\n");
+        expect(problems).toMatch(/price: Not a number value/);
+        expect(problems).toMatch(/colour isn't one of Products's fields/);
+        expect(problems).toMatch(/Two items have the address walnut-desk/);
+        expect(problems).toMatch(/There's a page at \/products\/oak-table\/ already/);
+        expect(problems).toMatch(/The title is one of the list's fields of words/);
+    });
+    it("refuses an address that isn't lowercase words and dashes, and a field called id or slug", () => {
+        const r = raw();
+        r.lists.products.items[0].slug = "Walnut Desk";
+        r.lists.products.fields.push({ key: "slug", label: "Slug", kind: "text" });
+        const problems = content.parse(r).problems.join("\n");
+        expect(problems).toMatch(/Lowercase letters, numbers and dashes/);
+        expect(problems).toMatch(/id and slug are an item's own/);
+    });
+    it("gives each item a page at its list's address, titled, described and shared by its own values", () => {
+        const site = content.parse(raw()).site;
+        const items = allPages(site).filter((p) => itemOf(p));
+        expect(items.map((p) => [p.path, p.title, p.description])).toEqual([
+            ["/products/walnut-desk/", "Walnut desk", "Solid walnut."],
+            ["/products/oak-chair/", "Oak chair", "Sits well."],
+        ]);
+        expect(items[0].share).toEqual({ src: "desk.jpg", alt: "The desk" });
+    });
+    it("finds an item's page at its address, lists it for the build and the sitemap, and checks links to it", () => {
+        const site = content.parse(raw()).site;
+        setPrepared({ site, images: {}, csp: {} }, false);
+        expect(pageAt(["products", "oak-chair"])?.title).toBe("Oak chair");
+        expect(pageAt(["products"])?.title).toBe("Products");
+        expect(pageAt(["products", "nothing"])).toBeNull();
+        expect(staticParams()).toContainEqual({ path: ["products", "walnut-desk"] });
+        expect(sitemap().map((u) => u.url)).toContain("https://acme.example/products/oak-chair/");
+        expect(sitemapXml(site)).toContain("/products/walnut-desk/");
+        // A link to an item's page lands; one to an item there isn't doesn't.
+        const linked = raw();
+        linked.pages[0].blocks = [{ type: "built", root: { id: "linkroot01", tag: "a", text: "Desk", href: "/products/walnut-desk/" } }];
+        expect(content.parse(linked).problems).toBeUndefined();
+        linked.pages[0].blocks[0].root.href = "/products/pine-bed/";
+        expect(content.parse(linked).problems.join("\n")).toMatch(/No page at \/products\/pine-bed\//);
+    });
+    it("draws an item's page with this. for the item and item. for a repeat's", () => {
+        const site = content.parse(raw()).site;
+        setPrepared({ site, images: {}, csp: {} }, true);
+        const page = pageAt(["products", "walnut-desk"]);
+        const html = renderToStaticMarkup(_jsx(BuiltSection, { s: page.blocks[0] }));
+        expect(html).toContain(">Walnut desk</h1>");
+        expect(html).toContain(">1200</p>");
+        expect(html).toContain('alt="The desk"');
+        expect(html).toContain("<li");
+        expect(html).toContain(">Oak chair</li>");
+    });
+    it("builds CSS and behaviors for a list's page design, which only its items draw", () => {
+        const site = content.parse(raw()).site;
+        expect([...classesIn(site)]).toEqual(["kit:p-6", "kit:text-4xl"]);
+        expect([...behaviorsIn(site)]).toEqual([]);
+    });
+});
+describe("a section's items from a list", () => {
+    const site = {
+        trailingSlash: true,
+        lists: {
+            services: {
+                name: "Services",
+                fields: [
+                    { key: "name", label: "Name", kind: "text" },
+                    { key: "summary", label: "Summary", kind: "longText" },
+                    { key: "photo", label: "Photo", kind: "image" },
+                ],
+                items: [
+                    { id: "a", slug: "bookkeeping", name: "Bookkeeping", summary: "Monthly books.", photo: { src: "uploads/b.jpg", alt: "A ledger" } },
+                    { id: "b", slug: "payroll", name: "Payroll" },
+                ],
+                page: { path: "/services/", title: "name", blocks: [] },
+            },
+        },
+    };
+    const block = { type: "services", heading: "What we do", items: [{ title: "Typed", text: "Typed" }], from: { list: "services", into: "items", fields: { title: "name", text: "summary", image: "photo", href: "@page" } } };
+    it("fills the section's items from the list, each linked to its page", () => {
+        const out = withListItems(block, site);
+        expect(out.items).toEqual([
+            { title: "Bookkeeping", text: "Monthly books.", image: { src: "uploads/b.jpg", alt: "A ledger" }, href: "/services/bookkeeping/" },
+            // Words it hasn't are empty words; a picture it hasn't is left out.
+            { title: "Payroll", text: "", href: "/services/payroll/" },
+        ]);
+    });
+    it("keeps the typed items where the list isn't there, and when none is picked", () => {
+        expect(withListItems({ ...block, from: { ...block.from, list: "gone" } }, site)).toEqual({ ...block, from: { ...block.from, list: "gone" } });
+        const { from: _, ...typed } = block;
+        expect(withListItems(typed, site)).toBe(typed);
+    });
+    it("is what a page draws", () => {
+        const pages = allPages({ ...site, pages: [{ path: "/services/", title: "Services", description: "", blocks: [block] }] });
+        expect(pages[0].blocks[0].items).toHaveLength(2);
+    });
+    it("is a field a section adds, naming the array it fills", () => {
+        const schema = z.object({ items: z.array(z.object({ title: text })), from: fromList("items") });
+        expect(schema.parse({ items: [], from: { list: "services", fields: { title: "name" } } }).from).toEqual({ list: "services", into: "items", fields: { title: "name" } });
+        expect(() => schema.parse({ items: [], from: { list: "services", into: "people" } })).toThrow();
+    });
+});
+describe("a link bound to a list's value", () => {
+    it("goes to an email address as mailto: and a phone number as tel:, anything else as it is", async () => {
+        const { linkFor } = await import("../next/built.js");
+        expect(linkFor("team@caltho.com")).toBe("mailto:team@caltho.com");
+        expect(linkFor("(215) 555-0100")).toBe("tel:2155550100");
+        expect(linkFor("+1 215 555 0100")).toBe("tel:+12155550100");
+        expect(linkFor("/services/")).toBe("/services/");
+        expect(linkFor("https://caltho.com")).toBe("https://caltho.com");
+    });
+});
+describe("a filter over a list", () => {
+    it("marks each item with its value of the filter's field, and leaves its buttons as buttons", () => {
+        const site = { lists: { work: { name: "Work", fields: [{ key: "name", label: "Name", kind: "text" }, { key: "industry", label: "Industry", kind: "text" }], items: [{ id: "a", slug: "boat", name: "Boat", industry: "Hospitality" }, { id: "b", slug: "agency", name: "Agency", industry: "Real Estate" }] } } };
+        setPrepared({ site, images: {}, csp: {} }, false);
+        const block = {
+            type: "built",
+            root: {
+                id: "filtroot01", tag: "section", behavior: { name: "filter", field: "industry" }, children: [
+                    { id: "filtbtns01", tag: "div", children: [{ id: "filtall001", tag: "button", text: "All", class: "aria-pressed:bg-ink" }, { id: "filtre0001", tag: "button", text: "Real estate" }] },
+                    { id: "filtgrid01", tag: "ul", children: [{ id: "filtitem01", tag: "li", repeat: { path: "lists.work.items" }, bind: { path: "item.name" } }] },
+                ],
+            },
+        };
+        const html = renderToStaticMarkup(_jsx(BuiltSection, { s: block }));
+        expect(html).toContain('data-kit-behavior="filter"');
+        expect(html).toMatch(/<li[^>]*data-kit-filter-value="hospitality"[^>]*>Boat<\/li>/);
+        expect(html).toMatch(/<li[^>]*data-kit-filter-value="real-estate"[^>]*>Agency<\/li>/);
+        expect(html).toMatch(/<button[^>]*type="button"[^>]*>All<\/button>/);
+    });
+});
+describe("a form in a built section", () => {
+    const form = {
+        id: "formroot01", tag: "form", class: "grid gap-4", children: [
+            { id: "formlab001", tag: "label", for: "formname01", text: "Your name" },
+            { id: "formname01", tag: "input", field: { name: "name", required: true, placeholder: "Jane" } },
+            { id: "formmsg001", tag: "textarea", field: { name: "message", rows: 4 } },
+            { id: "formhow001", tag: "select", field: { name: "how", placeholder: "Pick one" }, children: [{ id: "formopt001", tag: "option", text: "Email" }] },
+            { id: "formsend01", tag: "button", text: "Send message" },
+        ],
+    };
+    it("posts to the site's own form address with each field by its name, a label naming its field, the spam trap, and a button that sends", () => {
+        setPrepared({ site: { form: "https://forms.caltho.com/f/abc" }, images: {}, csp: {} }, false);
+        const html = renderToStaticMarkup(_jsx(BuiltSection, { s: { type: "built", root: form } }));
+        const tag = (name) => html.match(new RegExp(`<${name}\\b[^>]*>`))?.[0] ?? "";
+        expect(tag("form")).toContain('method="post"');
+        expect(tag("form")).toContain('action="https://forms.caltho.com/f/abc"');
+        expect(html).toMatch(/<label[^>]*for="kit-f-formname01"[^>]*>Your name<\/label>/);
+        const name = html.match(/<input[^>]*id="kit-f-formname01"[^>]*>/)?.[0] ?? "";
+        for (const a of ['name="name"', 'type="text"', 'required=""', 'placeholder="Jane"'])
+            expect(name).toContain(a);
+        expect(html).toMatch(/<textarea[^>]*name="message"[^>]*rows="4"/);
+        expect(html).toMatch(/<select[^>]*name="how"[^>]*>.*<option value="Email">Email<\/option>/);
+        expect(html).toContain('name="_website"');
+        expect(html).toMatch(/<button[^>]*type="submit"[^>]*>Send message<\/button>/);
+    });
+    it("can't be sent where the site has no form address yet, and a field outside a form is refused", () => {
+        setPrepared({ site: {}, images: {}, csp: {} }, false);
+        const html = renderToStaticMarkup(_jsx(BuiltSection, { s: { type: "built", root: form } }));
+        expect(html).not.toContain("<form");
+        expect(html).toContain("data-kit-form-unset");
+        expect(treeProblems({ id: "rootrootxx", tag: "div", children: [{ id: "lonefield1", tag: "input", field: { name: "email" } }] }).join(" ")).toMatch(/belongs inside a form/);
+    });
+    it("sends to the business's form it names, by key; one the site wasn't given isn't sent anywhere", () => {
+        const quote = { ...form, sendTo: "quote" };
+        setPrepared({ site: { form: "https://forms.caltho.com/f/abc", forms: { quote: "https://acme.caltho.app/api/forms/quote/k1" } }, images: {}, csp: {} }, false);
+        expect(renderToStaticMarkup(_jsx(BuiltSection, { s: { type: "built", root: quote } }))).toContain('action="https://acme.caltho.app/api/forms/quote/k1"');
+        const html = renderToStaticMarkup(_jsx(BuiltSection, { s: { type: "built", root: { ...form, sendTo: "gone" } } }));
+        expect(html).not.toContain("<form");
+        expect(node.safeParse({ id: "abcdefgh12", tag: "div", sendTo: "quote" }).success).toBe(false);
+        expect(node.safeParse({ ...form, sendTo: "https://evil.example" }).success).toBe(false);
+        const picked = renderToStaticMarkup(_jsx(BuiltSection, { s: { type: "built", root: { ...form, children: [{ id: "byemail001", tag: "input", field: { name: "reach", type: "radio", value: "email", checked: true } }] } } }));
+        expect(picked).toMatch(/<input[^>]*checked=""[^>]*value="email"/);
+    });
+    it("shows a picture's phone version in its place on a small screen", () => {
+        const prepared = (src, w, h) => ({ src: `/_img/${src}`, width: w, height: h, srcset: [{ url: `/_img/${src}.800.webp`, w: 800 }] });
+        setPrepared({ site: {}, images: { "uploads/today.png": prepared("today.png", 2880, 1400), "uploads/today-phone.png": prepared("today-phone.png", 1170, 1992) }, csp: {} }, false);
+        const shot = { id: "shotshot01", tag: "img", class: "w-full", image: { src: "uploads/today.png", alt: "Today", phoneSrc: "uploads/today-phone.png" } };
+        const html = renderToStaticMarkup(_jsx(BuiltSection, { s: { type: "built", root: { id: "rootroot01", tag: "div", children: [shot] } } }));
+        expect(html).toMatch(/<picture><source media="\(max-width: 700px\)"[^>]*today-phone[^>]*\/><img[^>]*today\.png[^>]*alt="Today"/);
+        expect(node.safeParse({ ...shot, image: { ...shot.image, phoneSrc: "https://evil.example/x.png" } }).success).toBe(false);
+    });
+});

package/dist/content/look.d.ts

@@ -133,13 +133,13 @@ export declare function lookSchema(o: LookOptions): z.ZodOptional<z.ZodObject<{
             floating: "floating";
         }>>;
         layout: z.ZodDefault<z.ZodEnum<{
+            left: "left";
             spread: "spread";
             centered: "centered";
-            left: "left";
         }>>;
         menuShows: z.ZodDefault<z.ZodEnum<{
-            both: "both";
             icon: "icon";
+            both: "both";
             word: "word";
         }>>;
         menuStyle: z.ZodOptional<z.ZodString>;
@@ -156,39 +156,39 @@ export declare function lookSchema(o: LookOptions): z.ZodOptional<z.ZodObject<{
         color: z.ZodString;
     }, z.core.$strip>>>;
     type: z.ZodDefault<z.ZodObject<{
-        display: z.ZodOptional<z.ZodObject<{
+        h1: z.ZodOptional<z.ZodObject<{
             size: z.ZodOptional<z.ZodNumber>;
-            weight: z.ZodOptional<z.ZodLiteral<400 | 500 | 600 | 700 | 300>>;
+            weight: z.ZodOptional<z.ZodLiteral<400 | 600 | 500 | 300 | 700>>;
             tracking: z.ZodOptional<z.ZodNumber>;
             leading: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
-        h1: z.ZodOptional<z.ZodObject<{
+        h2: z.ZodOptional<z.ZodObject<{
             size: z.ZodOptional<z.ZodNumber>;
-            weight: z.ZodOptional<z.ZodLiteral<400 | 500 | 600 | 700 | 300>>;
+            weight: z.ZodOptional<z.ZodLiteral<400 | 600 | 500 | 300 | 700>>;
             tracking: z.ZodOptional<z.ZodNumber>;
             leading: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
-        h2: z.ZodOptional<z.ZodObject<{
+        h3: z.ZodOptional<z.ZodObject<{
             size: z.ZodOptional<z.ZodNumber>;
-            weight: z.ZodOptional<z.ZodLiteral<400 | 500 | 600 | 700 | 300>>;
+            weight: z.ZodOptional<z.ZodLiteral<400 | 600 | 500 | 300 | 700>>;
             tracking: z.ZodOptional<z.ZodNumber>;
             leading: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
-        h3: z.ZodOptional<z.ZodObject<{
+        small: z.ZodOptional<z.ZodObject<{
             size: z.ZodOptional<z.ZodNumber>;
-            weight: z.ZodOptional<z.ZodLiteral<400 | 500 | 600 | 700 | 300>>;
+            weight: z.ZodOptional<z.ZodLiteral<400 | 600 | 500 | 300 | 700>>;
             tracking: z.ZodOptional<z.ZodNumber>;
             leading: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
         body: z.ZodOptional<z.ZodObject<{
             size: z.ZodOptional<z.ZodNumber>;
-            weight: z.ZodOptional<z.ZodLiteral<400 | 500 | 600 | 700 | 300>>;
+            weight: z.ZodOptional<z.ZodLiteral<400 | 600 | 500 | 300 | 700>>;
             tracking: z.ZodOptional<z.ZodNumber>;
             leading: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
-        small: z.ZodOptional<z.ZodObject<{
+        display: z.ZodOptional<z.ZodObject<{
             size: z.ZodOptional<z.ZodNumber>;
-            weight: z.ZodOptional<z.ZodLiteral<400 | 500 | 600 | 700 | 300>>;
+            weight: z.ZodOptional<z.ZodLiteral<400 | 600 | 500 | 300 | 700>>;
             tracking: z.ZodOptional<z.ZodNumber>;
             leading: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;

package/dist/content-migrate.d.ts

@@ -0,0 +1,51 @@
+/** The format this kit's content is in. 0: before built sections; 1: built sections and components. */
+export declare const CONTENT_FORMAT = 1;
+export type Content = Record<string, unknown>;
+export type ContentMigration = {
+    /** Stable, unique, in order: "0001-built-sections". */
+    id: string;
+    from: number;
+    to: number;
+    /** What it changes, for whoever looks at a site's history. */
+    title: string;
+    /** The content in format `from`, moved to `to` (a copy: the content given is never changed). Throws a MigrationError for what it can't move. */
+    run(content: Content): Content;
+};
+/** What a migration can't move, and where: a fault for Caltho to fix in the migration, never a site's to fix by hand. */
+export declare class MigrationError extends Error {
+    readonly path: (string | number)[];
+    constructor(message: string, path?: (string | number)[]);
+}
+/** Every migration, in order: each one's `from` is the one before's `to`. */
+export declare const CONTENT_MIGRATIONS: readonly ContentMigration[];
+/** The format content is in: its `format`, or 0 for content from before formats were said. */
+export declare function formatOf(content: unknown): number;
+export type MigrateResult = {
+    ok: true;
+    content: Content;
+    from: number;
+    format: number;
+    applied: {
+        id: string;
+        title: string;
+    }[];
+} | {
+    ok: false;
+    content: Content;
+    from: number;
+    format: number;
+    error: {
+        id: string;
+        message: string;
+        path: (string | number)[];
+    };
+};
+/**
+ * Content moved to this kit's format (or `to`): each migration it hasn't had, in order, then its
+ * `format` set. Idempotent: content already there comes back as it was, with nothing applied. A
+ * migration that fails stops it: the content is returned as given, with the failure (`ok: false`).
+ * Content in a format newer than this kit knows is refused the same way (the site needs the newer kit).
+ */
+export declare function migrateContent(content: Content, o?: {
+    to?: number;
+}): MigrateResult;

package/dist/content-migrate.js

@@ -0,0 +1,69 @@
+// A site's content moved from one format to the next. Every client site is the starter plus its
+// configuration (its content: pages, Look, built sections, components), with no code of its own,
+// so the configuration's format is the kit's, and it changes only with the kit. The content says
+// which format it's in (`format`; none is 0, the format before built sections). When a newer kit
+// changes a shape, a migration here moves content from the format before to its own, as data:
+// pure, in order, each once (content already at or past its format is left alone), never needing a
+// person to edit a site by hand. One that can't move something says so (a MigrationError) for
+// Caltho to fix in the migration; the content is then left exactly as it was.
+//
+// Most changes need none: a new kind of block (built, use) or a new optional field leaves existing
+// content valid, and only the format number moves. CalOS runs these on a site's draft and published
+// content when the site moves to a newer kit (migrateContent); the build runs them too (prepare),
+// so content CalOS hasn't moved yet still builds. Code migrations (a site's files) are ./migrate.ts.
+/** The format this kit's content is in. 0: before built sections; 1: built sections and components. */
+export const CONTENT_FORMAT = 1;
+/** What a migration can't move, and where: a fault for Caltho to fix in the migration, never a site's to fix by hand. */
+export class MigrationError extends Error {
+    path;
+    constructor(message, path = []) {
+        super(message);
+        this.path = path;
+        this.name = "MigrationError";
+    }
+}
+/** Every migration, in order: each one's `from` is the one before's `to`. */
+export const CONTENT_MIGRATIONS = [
+    {
+        id: "0001-built-sections",
+        from: 0,
+        to: 1,
+        title: "Built sections, components and the cookie banner: new kinds of block (built, use), the site's components and its consent setting, none of which changes existing content",
+        run: (c) => c,
+    },
+];
+/** The format content is in: its `format`, or 0 for content from before formats were said. */
+export function formatOf(content) {
+    const f = content?.format;
+    return typeof f === "number" && Number.isInteger(f) && f >= 0 ? f : 0;
+}
+/**
+ * Content moved to this kit's format (or `to`): each migration it hasn't had, in order, then its
+ * `format` set. Idempotent: content already there comes back as it was, with nothing applied. A
+ * migration that fails stops it: the content is returned as given, with the failure (`ok: false`).
+ * Content in a format newer than this kit knows is refused the same way (the site needs the newer kit).
+ */
+export function migrateContent(content, o = {}) {
+    const to = o.to ?? CONTENT_FORMAT;
+    const from = formatOf(content);
+    if (from > CONTENT_FORMAT)
+        return { ok: false, content, from, format: from, error: { id: "format", message: `The content is in format ${from}, newer than this kit's (${CONTENT_FORMAT}): the site needs a newer @caltho/site-kit`, path: ["format"] } };
+    let at = structuredClone(content);
+    const applied = [];
+    for (const m of CONTENT_MIGRATIONS) {
+        if (m.from < from || m.to > to)
+            continue;
+        try {
+            at = m.run(structuredClone(at));
+        }
+        catch (err) {
+            const e = err;
+            return { ok: false, content, from, format: from, error: { id: m.id, message: e.message, path: e instanceof MigrationError ? e.path : [] } };
+        }
+        at.format = m.to;
+        applied.push({ id: m.id, title: m.title });
+    }
+    if (from < to && formatOf(at) !== to)
+        at.format = to;
+    return { ok: true, content: at, from, format: formatOf(at), applied };
+}

package/dist/finish.d.ts

@@ -6,5 +6,5 @@ export declare function finish(root: string, outDir: string, env?: Record<string
  * out, and what's marked to count), and each phone link and map link marked: a call or directions
  * tapped is what a business wants to know came from the site. No cookies: nothing to consent to.
  */
-export declare function counted(html: string, a: Analytics): string;
+export declare function counted(html: string, a: Analytics, asks?: boolean): string;
 export {};