@caltho/site-kit 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Caltho
+
+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

@@ -1,3 +1,82 @@
-# Temporary Holding Version
+# site-kit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+What every Caltho site is built with, published to npm as `@caltho/site-kit`. Each client's site is its
+own repository with its own design, started from [site-starter](https://github.com/trycaltho/site-starter).
+The kit is not a design system. It's the contract that lets CalOS manage any of those sites, and the
+plumbing every one of them needs.
+
+## The idea
+
+A site's content (its pages and what's on them) lives in **CalOS**, and the owner edits it there.
+Publishing in CalOS rebuilds the site with that content: no one pushes code to change a page. The
+design, meaning how a block looks and what kinds of block there are, is the site's own code.
+
+For CalOS to edit a site it hasn't seen, the site **declares what's editable**. That's all this takes:
+
+```ts
+// content/schema.ts
+import { defineSite, image, link, text, z } from "@caltho/site-kit/content";
+
+export default defineSite({
+  hero: z.object({ heading: text, text: text.optional(), image: image.optional(), actions: z.array(link).default([]) }),
+  faq: z.object({ heading: text, items: z.array(z.object({ q: text, a: text })).min(1) }),
+  // …whatever this site's design has
+});
+```
+
+- A page is `path`, `title`, `description`, an optional `menu` label, and a list of **blocks**. A block is
+  one of the kinds the site declared, with the fields it declared.
+- `site-kit prepare` checks the content against that, in every build, and says every problem with where it
+  is (`pages[0] (/) › blocks[1] (faq) › items[0] › q`). A build never publishes a page with a hole in it.
+- It also writes `.site/schema.json`, the declaration as JSON Schema. **CalOS draws its editing forms
+  from that**: text boxes, picture pickers (with required descriptions), lists to add to, reorder and
+  remove. Add a kind of block to a site and it appears in CalOS with no work on CalOS's side.
+- A new page is a new entry in the list with a path; the site's catch-all route renders it.
+
+Forms are separate and optional. A block can post to any address (a CalOS form, another service, or none);
+the kit only checks it's a URL.
+
+## What's in it
+
+| part | what it does |
+| --- | --- |
+| **Content** (`@caltho/site-kit/content`) | `defineSite` and the pieces to build blocks from (`text`, `md`, `image`, `link`, `href`, `business`, …); the checks, including that every link lands on a page and every `#part` exists; the JSON Schema. |
+| **prepare** | Loads the content from CalOS (`CALOS_CONTENT_URL`, `CALOS_SITE_TOKEN`) or `content/site.json`, checks it, writes the schema, and makes every picture the content names as WebP at the widths screens need plus a 1200×630 share crop, named by content so they cache for a year. |
+| **finish** | After the framework's build: a content security policy in every page (each inline script named by hash), `_headers` (security headers, long caching, `noindex` on preview addresses), and `_redirects` from CalOS (`CALOS_REDIRECTS_URL`; a build that can't reach CalOS fails rather than lose them). |
+| **check** | Every page in a real browser through axe (WCAG 2.0–2.2 A and AA, best practice) on a computer and a phone; fails on any violation, on anything the policy blocks, and on anything that doesn't load. |
+| **Search** | Titles that fit, canonical addresses, the business as schema.org data (hours, areas, address), FAQ and breadcrumb data, robots.txt, the sitemap. |
+| **Policies** | Privacy, accessibility and terms, written from the business's facts and what the site does. Optional: a site calls `policy()` where it wants them. |
+| **Helpers for components** (`@caltho/site-kit/lib`) | The pieces that touch no files: `md` (Markdown that can't run HTML), `plain`, `policy`, the search data, `imagesIn`, `clock`, `dayRange`, `telHref`. |
+| **Next.js helpers** (`@caltho/site-kit/next`) | The prepared content, a page by its path, page metadata, `Img` (the prepared widths), `Md` (Markdown that can't run HTML), `JsonLd`. Server components only. |
+
+## A build
+
+```sh
+site-kit prepare     # before: content checked, schema written, pictures ready
+next build           # the framework, reading .site/prepared.json
+site-kit finish out  # after: security policy, _headers, _redirects
+site-kit check out   # then: the browser check
+```
+
+This is the whole contract between a site and CalOS: content in at build, the declaration out, redirects
+in at build, files out. A site in another framework uses the same `prepare` and `finish` and reads
+`.site/prepared.json` its own way.
+
+`prepare` reads `content/schema.ts` directly, so it needs **Node 22.18 or later**.
+
+## Working on it
+
+```sh
+bun install
+bun run typecheck && bun test src && bun run build
+```
+
+To try a change in a site before releasing it: `bun pm pack`, then in the site
+`bun add file:/path/to/caltho-site-kit-<version>.tgz`.
+
+**Releasing**: raise `version` in package.json and merge to main. The Publish workflow sees a version
+that isn't on npm yet, checks and builds it, and **stages** it with npm's trusted publishing (no token is
+stored anywhere). A person then approves it, which is the 2FA step: `npm stage list`, then
+`npm stage approve <id>` (or approve on npmjs.com). Only then is it live, and a site's Dependabot picks it up.
+Set on the package once: Settings › Trusted publisher › GitHub Actions: organization `trycaltho`,
+repository `site-kit`, workflow `publish.yml`, permission "stage publish".

package/dist/cli/check.d.ts

@@ -0,0 +1,5 @@
+export declare function check(dir: string, log?: {
+    (...data: any[]): void;
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+}): Promise<boolean>;

package/dist/cli/check.js

@@ -0,0 +1,74 @@
+// Checks a built site in a real browser before it's published: every page in its sitemap and the
+// 404 page, on a computer screen and a phone, with axe (WCAG 2.2 AA and best practice), and with
+// nothing blocked by the site's own content security policy or failing to load. Says what's wrong
+// and where; true when nothing is.
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { serve } from "./serve.js";
+export async function check(dir, log = console.log) {
+    const require = createRequire(join(process.cwd(), "package.json"));
+    const pw = (await import(__rewriteRelativeImportExtension(require.resolve("playwright"))));
+    const chromium = pw.chromium ?? pw.default.chromium;
+    const axeSource = readFileSync(require.resolve("axe-core/axe.min.js"), "utf8");
+    const port = 4800 + Math.floor(Math.random() * 100);
+    const base = `http://localhost:${port}`;
+    const sitemap = readFileSync(join(dir, "sitemap.xml"), "utf8");
+    const paths = [...sitemap.matchAll(/<loc>([^<]+)<\/loc>/g)].map((m) => new URL(m[1]).pathname);
+    paths.push("/404.html");
+    const server = await serve(dir, port);
+    const problems = [];
+    const browser = await chromium.launch(process.env.CHROMIUM_PATH ? { executablePath: process.env.CHROMIUM_PATH } : {}).catch((err) => {
+        server.close();
+        throw err;
+    });
+    try {
+        for (const [screen, viewport] of [
+            ["computer", { width: 1280, height: 800 }],
+            ["phone", { width: 390, height: 844 }],
+        ]) {
+            const context = await browser.newContext({ viewport });
+            const page = await context.newPage();
+            let where = "";
+            page.on("console", (m) => m.type() === "error" && problems.push(`${where} (${screen}): console: ${m.text()}`));
+            page.on("pageerror", (e) => problems.push(`${where} (${screen}): script error: ${e.message}`));
+            page.on("requestfailed", (r) => problems.push(`${where} (${screen}): didn't load ${r.url()}`));
+            page.on("response", (r) => {
+                if (r.status() >= 400 && !r.url().endsWith("/404.html"))
+                    problems.push(`${where} (${screen}): ${r.status()} for ${r.url()}`);
+            });
+            for (const path of paths) {
+                where = path;
+                await page.goto(base + path, { waitUntil: "networkidle" });
+                // Through the browser's devtools channel: the page's own policy (rightly) blocks an injected <script>.
+                await page.evaluate(axeSource);
+                const result = (await page.evaluate(() => 
+                // @ts-expect-error axe is defined on the page by the line above
+                window.axe.run(document, { runOnly: { type: "tag", values: ["wcag2a", "wcag2aa", "wcag21a", "wcag21aa", "wcag22aa", "best-practice"] } })));
+                for (const v of result.violations) {
+                    const targets = v.nodes.slice(0, 3).map((n) => n.target.join(" "));
+                    problems.push(`${path} (${screen}): ${v.id}: ${v.help} [${v.impact}] at ${targets.join(", ")}${v.nodes.length > 3 ? ` and ${v.nodes.length - 3} more` : ""}`);
+                }
+            }
+            await context.close();
+        }
+    }
+    finally {
+        await browser.close();
+        server.close();
+    }
+    if (problems.length) {
+        log(`✗ ${dir}: ${problems.length} problem${problems.length === 1 ? "" : "s"}\n  - ${[...new Set(problems)].join("\n  - ")}`);
+        return false;
+    }
+    log(`✓ ${dir}: ${paths.length} pages, on a computer and a phone: no accessibility problems axe can find, nothing blocked or broken`);
+    return true;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+// site-kit prepare            content checked, schema written, images ready for the build (.site/, public/)
+// site-kit finish [out]       after the build: the content security policy, _headers, _redirects
+// site-kit serve [out] [port] the build served as Cloudflare Pages will
+// site-kit check [out]        every page in a real browser: axe, blocked or broken loads
+import { resolve } from "node:path";
+import { finish } from "../finish.js";
+import { prepare } from "../prepare.js";
+const [command = "", ...args] = process.argv.slice(2);
+const root = process.cwd();
+try {
+    if (command === "prepare")
+        await prepare(root);
+    else if (command === "finish")
+        await finish(root, resolve(args[0] ?? "out"));
+    else if (command === "serve") {
+        const { serve } = await import("./serve.js");
+        const port = Number(args[1] ?? 4321);
+        await serve(args[0] ?? "out", port);
+        console.log(`Serving ${resolve(args[0] ?? "out")} at http://localhost:${port}`);
+    }
+    else if (command === "check") {
+        const { check } = await import("./check.js");
+        process.exitCode = (await check(resolve(args[0] ?? "out"))) ? 0 : 1;
+    }
+    else {
+        console.error("Usage: site-kit prepare | finish [out] | serve [out] [port] | check [out]");
+        process.exitCode = 1;
+    }
+}
+catch (err) {
+    console.error(`✗ ${err.message}`);
+    process.exitCode = 1;
+}

package/dist/cli/serve.d.ts

@@ -0,0 +1,3 @@
+import { type Server } from "node:http";
+/** Serves `dir` on `port`; resolves once it's listening. */
+export declare function serve(dir: string, port: number): Promise<Server>;

package/dist/cli/serve.js

@@ -0,0 +1,86 @@
+// Serves a built site the way Cloudflare Pages will: its `_headers` and `_redirects` applied,
+// `/about` sent on to `/about/`, and 404.html for anything else. For looking at a build and
+// running the checks against it before it's published.
+import { createReadStream, existsSync, readFileSync, statSync } from "node:fs";
+import { createServer } from "node:http";
+import { extname, join, resolve } from "node:path";
+const TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".json": "application/json",
+    ".xml": "application/xml",
+    ".txt": "text/plain; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".avif": "image/avif",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".woff2": "font/woff2",
+};
+/** `_headers`: blocks of a path pattern and indented "Name: value" lines. Only path patterns apply here. */
+function readHeaders(root) {
+    const file = join(root, "_headers");
+    if (!existsSync(file))
+        return [];
+    const rules = [];
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+        if (!line.trim() || line.trim().startsWith("#"))
+            continue;
+        if (!/^\s/.test(line))
+            rules.push({ pattern: line.trim(), headers: [] });
+        else {
+            const i = line.indexOf(":");
+            rules.at(-1)?.headers.push([line.slice(0, i).trim(), line.slice(i + 1).trim()]);
+        }
+    }
+    return rules.filter((r) => r.pattern.startsWith("/"));
+}
+function readRedirects(root) {
+    const file = join(root, "_redirects");
+    if (!existsSync(file))
+        return new Map();
+    return new Map(readFileSync(file, "utf8")
+        .split("\n")
+        .map((l) => l.trim().split(/\s+/))
+        .filter((p) => p.length >= 2 && p[0].startsWith("/"))
+        .map(([from, to, status]) => [from, { to: to, status: Number(status ?? 301) }]));
+}
+const matches = (pattern, path) => (pattern.endsWith("/*") ? path.startsWith(pattern.slice(0, -1)) : pattern === path);
+/** Serves `dir` on `port`; resolves once it's listening. */
+export function serve(dir, port) {
+    const root = resolve(dir);
+    const server = createServer((req, res) => {
+        const path = decodeURIComponent(new URL(req.url ?? "/", "http://x").pathname);
+        for (const rule of readHeaders(root))
+            if (matches(rule.pattern, path))
+                for (const [k, v] of rule.headers)
+                    res.setHeader(k, v);
+        const redirect = readRedirects(root).get(path);
+        if (redirect) {
+            res.writeHead(redirect.status, { Location: redirect.to });
+            return res.end();
+        }
+        let file = join(root, path);
+        if (!file.startsWith(root)) {
+            res.writeHead(400);
+            return res.end();
+        }
+        if (existsSync(file) && statSync(file).isDirectory()) {
+            if (!path.endsWith("/")) {
+                res.writeHead(308, { Location: `${path}/` });
+                return res.end();
+            }
+            file = join(file, "index.html");
+        }
+        let status = 200;
+        if (!existsSync(file) || path.startsWith("/_headers") || path.startsWith("/_redirects")) {
+            file = join(root, "404.html");
+            status = 404;
+        }
+        res.writeHead(status, { "Content-Type": TYPES[extname(file)] ?? "application/octet-stream" });
+        createReadStream(file).pipe(res);
+    });
+    return new Promise((ok) => server.listen(port, () => ok(server)));
+}

package/dist/content/index.d.ts

@@ -0,0 +1,289 @@
+import { z } from "zod";
+export { z };
+export declare const text: z.ZodString;
+/** Markdown: paragraphs, **bold**, *italic*, [links](/contact), lists, ### small headings. No HTML. */
+export declare const md: z.ZodString;
+/** A file in the site's `content/images/` folder. */
+export declare const file: z.ZodString;
+/** Describe what's in the picture for someone who can't see it; "" only when it's decoration. */
+export declare const image: z.ZodObject<{
+    src: z.ZodString;
+    alt: z.ZodString;
+}, z.core.$strip>;
+export declare const href: z.ZodString;
+export declare const link: z.ZodObject<{
+    label: z.ZodString;
+    href: z.ZodString;
+    style: z.ZodOptional<z.ZodEnum<{
+        primary: "primary";
+        secondary: "secondary";
+    }>>;
+}, z.core.$strip>;
+export declare const time: z.ZodString;
+export declare const DAYS: readonly ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"];
+/** The business's facts: the header, footer, hours, contact details and search data all come from here. */
+export declare const business: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodDefault<z.ZodString>;
+    tagline: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodEmail>;
+    address: z.ZodOptional<z.ZodObject<{
+        street: z.ZodString;
+        locality: z.ZodString;
+        region: z.ZodString;
+        postcode: z.ZodString;
+        country: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    showAddress: z.ZodDefault<z.ZodBoolean>;
+    areas: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    hours: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        days: z.ZodArray<z.ZodEnum<{
+            Mo: "Mo";
+            Tu: "Tu";
+            We: "We";
+            Th: "Th";
+            Fr: "Fr";
+            Sa: "Sa";
+            Su: "Su";
+        }>>;
+        opens: z.ZodString;
+        closes: z.ZodString;
+    }, z.core.$strip>>>;
+    hoursNote: z.ZodOptional<z.ZodString>;
+    logo: z.ZodOptional<z.ZodObject<{
+        src: z.ZodString;
+        alt: z.ZodString;
+    }, z.core.$strip>>;
+    founded: z.ZodOptional<z.ZodNumber>;
+    licence: z.ZodOptional<z.ZodString>;
+    priceRange: z.ZodOptional<z.ZodString>;
+    social: z.ZodDefault<z.ZodObject<{
+        facebook: z.ZodOptional<z.ZodURL>;
+        instagram: z.ZodOptional<z.ZodURL>;
+        google: z.ZodOptional<z.ZodURL>;
+        yelp: z.ZodOptional<z.ZodURL>;
+        nextdoor: z.ZodOptional<z.ZodURL>;
+        linkedin: z.ZodOptional<z.ZodURL>;
+        youtube: z.ZodOptional<z.ZodURL>;
+        tiktok: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** A block as the kit sees it: its kind, its place on the page, and whatever fields the site gave it. */
+export type Block = {
+    type: string;
+    id?: string;
+    [field: string]: unknown;
+};
+export type Page = {
+    path: string;
+    title: string;
+    description: string;
+    menu?: string;
+    share?: {
+        src: string;
+        alt: string;
+    };
+    noindex: boolean;
+    blocks: Block[];
+};
+export type Business = z.output<typeof business>;
+export type Image = z.output<typeof image>;
+export type Link = z.output<typeof link>;
+export type Redirect = {
+    from: string;
+    to: string;
+    status: 301 | 302;
+};
+/** What every site has, whatever its blocks. */
+export type SiteBase = {
+    url: string;
+    lang: string;
+    business: Business;
+    form?: string;
+    redirects: Redirect[];
+};
+/** The content as the kit sees it: what search, security, images and the checks need. A site's own type has its blocks and extra fields. */
+export type Site = SiteBase & {
+    pages: Page[];
+    [extra: string]: unknown;
+};
+/** The blocks a site declared, as a union by `type`: `BlocksOf<typeof blocks>`. */
+export type BlocksOf<B extends Record<string, z.ZodObject>> = {
+    [K in keyof B & string]: z.output<B[K]> & {
+        type: K;
+        id?: string;
+    };
+}[keyof B & string];
+/** A site's content with its own blocks typed: `ContentOf<typeof blocks> & { headerAction?: Link }`. */
+export type ContentOf<B extends Record<string, z.ZodObject>> = SiteBase & {
+    pages: (Omit<Page, "blocks"> & {
+        blocks: BlocksOf<B>[];
+    })[];
+};
+export type DefineOptions = {
+    /** Fields of the site beyond the kit's own (a theme, a header button, a form address). */
+    extend?: z.ZodRawShape;
+    /** Checks only the site can make (a contact block needs somewhere to send), added to the kit's own. */
+    refine?: (site: Site, ctx: z.RefinementCtx) => void;
+};
+/**
+ * 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 declare function defineSite<const B extends Record<string, z.ZodObject>>(blocks: B, o?: DefineOptions): {
+    schema: z.ZodObject<{
+        pages: z.ZodArray<z.ZodObject<{
+            blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<z.core.$ZodLooseShape, z.core.$strip>, ...z.ZodObject<z.core.$ZodLooseShape, z.core.$strip>[]], "type">>;
+            path: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            menu: z.ZodOptional<z.ZodString>;
+            share: z.ZodOptional<z.ZodObject<{
+                src: z.ZodString;
+                alt: z.ZodString;
+            }, z.core.$strip>>;
+            noindex: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        url: z.ZodURL;
+        lang: z.ZodDefault<z.ZodString>;
+        business: z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodDefault<z.ZodString>;
+            tagline: z.ZodOptional<z.ZodString>;
+            phone: z.ZodOptional<z.ZodString>;
+            email: z.ZodOptional<z.ZodEmail>;
+            address: z.ZodOptional<z.ZodObject<{
+                street: z.ZodString;
+                locality: z.ZodString;
+                region: z.ZodString;
+                postcode: z.ZodString;
+                country: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>;
+            showAddress: z.ZodDefault<z.ZodBoolean>;
+            areas: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            hours: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                days: z.ZodArray<z.ZodEnum<{
+                    Mo: "Mo";
+                    Tu: "Tu";
+                    We: "We";
+                    Th: "Th";
+                    Fr: "Fr";
+                    Sa: "Sa";
+                    Su: "Su";
+                }>>;
+                opens: z.ZodString;
+                closes: z.ZodString;
+            }, z.core.$strip>>>;
+            hoursNote: z.ZodOptional<z.ZodString>;
+            logo: z.ZodOptional<z.ZodObject<{
+                src: z.ZodString;
+                alt: z.ZodString;
+            }, z.core.$strip>>;
+            founded: z.ZodOptional<z.ZodNumber>;
+            licence: z.ZodOptional<z.ZodString>;
+            priceRange: z.ZodOptional<z.ZodString>;
+            social: z.ZodDefault<z.ZodObject<{
+                facebook: z.ZodOptional<z.ZodURL>;
+                instagram: z.ZodOptional<z.ZodURL>;
+                google: z.ZodOptional<z.ZodURL>;
+                yelp: z.ZodOptional<z.ZodURL>;
+                nextdoor: z.ZodOptional<z.ZodURL>;
+                linkedin: z.ZodOptional<z.ZodURL>;
+                youtube: z.ZodOptional<z.ZodURL>;
+                tiktok: z.ZodOptional<z.ZodURL>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        form: z.ZodOptional<z.ZodURL>;
+        redirects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            status: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<301>, z.ZodLiteral<302>]>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    /** The content checked, or every problem in it as "where: what" lines. */
+    parse(raw: unknown): {
+        site: z.output<z.ZodObject<{
+            pages: z.ZodArray<z.ZodObject<{
+                blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<z.core.$ZodLooseShape, z.core.$strip>, ...z.ZodObject<z.core.$ZodLooseShape, z.core.$strip>[]], "type">>;
+                path: z.ZodString;
+                title: z.ZodString;
+                description: z.ZodString;
+                menu: z.ZodOptional<z.ZodString>;
+                share: z.ZodOptional<z.ZodObject<{
+                    src: z.ZodString;
+                    alt: z.ZodString;
+                }, z.core.$strip>>;
+                noindex: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            url: z.ZodURL;
+            lang: z.ZodDefault<z.ZodString>;
+            business: z.ZodObject<{
+                name: z.ZodString;
+                kind: z.ZodDefault<z.ZodString>;
+                tagline: z.ZodOptional<z.ZodString>;
+                phone: z.ZodOptional<z.ZodString>;
+                email: z.ZodOptional<z.ZodEmail>;
+                address: z.ZodOptional<z.ZodObject<{
+                    street: z.ZodString;
+                    locality: z.ZodString;
+                    region: z.ZodString;
+                    postcode: z.ZodString;
+                    country: z.ZodDefault<z.ZodString>;
+                }, z.core.$strip>>;
+                showAddress: z.ZodDefault<z.ZodBoolean>;
+                areas: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                hours: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    days: z.ZodArray<z.ZodEnum<{
+                        Mo: "Mo";
+                        Tu: "Tu";
+                        We: "We";
+                        Th: "Th";
+                        Fr: "Fr";
+                        Sa: "Sa";
+                        Su: "Su";
+                    }>>;
+                    opens: z.ZodString;
+                    closes: z.ZodString;
+                }, z.core.$strip>>>;
+                hoursNote: z.ZodOptional<z.ZodString>;
+                logo: z.ZodOptional<z.ZodObject<{
+                    src: z.ZodString;
+                    alt: z.ZodString;
+                }, z.core.$strip>>;
+                founded: z.ZodOptional<z.ZodNumber>;
+                licence: z.ZodOptional<z.ZodString>;
+                priceRange: z.ZodOptional<z.ZodString>;
+                social: z.ZodDefault<z.ZodObject<{
+                    facebook: z.ZodOptional<z.ZodURL>;
+                    instagram: z.ZodOptional<z.ZodURL>;
+                    google: z.ZodOptional<z.ZodURL>;
+                    yelp: z.ZodOptional<z.ZodURL>;
+                    nextdoor: z.ZodOptional<z.ZodURL>;
+                    linkedin: z.ZodOptional<z.ZodURL>;
+                    youtube: z.ZodOptional<z.ZodURL>;
+                    tiktok: z.ZodOptional<z.ZodURL>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            form: z.ZodOptional<z.ZodURL>;
+            redirects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                status: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<301>, z.ZodLiteral<302>]>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        problems?: never;
+    } | {
+        site?: never;
+        problems: string[];
+    };
+    /** The declaration CalOS draws its editing forms from. */
+    jsonSchema: () => Record<string, unknown>;
+};
+export type SiteDefinition = ReturnType<typeof defineSite>;
+/** "Mon–Fri", "Sat", "Mon, Wed, Fri" for a set of days. */
+export declare function dayRange(days: readonly (typeof DAYS)[number][]): string;
+/** "8am", "5:30pm". */
+export declare function clock(t: string): string;
+/** "tel:+15550102030" from however the number is written. */
+export declare function telHref(phone: string, country?: string): string;