@caltho/site-kit 0.0.0-stage → 0.1.0

package/dist/policies.js

@@ -0,0 +1,84 @@
+// The policy pages a business's site should have, written from what the business has told us and
+// what the template actually does: no cookies, no analytics, no third-party requests, a contact
+// form that goes to the business's CalOS. So the words stay true as the site changes: add a
+// tracker to the template and this is where it has to be said. Plain language, US-first; a
+// business adds its own paragraphs with `extra`, and should have a lawyer read them once.
+/**
+ * `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 function policy(site, which, o = {}) {
+    const b = site.business;
+    const host = new URL(site.url).host.replace(/^www\./, "");
+    const reach = [b.email ? `email [${b.email}](mailto:${b.email})` : null, b.phone ? `call ${b.phone}` : null].filter(Boolean).join(" or ");
+    const place = b.address ? `${b.address.locality}, ${b.address.region}` : null;
+    const hasForm = o.collectsFromForm ?? !!site.form;
+    if (which === "privacy") {
+        return {
+            title: "Privacy policy",
+            body: [
+                `## Who we are`,
+                `${b.name}${place ? ` of ${place}` : ""} runs this website, ${host}. If you have a question about your information, ${reach || "contact us"}.`,
+                `## What we collect`,
+                [
+                    hasForm ? `- **When you send us a message** through the form on this site: your name, your email address, your phone number if you give it, and what you write.` : null,
+                    `- **When you call or email us**: what you choose to tell us.`,
+                    `- **When you visit**: our hosting provider, Cloudflare, briefly records technical details such as your IP address, browser and the pages asked for, to keep the site secure and working.`,
+                ]
+                    .filter(Boolean)
+                    .join("\n"),
+                `This site doesn't use cookies, advertising or analytics trackers. Its fonts and pictures come from this site itself, so visiting it doesn't tell anyone else you were here.`,
+                `## How we use it`,
+                `To answer you, to quote for and do the work you ask about, and to keep the records the law requires. We keep enquiries in our customer records system, which Caltho runs for us. We don't sell or rent your information, and we don't share it for advertising. The companies that help us run this site and our business (hosting, email, records) only use it to do that for us.`,
+                `## How long we keep it`,
+                `As long as we need it to answer you and serve you, and afterwards only as long as the law or our accounts require. Ask us and we'll delete what we don't have to keep.`,
+                `## Your choices`,
+                `You can ask what information we hold about you, ask us to correct it, or ask us to delete it: ${reach || "contact us"}. Depending on where you live (for example California), the law gives you further rights; we honor them for everyone. We'll answer within 30 days.`,
+                `## Children`,
+                `This site isn't meant for children under 13, and we don't knowingly collect their information.`,
+                `## Changes`,
+                `If we change how we handle your information, we'll update this page and the date at the top.`,
+            ].join("\n\n"),
+        };
+    }
+    if (which === "accessibility") {
+        return {
+            title: "Accessibility",
+            body: [
+                `We want everyone to be able to use ${host}, including people who use a screen reader, a keyboard, magnification or other assistive technology. We aim to meet the Web Content Accessibility Guidelines (WCAG) 2.2 at level AA.`,
+                `## What we do`,
+                [
+                    `- Every picture that carries meaning has a description.`,
+                    `- Every page can be used with a keyboard alone, and shows where you are on it.`,
+                    `- Text and buttons are checked to stand out clearly from their background.`,
+                    `- Pages have headings in order and work when text is enlarged to 200%.`,
+                    `- Forms say what each box is for and what went wrong if something did.`,
+                    `- The site is checked automatically every time it changes.`,
+                ].join("\n"),
+                `## If something doesn't work for you`,
+                `Please tell us: ${reach || "contact us"}. Say which page and what happened, and we'll get you the information another way and fix it.`,
+                `## Compatibility`,
+                `The site is built to work with current versions of the major browsers and screen readers, on phones and computers.`,
+            ].join("\n\n"),
+        };
+    }
+    return {
+        title: "Terms of use",
+        body: [
+            `These terms cover your use of ${host}, run by ${b.name}.`,
+            `## The information here`,
+            `We keep this site accurate and up to date, but it's general information. Prices, availability and timings can change; a quote or booking is only confirmed when we confirm it to you directly.`,
+            `## Our content`,
+            `The words, photos and logo on this site belong to ${b.name} or the people who license them to us. Please don't copy them without asking.`,
+            `## Other websites`,
+            `Links to other sites are there to help you; we aren't responsible for what's on them.`,
+            `## Liability`,
+            `The site is provided as it is. As far as the law allows, we aren't liable for any loss from using it or relying on it.`,
+            b.address ? `## Law\n\nThese terms are governed by the laws of ${b.address.region}.` : null,
+            `## Questions`,
+            reach ? `${reach[0].toUpperCase()}${reach.slice(1)}.` : `Contact us.`,
+        ]
+            .filter(Boolean)
+            .join("\n\n"),
+    };
+}

package/dist/prepare.d.ts

@@ -0,0 +1,21 @@
+import type { Site } from "./content/index.ts";
+export type PreparedImage = {
+    width: number;
+    height: number;
+    /** The largest copy, for `src`. */
+    src: string;
+    /** WebP copies by width, smallest first; empty for an SVG. */
+    srcset: {
+        w: number;
+        url: string;
+    }[];
+    /** A 1200×630 JPEG, where a page shares it. */
+    share?: string;
+};
+export type Prepared = {
+    site: Site;
+    images: Record<string, PreparedImage>;
+};
+type Log = (line: string) => void;
+export declare function prepare(root: string, env?: Record<string, string | undefined>, log?: Log): Promise<Prepared>;
+export {};

package/dist/prepare.js

@@ -0,0 +1,159 @@
+// Everything a site's build needs from outside its code, made ready before the framework runs: the
+// content (CalOS's published version when the build is given its address, else the site's own
+// content/site.json), checked against the site's own declaration of its blocks (content/schema.ts);
+// and every picture the content uses, as WebP at the widths screens need, plus a 1200×630 crop for
+// sharing. It writes `.site/` (read at build) and `public/_img/` (served), and the declaration as
+// JSON Schema (`.site/schema.json`), which is what CalOS draws its editing forms from. Nothing here
+// knows which framework reads it: this is the contract between a site and CalOS.
+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 { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, extname, join, relative } from "node:path";
+import sharp from "sharp";
+import { pathToFileURL } from "node:url";
+import { imagesIn, shareImageOf } from "./images.js";
+const WIDTHS = [400, 640, 800, 1024, 1280, 1600, 2000];
+export async function prepare(root, env = process.env, log = console.log) {
+    const out = join(root, ".site");
+    const pub = join(root, "public");
+    const imagesDir = join(root, "content", "images");
+    await mkdir(out, { recursive: true });
+    // The content: CalOS's when told where, the site's own otherwise.
+    let raw;
+    let from;
+    if (env.CALOS_CONTENT_URL) {
+        const res = await fetch(env.CALOS_CONTENT_URL, {
+            headers: env.CALOS_SITE_TOKEN ? { authorization: `Bearer ${env.CALOS_SITE_TOKEN}` } : {},
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok)
+            throw new Error(`Couldn't get the content from CalOS (${env.CALOS_CONTENT_URL}): ${res.status}`);
+        const body = (await res.json());
+        raw = body.content;
+        from = "CalOS";
+        // Pictures uploaded in CalOS, fetched into the images folder once each.
+        for (const [name, url] of Object.entries(body.images ?? {})) {
+            const file = join(imagesDir, name);
+            if (existsSync(file))
+                continue;
+            const got = await fetch(url, { signal: AbortSignal.timeout(60_000) });
+            if (!got.ok)
+                throw new Error(`Couldn't get the image ${name} from CalOS: ${got.status}`);
+            await mkdir(dirname(file), { recursive: true });
+            await writeFile(file, Buffer.from(await got.arrayBuffer()));
+        }
+    }
+    else {
+        const file = join(root, "content", "site.json");
+        try {
+            raw = JSON.parse(await readFile(file, "utf8"));
+        }
+        catch (err) {
+            throw new Error(`Couldn't read ${relative(root, file)}: ${err.message}`);
+        }
+        from = "content/site.json";
+    }
+    const definition = await loadDefinition(root);
+    const parsed = definition.parse(raw);
+    if (parsed.problems)
+        throw new Error(`The site's content needs fixing (${from}):\n  - ${parsed.problems.join("\n  - ")}`);
+    const site = parsed.site;
+    await writeFile(join(out, "schema.json"), JSON.stringify(definition.jsonSchema(), null, 2) + "\n");
+    const images = await pictures(site, imagesDir, pub, log);
+    const prepared = { site, images };
+    await writeFile(join(out, "prepared.json"), JSON.stringify(prepared));
+    log(`site-kit: content from ${from}, ${site.pages.length} pages, ${Object.keys(images).length} images`);
+    return prepared;
+}
+// ---- pictures ----
+async function pictures(site, imagesDir, pub, log) {
+    const used = imagesIn(site);
+    const shared = new Set(site.pages.map((p) => shareImageOf(site, p)?.src).filter((s) => !!s));
+    const have = existsSync(imagesDir) ? await list(imagesDir) : [];
+    const missing = [...used].filter((src) => !have.includes(src));
+    if (missing.length) {
+        throw new Error(`The content names images that aren't in content/images: ${missing.join(", ")}.${have.length ? ` There is: ${have.join(", ")}` : " The folder is empty."}`);
+    }
+    const dir = join(pub, "_img");
+    await mkdir(dir, { recursive: true });
+    const result = {};
+    let made = 0;
+    for (const src of [...used].sort()) {
+        const bytes = await readFile(join(imagesDir, src));
+        const hash = createHash("sha256").update(bytes).digest("hex").slice(0, 10);
+        const base = src.replace(/\.[^.]+$/, "").replace(/[^\w-]+/g, "-");
+        if (extname(src).toLowerCase() === ".svg") {
+            const name = `${base}.${hash}.svg`;
+            if (!existsSync(join(dir, name)))
+                await writeFile(join(dir, name), bytes);
+            const meta = await sharp(bytes).metadata();
+            result[src] = { width: meta.width ?? 0, height: meta.height ?? 0, src: `/_img/${name}`, srcset: [] };
+            continue;
+        }
+        const img = sharp(bytes).rotate();
+        const meta = await img.metadata();
+        const upright = (meta.orientation ?? 1) >= 5;
+        const width = (upright ? meta.height : meta.width) ?? 0;
+        const height = (upright ? meta.width : meta.height) ?? 0;
+        const widths = WIDTHS.filter((w) => w < width).concat(width <= WIDTHS.at(-1) ? [width] : []);
+        const srcset = [];
+        for (const w of widths.length ? widths : [width]) {
+            const name = `${base}.${hash}.${w}.webp`;
+            if (!existsSync(join(dir, name))) {
+                await sharp(bytes).rotate().resize({ width: w }).webp({ quality: 78 }).toFile(join(dir, name));
+                made++;
+            }
+            srcset.push({ w, url: `/_img/${name}` });
+        }
+        const entry = { width, height, src: srcset.at(-1).url, srcset };
+        if (shared.has(src)) {
+            const name = `${base}.${hash}.share.jpg`;
+            if (!existsSync(join(dir, name))) {
+                await sharp(bytes).rotate().resize({ width: 1200, height: 630, fit: "cover" }).jpeg({ quality: 80, mozjpeg: true }).toFile(join(dir, name));
+                made++;
+            }
+            entry.share = `/_img/${name}`;
+        }
+        result[src] = entry;
+    }
+    if (made)
+        log(`site-kit: ${made} image copies made`);
+    return result;
+}
+async function list(dir, prefix = "") {
+    const out = [];
+    for (const e of await readdir(dir, { withFileTypes: true })) {
+        if (e.name.startsWith("."))
+            continue;
+        if (e.isDirectory())
+            out.push(...(await list(join(dir, e.name), `${prefix}${e.name}/`)));
+        else
+            out.push(`${prefix}${e.name}`);
+    }
+    return out;
+}
+/** The site's declaration of its blocks: `content/schema.ts`, the default export of `defineSite(...)`. */
+async function loadDefinition(root) {
+    const file = ["schema.ts", "schema.mjs", "schema.js"].map((f) => join(root, "content", f)).find((f) => existsSync(f));
+    if (!file)
+        throw new Error("There's no content/schema.ts: it declares the site's blocks with defineSite (see the starter)");
+    let mod;
+    try {
+        mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(file).href)));
+    }
+    catch (err) {
+        const message = err.message;
+        throw new Error(`Couldn't load ${relative(root, file)}: ${/Unknown file extension|ERR_UNKNOWN_FILE_EXTENSION/.test(message) ? "Node 22.18 or later is needed to read a TypeScript file (the build ran on " + process.version + ")" : message}`);
+    }
+    if (!mod.default || typeof mod.default.parse !== "function")
+        throw new Error(`${relative(root, file)} should export default defineSite({ ...blocks })`);
+    return mod.default;
+}

package/dist/seo.d.ts

@@ -0,0 +1,40 @@
+import { DAYS, type Business, type Page, type Site } from "./content/index.ts";
+/** The page's address as search engines should know it. */
+export declare function canonical(site: Site, path: string): string;
+/** "Services | Northfield Plumbing"; the home page's title stands alone when it already names them. */
+export declare function fullTitle(site: Site, page: Page): string;
+/** The business as schema.org describes it: what Google uses for its knowledge panel and maps. */
+export declare function businessData(site: Site, image?: string): Record<string, unknown>;
+/** FAQPage structured data from a page's questions and answers (`plain` turns an answer's Markdown to words). */
+export declare function faqData(items: {
+    q: string;
+    a: string;
+}[], plain: (md: string) => string): Record<string, unknown> | null;
+export declare function breadcrumbData(site: Site, page: Page): Record<string, unknown> | null;
+/** JSON for a `<script type="application/ld+json">`, safe to put in a page. */
+export declare function ldJson(data: unknown): string;
+/** Every page may be read; the sitemap says which there are. */
+export declare function robotsTxt(site: Site): string;
+/** Every page search engines should list, at its canonical address. */
+export declare function sitemapXml(site: Site): string;
+/**
+ * Cloudflare Pages' `_headers`: the security headers our site checks look for (the content
+ * security policy itself is in each page, with hashes of the page's own scripts and styles), long
+ * caching for the fingerprinted assets, and `noindex` on the preview addresses (<site>.caltho.site
+ * and <project>.pages.dev) so only the real domain is in search results.
+ */
+export declare function headersFile(): string;
+/**
+ * The site's `_redirects`: CalOS's list for this site when the build is given its address
+ * (CALOS_REDIRECTS_URL, the Website › Redirects page's list), otherwise the content's own. A
+ * CalOS that can't be reached fails the build rather than publishing without the redirects.
+ */
+export declare function loadRedirects(site: Site, url: string | undefined): Promise<{
+    file: string;
+    from: string;
+}>;
+/** "Mon–Fri 7am–6pm" lines for the hours, in the order given. */
+export declare function hoursLines(b: Business): {
+    days: (typeof DAYS)[number][];
+    time: string;
+}[];

package/dist/seo.js

@@ -0,0 +1,153 @@
+// What search engines and browsers read about a site besides its words: the structured data
+// (schema.org) describing the business, robots.txt, and the files Cloudflare Pages reads for
+// response headers and redirects. Everything here is worked out from the site's content.
+import { clock } from "./content/index.js";
+/** The page's address as search engines should know it. */
+export function canonical(site, path) {
+    return new URL(path, site.url).href;
+}
+/** "Services | Northfield Plumbing"; the home page's title stands alone when it already names them. */
+export function fullTitle(site, page) {
+    const name = site.business.name;
+    if (page.path === "/" && page.title.toLowerCase().includes(name.toLowerCase()))
+        return page.title;
+    const joined = `${page.title} | ${name}`;
+    // Search results cut titles at about 60 characters: the business's name only where it fits.
+    return joined.length <= 60 ? joined : page.title;
+}
+const DAY_URI = {
+    Mo: "Monday",
+    Tu: "Tuesday",
+    We: "Wednesday",
+    Th: "Thursday",
+    Fr: "Friday",
+    Sa: "Saturday",
+    Su: "Sunday",
+};
+/** The business as schema.org describes it: what Google uses for its knowledge panel and maps. */
+export function businessData(site, image) {
+    const b = site.business;
+    const sameAs = Object.values(b.social).filter(Boolean);
+    return clean({
+        "@context": "https://schema.org",
+        "@type": b.kind,
+        "@id": `${site.url.replace(/\/$/, "")}/#business`,
+        name: b.name,
+        description: b.tagline,
+        url: site.url,
+        telephone: b.phone,
+        email: b.email,
+        image,
+        priceRange: b.priceRange,
+        foundingDate: b.founded ? String(b.founded) : undefined,
+        address: b.address && b.showAddress
+            ? {
+                "@type": "PostalAddress",
+                streetAddress: b.address.street,
+                addressLocality: b.address.locality,
+                addressRegion: b.address.region,
+                postalCode: b.address.postcode,
+                addressCountry: b.address.country,
+            }
+            : b.address
+                ? { "@type": "PostalAddress", addressLocality: b.address.locality, addressRegion: b.address.region, addressCountry: b.address.country }
+                : undefined,
+        areaServed: b.areas.length ? b.areas.map((name) => ({ "@type": "Place", name })) : undefined,
+        openingHoursSpecification: b.hours.length
+            ? b.hours.map((h) => ({ "@type": "OpeningHoursSpecification", dayOfWeek: h.days.map((d) => `https://schema.org/${DAY_URI[d]}`), opens: h.opens, closes: h.closes }))
+            : undefined,
+        sameAs: sameAs.length ? sameAs : undefined,
+    });
+}
+/** FAQPage structured data from a page's questions and answers (`plain` turns an answer's Markdown to words). */
+export function faqData(items, plain) {
+    if (!items.length)
+        return null;
+    return {
+        "@context": "https://schema.org",
+        "@type": "FAQPage",
+        mainEntity: items.map((i) => ({ "@type": "Question", name: i.q, acceptedAnswer: { "@type": "Answer", text: plain(i.a) } })),
+    };
+}
+export function breadcrumbData(site, page) {
+    if (page.path === "/")
+        return null;
+    const crumbs = [{ name: "Home", path: "/" }];
+    const parts = page.path.split("/").filter(Boolean);
+    parts.forEach((_, i) => {
+        const path = `/${parts.slice(0, i + 1).join("/")}/`;
+        const p = site.pages.find((x) => x.path === path);
+        if (p)
+            crumbs.push({ name: p.menu ?? p.title, path });
+    });
+    return {
+        "@context": "https://schema.org",
+        "@type": "BreadcrumbList",
+        itemListElement: crumbs.map((c, i) => ({ "@type": "ListItem", position: i + 1, name: c.name, item: canonical(site, c.path) })),
+    };
+}
+/** JSON for a `<script type="application/ld+json">`, safe to put in a page. */
+export function ldJson(data) {
+    return JSON.stringify(data).replace(/</g, "\\u003c");
+}
+/** Every page may be read; the sitemap says which there are. */
+export function robotsTxt(site) {
+    return `User-agent: *\nAllow: /\n\nSitemap: ${canonical(site, "/sitemap.xml")}\n`;
+}
+/** Every page search engines should list, at its canonical address. */
+export function sitemapXml(site) {
+    const urls = site.pages.filter((p) => !p.noindex).map((p) => `  <url><loc>${canonical(site, p.path)}</loc></url>`);
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${urls.join("\n")}\n</urlset>\n`;
+}
+/**
+ * Cloudflare Pages' `_headers`: the security headers our site checks look for (the content
+ * security policy itself is in each page, with hashes of the page's own scripts and styles), long
+ * caching for the fingerprinted assets, and `noindex` on the preview addresses (<site>.caltho.site
+ * and <project>.pages.dev) so only the real domain is in search results.
+ */
+export function headersFile() {
+    return `/*
+  X-Content-Type-Options: nosniff
+  Referrer-Policy: strict-origin-when-cross-origin
+  Permissions-Policy: camera=(), microphone=(), geolocation=(), payment=(), usb=()
+  X-Frame-Options: DENY
+  Content-Security-Policy: frame-ancestors 'none'
+  Strict-Transport-Security: max-age=31536000
+
+/_next/static/*
+  Cache-Control: public, max-age=31536000, immutable
+
+/_img/*
+  Cache-Control: public, max-age=31536000, immutable
+
+/_fonts/*
+  Cache-Control: public, max-age=31536000, immutable
+
+https://:project.pages.dev/*
+  X-Robots-Tag: noindex
+
+https://:site.caltho.site/*
+  X-Robots-Tag: noindex
+`;
+}
+/**
+ * The site's `_redirects`: CalOS's list for this site when the build is given its address
+ * (CALOS_REDIRECTS_URL, the Website › Redirects page's list), otherwise the content's own. A
+ * CalOS that can't be reached fails the build rather than publishing without the redirects.
+ */
+export async function loadRedirects(site, url) {
+    if (url) {
+        const res = await fetch(url, { signal: AbortSignal.timeout(15_000) });
+        if (!res.ok)
+            throw new Error(`Couldn't get the redirects from CalOS (${url}): ${res.status}`);
+        return { file: await res.text(), from: "CalOS" };
+    }
+    return { file: site.redirects.map((r) => `${r.from} ${r.to} ${r.status}`).join("\n") + (site.redirects.length ? "\n" : ""), from: "site.json" };
+}
+/** "Mon–Fri 7am–6pm" lines for the hours, in the order given. */
+export function hoursLines(b) {
+    return b.hours.map((h) => ({ days: h.days, time: `${clock(h.opens)}–${clock(h.closes)}` }));
+}
+function clean(o) {
+    return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined && v !== null));
+}

package/package.json

@@ -1,6 +1,86 @@
 {
   "name": "@caltho/site-kit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "What every Caltho site is built with: the contract with CalOS (content, and how a site declares what is editable), images, search and security, and the checks",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/trycaltho/site-kit.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "bin": {
+    "site-kit": "dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./content": {
+      "types": "./dist/content/index.d.ts",
+      "default": "./dist/content/index.js"
+    },
+    "./lib": {
+      "types": "./dist/lib.d.ts",
+      "default": "./dist/lib.js"
+    },
+    "./next": {
+      "types": "./dist/next/index.d.ts",
+      "default": "./dist/next/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22.18"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/cli/index.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "bun test src",
+    "prepack": "bun run build"
+  },
+  "dependencies": {
+    "marked": "18.1.0",
+    "sharp": "0.35.5",
+    "zod": "4.6.7"
+  },
+  "peerDependencies": {
+    "axe-core": "^4.14.0",
+    "next": "^16.4.1",
+    "playwright": "^1.63.0",
+    "react": "^19.3.0"
+  },
+  "peerDependenciesMeta": {
+    "axe-core": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "playwright": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/bun": "1.4.2",
+    "@types/node": "22.20.5",
+    "@types/react": "19.3.0",
+    "axe-core": "4.14.0",
+    "next": "16.4.1",
+    "playwright": "1.63.0",
+    "react": "19.3.0",
+    "typescript": "6.0.3"
+  },
+  "bugs": {
+    "url": "https://github.com/trycaltho/site-kit/issues"
+  }
+}