npm - create-website-build-kit - Versions diffs - 0.1.0 - Mend

create-website-build-kit 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (91) hide show

package/README.md +54 -0
package/index.mjs +149 -0
package/package.json +42 -0
package/template/.dev.vars.example +3 -0
package/template/.github/workflows/gates.yml +58 -0
package/template/.node-version +1 -0
package/template/.pa11yci.json +24 -0
package/template/BUILD-STATE.md +47 -0
package/template/CLAUDE.md +153 -0
package/template/astro.config.mjs +150 -0
package/template/docs/analytics.md +86 -0
package/template/docs/content.md +138 -0
package/template/docs/handover.md +182 -0
package/template/docs/handover.pdf +0 -0
package/template/docs/runbook.md +661 -0
package/template/docs/traps.md +903 -0
package/template/gitignore +31 -0
package/template/package-lock.json +8159 -0
package/template/package.json +53 -0
package/template/public/_headers +61 -0
package/template/public/_redirects +39 -0
package/template/public/site.webmanifest +13 -0
package/template/scripts/a11y-evidence.mjs +258 -0
package/template/scripts/check-console.mjs +125 -0
package/template/scripts/check-env.mjs +99 -0
package/template/scripts/check-reflow.mjs +148 -0
package/template/scripts/check-sitemap.mjs +113 -0
package/template/scripts/dns-snapshot.mjs +267 -0
package/template/scripts/extract.mjs +317 -0
package/template/scripts/indexnow.mjs +154 -0
package/template/scripts/lastmod.mjs +147 -0
package/template/scripts/lib/inventory.mjs +104 -0
package/template/scripts/lib/preserved.mjs +42 -0
package/template/scripts/lib/routes.mjs +92 -0
package/template/scripts/md-to-pdf.mjs +335 -0
package/template/scripts/og-cards.config.mjs +114 -0
package/template/scripts/og-cards.mjs +487 -0
package/template/scripts/optimize-media.mjs +380 -0
package/template/scripts/recon.mjs +480 -0
package/template/scripts/redirects.mjs +298 -0
package/template/scripts/shots.mjs +447 -0
package/template/scripts/staging-headers.mjs +102 -0
package/template/scripts/tells.mjs +268 -0
package/template/scripts/verify.mjs +1069 -0
package/template/src/components/ContactForm.astro +405 -0
package/template/src/components/CtaBand.astro +82 -0
package/template/src/components/EnvBadge.astro +146 -0
package/template/src/components/Footer.astro +210 -0
package/template/src/components/Header.astro +530 -0
package/template/src/components/Icon.astro +56 -0
package/template/src/components/Img.astro +129 -0
package/template/src/components/PageHero.astro +88 -0
package/template/src/components/Seo.astro +119 -0
package/template/src/components/StructuredData.astro +173 -0
package/template/src/content/blog/.gitkeep +5 -0
package/template/src/content/legal/.gitkeep +0 -0
package/template/src/content.config.ts +81 -0
package/template/src/data/areas.ts +31 -0
package/template/src/data/business.ts +121 -0
package/template/src/data/categories.ts +37 -0
package/template/src/data/fonts.ts +25 -0
package/template/src/data/image-manifest.json +1 -0
package/template/src/data/lastmod.json +1 -0
package/template/src/data/nav.ts +49 -0
package/template/src/data/services.ts +39 -0
package/template/src/data/site.ts +136 -0
package/template/src/env.d.ts +28 -0
package/template/src/layouts/Base.astro +223 -0
package/template/src/lib/brevo.ts +96 -0
package/template/src/lib/hast-media.mjs +55 -0
package/template/src/lib/lastmod.mjs +47 -0
package/template/src/lib/lead.ts +92 -0
package/template/src/lib/legal-routes.mjs +31 -0
package/template/src/lib/legal.ts +75 -0
package/template/src/lib/posts.ts +64 -0
package/template/src/lib/runtime.ts +33 -0
package/template/src/pages/404.astro +51 -0
package/template/src/pages/[slug].astro +111 -0
package/template/src/pages/accessibility.astro +128 -0
package/template/src/pages/api/contact.ts +191 -0
package/template/src/pages/api/leads.csv.ts +82 -0
package/template/src/pages/contact.astro +112 -0
package/template/src/pages/index.astro +84 -0
package/template/src/pages/robots.txt.ts +38 -0
package/template/src/pages/rss.xml.ts +27 -0
package/template/src/styles/global.css +463 -0
package/template/src/styles/project.css +14 -0
package/template/src/styles/prose.css +182 -0
package/template/src/styles/tokens.css +218 -0
package/template/tsconfig.json +5 -0
package/template/wrangler.jsonc +63 -0

package/template/src/lib/brevo.ts ADDED Viewed

@@ -0,0 +1,96 @@
+/**
+ * Brevo transactional email.
+ *
+ * Deliberately thin: one fetch, no SDK. The API is three fields and a bearer
+ * header — a dependency here would be a liability with no upside.
+ */
+import type { LeadRecord } from './lead';
+import { business } from '../data/business';
+import { site } from '../data/site';
+const ENDPOINT = 'https://api.brevo.com/v3/smtp/email';
+type SendResult = { ok: true; messageId?: string } | { ok: false; error: string };
+async function send(
+  apiKey: string,
+  payload: Record<string, unknown>,
+  timeoutMs = 8000,
+): Promise<SendResult> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'api-key': apiKey,
+        'content-type': 'application/json',
+        accept: 'application/json',
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal,
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => '');
+      return { ok: false, error: `Brevo ${response.status}: ${body.slice(0, 300)}` };
+    }
+    const data = (await response.json().catch(() => ({}))) as { messageId?: string };
+    return { ok: true, messageId: data.messageId };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+const escapeHtml = (value: string) =>
+  value.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]!);
+const row = (label: string, value: string) =>
+  value
+    ? `<tr><td style="padding:8px 16px 8px 0;color:#5b656e;font-size:14px;white-space:nowrap;vertical-align:top">${label}</td><td style="padding:8px 0;color:#14171a;font-size:14px"><strong>${escapeHtml(value)}</strong></td></tr>`
+    : '';
+/** Internal new-lead notification. */
+export function notifyTeam(apiKey: string, lead: LeadRecord) {
+  const subjectTag = lead.env === 'test' ? '[TEST] ' : '';
+  return send(apiKey, {
+    sender: { name: business.email.senderName, email: business.email.sender },
+    to: [{ email: site.leadNotifyTo, name: business.name }],
+    replyTo: { email: lead.email, name: lead.name },
+    subject: `${subjectTag}New quote request — ${lead.name}${lead.service ? ` (${lead.service})` : ''}`,
+    htmlContent: `<!doctype html><html><body style="margin:0;padding:24px;background:#f4f6f7;font-family:-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif">
+<div style="max-width:560px;margin:0 auto;background:#fff;border-radius:16px;padding:28px;border:1px solid #e3e8eb">
+  ${lead.env === 'test' ? '<p style="margin:0 0 16px;padding:8px 12px;background:#fdf6e3;border-radius:8px;color:#7a5c00;font-size:13px">Submitted from staging — this is a test lead.</p>' : ''}
+  <h1 style="margin:0 0 4px;font-size:20px;color:#14171a">New quote request</h1>
+  <p style="margin:0 0 20px;color:#5b656e;font-size:14px">${new Date(lead.receivedAt).toLocaleString(business.locale, { timeZone: business.address.timeZone, dateStyle: 'full', timeStyle: 'short' })} ${business.address.timeZoneLabel}</p>
+  <table style="width:100%;border-collapse:collapse">
+    ${row('Name', lead.name)}
+    ${row('Email', lead.email)}
+    ${row('Phone', lead.phone)}
+    ${row('Service', lead.service)}
+    ${row('Page', lead.page)}
+  </table>
+  ${lead.message ? `<div style="margin-top:20px;padding-top:20px;border-top:1px solid #e3e8eb"><p style="margin:0 0 6px;color:#5b656e;font-size:13px">Message</p><p style="margin:0;color:#14171a;font-size:15px;line-height:1.6;white-space:pre-wrap">${escapeHtml(lead.message)}</p></div>` : ''}
+  <p style="margin:24px 0 0;padding-top:16px;border-top:1px solid #e3e8eb;color:#78838c;font-size:12px">Lead ${lead.id} · reply directly to reach ${escapeHtml(lead.name)}</p>
+</div></body></html>`,
+    textContent: [
+      lead.env === 'test' ? '[TEST LEAD — submitted from staging]' : '',
+      'New quote request',
+      `Name:    ${lead.name}`,
+      `Email:   ${lead.email}`,
+      `Phone:   ${lead.phone}`,
+      `Service: ${lead.service}`,
+      `Page:    ${lead.page}`,
+      '',
+      lead.message,
+      '',
+      `Lead ${lead.id} · ${lead.receivedAt}`,
+    ]
+      .filter(Boolean)
+      .join('\n'),
+  });
+}

package/template/src/lib/hast-media.mjs ADDED Viewed

@@ -0,0 +1,55 @@
+import { defineHastPlugin } from 'satteri';
+// Generated by `npm run media`. Empty on a fresh project — that is fine.
+import manifest from '../data/image-manifest.json' with { type: 'json' };
+/** `/img/blog/name-1200.webp` → `blog/name`, the manifest key. */
+function manifestKey(src) {
+  const match = /^\/img\/(.+)-\d+\.webp$/.exec(typeof src === 'string' ? src : '');
+  return match ? match[1] : null;
+}
+/**
+ * Upgrades markdown output at build time.
+ *
+ *  - <img> gains srcset/sizes and intrinsic width/height from the media
+ *    manifest, so article bodies never shift as images load. The markdown
+ *    itself keeps a plain root-relative path — portable, and the dev server
+ *    serves it directly.
+ *  - <table> is wrapped in a scroll container, so a wide table scrolls itself
+ *    rather than making the whole page scroll sideways on a phone.
+ *
+ * Written against Sätteri's native hast API rather than rehype: the legacy
+ * rehype path needs @astrojs/markdown-remark and swaps the whole pipeline back
+ * to unified, which is a dependency and a slowdown for no gain here.
+ */
+export const hastMedia = defineHastPlugin({
+  name: 'media-manifest',
+  element: [
+    {
+      filter: ['img'],
+      visit(node, ctx) {
+        const entry = manifest[manifestKey(node.properties?.src)];
+        if (!entry) return;
+        ctx.setProperty(node, 'srcset', entry.srcset);
+        ctx.setProperty(node, 'sizes', '(min-width: 46rem) 44rem, 92vw');
+        ctx.setProperty(node, 'width', entry.width);
+        ctx.setProperty(node, 'height', entry.height);
+        if (!node.properties?.loading) ctx.setProperty(node, 'loading', 'lazy');
+        if (!node.properties?.decoding) ctx.setProperty(node, 'decoding', 'async');
+      },
+    },
+    {
+      filter: ['table'],
+      visit(node, ctx) {
+        const parent = ctx.parent(node);
+        if (parent?.type === 'element' && parent.properties?.className?.includes?.('table-scroll')) return;
+        ctx.wrapNode(node, {
+          type: 'element',
+          tagName: 'div',
+          properties: { className: ['table-scroll'] },
+          children: [],
+        });
+      },
+    },
+  ],
+});

package/template/src/lib/lastmod.mjs ADDED Viewed

@@ -0,0 +1,47 @@
+/**
+ * Per-route `lastmod` for the sitemap.
+ *
+ * Reads src/data/lastmod.json, which is generated by `npm run lastmod` and
+ * committed. This module does no git work — it exists so astro.config.mjs can
+ * stay readable.
+ *
+ * ── WHY THE DATES ARE COMMITTED DATA AND NOT READ FROM git HERE ────────────
+ * The first version shelled out to `git log` during the build. It produced
+ * correct dates locally and NOTHING in production: Cloudflare Workers Builds
+ * shallow-clones, so per-file history does not exist there, and the module's
+ * own shallow guard correctly refused to stamp all 23 pages with one date.
+ *
+ * The guard was right; depending on history the build may not have been given
+ * was the mistake. Confirmed after deploying — the live sitemap had zero
+ * `lastmod` elements while the local build had 23.
+ *
+ * ── WHY NOT JUST STAMP THE BUILD TIME ─────────────────────────────────────
+ * Because it claims every page changed on every deploy, including deploys that
+ * only touched a script. Google uses `lastmod` where a site's values are
+ * consistently accurate and discounts them where they are not, so a
+ * plausible-looking wrong date does not buy a faster re-crawl — it spends the
+ * credibility that would have earned one.
+ *
+ * ── WHY LAYOUT AND NAV CHANGES DO NOT MOVE ANY DATE ───────────────────────
+ * An earlier cut treated src/layouts/Base.astro and src/data/nav.ts as sources
+ * for every route, reasoning that a footer link really does change all 23
+ * documents. True, and still wrong: it collapsed every date to the same day,
+ * which from outside is indistinguishable from the build-timestamp failure
+ * above and carries no prioritisation signal at all. Google's guidance asks
+ * for the last date a page's CONTENT changed significantly and says explicitly
+ * not to bump it for navigation or boilerplate.
+ *
+ * If the JSON is missing or unreadable, no `lastmod` is emitted anywhere.
+ * "I don't know" is a valid thing for a sitemap to say; guessing is not.
+ */
+import { readFileSync } from 'node:fs';
+export function lastmodByRoute() {
+  try {
+    return new Map(Object.entries(JSON.parse(readFileSync('src/data/lastmod.json', 'utf8'))));
+  } catch {
+    console.warn('[sitemap] src/data/lastmod.json missing — omitting lastmod. Run `npm run lastmod`.');
+    return new Map();
+  }
+}

package/template/src/lib/lead.ts ADDED Viewed

@@ -0,0 +1,92 @@
+/**
+ * Lead validation and shape. Shared by the API route and (for the field names)
+ * the form component, so the two cannot drift.
+ */
+export type LeadField = 'name' | 'email' | 'phone' | 'service' | 'message';
+export type LeadInput = Record<LeadField, string> & {
+  /** Honeypot. Real users never fill this. */
+  company?: string;
+  page?: string;
+};
+export type LeadRecord = {
+  id: string;
+  receivedAt: string;
+  env: 'live' | 'test';
+  name: string;
+  email: string;
+  phone: string;
+  service: string;
+  message: string;
+  page: string;
+  userAgent: string;
+  country: string;
+  ip: string;
+};
+/**
+ * The form's service dropdown. Keep in step with `src/data/services.ts` — these
+ * strings land in the lead record and the notification email, so a value that
+ * does not match a real service makes the enquiry harder to route, not easier.
+ * Always keep a final catch-all option.
+ */
+export const SERVICE_OPTIONS = [
+  'Service one',
+  'Service two',
+  'Something else',
+] as const;
+const EMAIL = /^[^\s@]+@[^\s@]+\.[a-z]{2,}$/i;
+/** Digits only, 10 or 11 (with a leading 1). Formatting is the user's business. */
+const digits = (value: string) => value.replace(/\D/g, '');
+export function validateLead(input: Partial<LeadInput>): {
+  ok: boolean;
+  errors: Partial<Record<LeadField, string>>;
+  values: Record<LeadField, string>;
+} {
+  const values = {
+    name: (input.name ?? '').trim(),
+    email: (input.email ?? '').trim(),
+    phone: (input.phone ?? '').trim(),
+    service: (input.service ?? '').trim(),
+    message: (input.message ?? '').trim(),
+  };
+  const errors: Partial<Record<LeadField, string>> = {};
+  if (values.name.length < 2) errors.name = 'Please tell us your name.';
+  else if (values.name.length > 100) errors.name = 'That name is too long.';
+  if (!values.email) errors.email = 'We need an email to send your quote to.';
+  else if (!EMAIL.test(values.email) || values.email.length > 200)
+    errors.email = 'That email address does not look right.';
+  /*
+   * Country-agnostic on purpose. E.164 caps a number at 15 digits including the
+   * country code, and 7 is about the shortest real national number, so anything
+   * in that band is plausible somewhere. A 10-digit rule is a US rule, and it
+   * silently rejects every UK, Irish and Australian visitor on a kit whose own
+   * compliance reference covers the EAA and AODA.
+   *
+   * ⚠ Tighten this per project if you serve one country. Do not tighten it in
+   * the template.
+   */
+  const phoneDigits = digits(values.phone);
+  if (!values.phone) errors.phone = 'A phone number lets us confirm your appointment.';
+  else if (phoneDigits.length < 7 || phoneDigits.length > 15)
+    errors.phone = 'That phone number does not look right.';
+  if (values.message.length > 4000) errors.message = 'Please keep your message under 4000 characters.';
+  return { ok: Object.keys(errors).length === 0, errors, values };
+}
+/**
+ * Key format sorts chronologically in a KV list, so the CSV export comes out
+ * newest-last without a sort step and pagination is stable.
+ */
+export const leadKey = (receivedAt: string, id: string) => `lead:${receivedAt}:${id}`;

package/template/src/lib/legal-routes.mjs ADDED Viewed

@@ -0,0 +1,31 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+const DIR = 'src/content/legal';
+/**
+ * Legal routes whose frontmatter says `noindex: true`.
+ *
+ * Read at CONFIG time, so `@astrojs/sitemap` can leave them out.
+ *
+ * `check-sitemap.mjs` explains why the sitemap's exclusion list is hand-kept in
+ * general: inclusion is decided in astro.config.mjs, before any page renders,
+ * so at that moment nothing knows which routes will emit the tag. Legal pages
+ * are the exception — their `noindex` is frontmatter sitting on disk, readable
+ * without rendering anything, so this one list can derive rather than drift.
+ *
+ * Deliberately a flat regex rather than a YAML parser: the config should not
+ * pull in a second content pipeline to answer one boolean, and if the shape
+ * ever stops matching, `npm run check:sitemap` fails the production build —
+ * which is exactly the cross-check that exists for this.
+ */
+export function noindexLegalRoutes() {
+  if (!existsSync(DIR)) return [];
+  return readdirSync(DIR)
+    .filter((file) => file.endsWith('.md'))
+    .filter((file) => {
+      const frontmatter = readFileSync(`${DIR}/${file}`, 'utf8').split(/^---\s*$/m)[1] ?? '';
+      return /^\s*noindex:\s*true\s*$/m.test(frontmatter);
+    })
+    .map((file) => `/${file.replace(/\.md$/, '')}/`);
+}

package/template/src/lib/legal.ts ADDED Viewed

@@ -0,0 +1,75 @@
+import { getCollection, type CollectionEntry } from 'astro:content';
+import { business } from '../data/business';
+import type { NavItem } from '../data/nav';
+export type LegalPage = CollectionEntry<'legal'>;
+/*
+ * ⚠ Does the collection have anything in it? Resolved by Vite at build time,
+ * so this costs nothing at runtime.
+ *
+ * `getCollection` on an EMPTY collection logs "The collection \"legal\" does not
+ * exist or is empty" — and the footer runs on every page, so a fresh template
+ * printed that line once per route on every build. Nothing was wrong; an empty
+ * legal collection is the normal state of a site nobody has written a privacy
+ * policy for yet. A starter that shouts at you about the correct state is a
+ * starter people stop reading the output of.
+ */
+const HAS_PAGES = Object.keys(import.meta.glob('../content/legal/**/*.md')).length > 0;
+/**
+ * Legal and policy pages, in footer order.
+ *
+ * Empty in a fresh template, and that is the point: nothing is emitted and
+ * nothing is linked until a page is actually written.
+ */
+export async function getLegalPages(): Promise<LegalPage[]> {
+  if (!HAS_PAGES) return [];
+  const pages = await getCollection('legal');
+  return pages.sort(
+    (a, b) => a.data.order - b.data.order || a.data.title.localeCompare(b.data.title),
+  );
+}
+/**
+ * The same pages as footer links.
+ *
+ * `nav.ts` explains why privacy and terms were never listed there by hand: a
+ * footer link to a page nobody has written yet is a 404 on EVERY page of the
+ * site, and nothing reports it. Deriving the links from the pages themselves
+ * removes that — the link cannot exist without the page.
+ *
+ * A `noindex` page is still linked. It has to be reachable to be enforceable;
+ * not being indexed is a separate decision from not being findable.
+ */
+export async function getLegalLinks(): Promise<NavItem[]> {
+  const pages = await getLegalPages();
+  return pages.map((page) => ({
+    label: page.data.navLabel ?? page.data.title,
+    href: `/${page.id}/`,
+  }));
+}
+/**
+ * ⚠ PINNED TO UTC, AND THAT IS THE WHOLE FUNCTION.
+ *
+ * An effective date is a calendar date, not an instant. `2026-08-21` parsed as
+ * a Date is midnight *Z*, and rendering that in the build machine's zone gives
+ * 20 August anywhere west of Greenwich — measured: US Pacific and US Eastern
+ * shift it, London and Tokyo do not. On a legal page that is the date the terms
+ * took effect being wrong by a day, on a page written precisely so a date can
+ * be relied on, with a clean build and nothing to report it.
+ *
+ * The schema keeps these as strings for the same reason. This builds the
+ * instant explicitly from the parts and formats it in the zone it was built in.
+ */
+export function formatLegalDate(iso: string): string {
+  const [year, month, day] = iso.split('-').map(Number);
+  return new Date(Date.UTC(year, month - 1, day)).toLocaleDateString(business.locale, {
+    month: 'long',
+    day: 'numeric',
+    year: 'numeric',
+    timeZone: 'UTC',
+  });
+}

package/template/src/lib/posts.ts ADDED Viewed

@@ -0,0 +1,64 @@
+import { getCollection, type CollectionEntry } from 'astro:content';
+import { business } from '../data/business';
+export type Post = CollectionEntry<'blog'>;
+/** Published posts, newest first. Drafts never reach a build. */
+export async function getPosts(): Promise<Post[]> {
+  const posts = await getCollection('blog', ({ data }) => !data.draft);
+  return posts.sort((a, b) => b.data.publishedAt.getTime() - a.data.publishedAt.getTime());
+}
+export async function getPostsByCategory(categoryName: string): Promise<Post[]> {
+  const posts = await getPosts();
+  return posts.filter((post) => post.data.categories.includes(categoryName));
+}
+/**
+ * Related posts: prefer ones sharing the most categories, then the most recent.
+ * "General" is on nearly everything, so it is worth little as a signal.
+ */
+export function relatedPosts(post: Post, all: Post[], limit = 3): Post[] {
+  const weight = (name: string) => (name === 'General' ? 1 : 4);
+  return all
+    .filter((candidate) => candidate.id !== post.id)
+    .map((candidate) => ({
+      candidate,
+      score: candidate.data.categories
+        .filter((c) => post.data.categories.includes(c))
+        .reduce((sum, c) => sum + weight(c), 0),
+    }))
+    .sort(
+      (a, b) =>
+        b.score - a.score ||
+        b.candidate.data.publishedAt.getTime() - a.candidate.data.publishedAt.getTime(),
+    )
+    .slice(0, limit)
+    .map((entry) => entry.candidate);
+}
+/** ~230 wpm, rounded up. Matches what Rank Math reported on the old site. */
+export function readingMinutes(body: string): number {
+  const words = body.trim().split(/\s+/).length;
+  return Math.max(1, Math.round(words / 230));
+}
+/**
+ * ⚠ `timeZone: 'UTC'` is load-bearing, not a default being spelled out.
+ *
+ * `publishedAt: 2026-08-21` in frontmatter becomes 2026-08-21T00:00:00Z, and
+ * formatting that instant in the BUILD MACHINE's zone renders 20 August
+ * anywhere west of Greenwich. Measured: US Pacific and US Eastern both shift
+ * it; London and Tokyo do not. So the same commit published a different date
+ * depending on who ran the build, and nothing anywhere reported it.
+ *
+ * The locale still comes from the business — that decides the ORDER and the
+ * wording. Only the zone is pinned.
+ */
+export const formatDate = (date: Date) =>
+  date.toLocaleDateString(business.locale, {
+    month: 'long',
+    day: 'numeric',
+    year: 'numeric',
+    timeZone: 'UTC',
+  });

package/template/src/lib/runtime.ts ADDED Viewed

@@ -0,0 +1,33 @@
+/**
+ * Access to Cloudflare bindings.
+ *
+ * `Astro.locals.runtime.env` was removed in Astro v6 — reading it throws at
+ * request time while the build, the types and the deploy all stay green. The
+ * only signal is an actual request. Everything that touches a binding goes
+ * through here so there is one place to change if it moves again.
+ *
+ * `env` from `cloudflare:workers` is a lazy proxy: importing it at module scope
+ * is safe, but touching a property outside a request context is not. Only read
+ * it inside a handler.
+ */
+import { env } from 'cloudflare:workers';
+type Bindings = {
+  LEADS?: KVNamespace;
+  LEADS_STAGING?: KVNamespace;
+  BREVO_API_KEY?: string;
+  LEADS_EXPORT_TOKEN?: string;
+};
+export function bindings(): Bindings {
+  return env as unknown as Bindings;
+}
+export function kv(name: 'LEADS' | 'LEADS_STAGING'): KVNamespace | undefined {
+  return bindings()[name];
+}
+export function secret(name: 'BREVO_API_KEY' | 'LEADS_EXPORT_TOKEN'): string | undefined {
+  const value = bindings()[name];
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}

package/template/src/pages/404.astro ADDED Viewed

@@ -0,0 +1,51 @@
+---
+import Base from '../layouts/Base.astro';
+import { business } from '../data/business';
+import { nav } from '../data/nav';
+/**
+ * A real 404 — the worker returns status 404 for this route, not 200.
+ *
+ * The onward links come from src/data/nav.ts so they can never point at a page
+ * that has since been removed. Offer SPECIFIC routes, not "go home": someone
+ * who landed on a dead link wanted something particular, and a link back to
+ * the homepage asks them to start the search again.
+ */
+---
+<Base
+  title={`Page not found - ${business.name}`}
+  description="The page you were looking for could not be found."
+  noindex
+>
+  <section class="section under-header">
+    <div class="container container--text">
+      <h1>This page doesn’t exist.</h1>
+      <p class="notfound__lede">
+        The link may be out of date, or the page may have moved. Here is where most people are
+        heading — or call and we will point you the right way.
+      </p>
+      <ul role="list" class="notfound__links">
+        {nav.map((link) => <li><a href={link.href}>{link.label}</a></li>)}
+      </ul>
+      <p><a class="btn" href={business.phone.href}>Call {business.phone.display}</a></p>
+    </div>
+  </section>
+</Base>
+<style>
+  .notfound__lede {
+    margin-block-start: var(--space-m);
+    font-size: var(--step-1);
+    color: var(--text-muted);
+  }
+  .notfound__links {
+    display: grid;
+    gap: var(--space-2xs);
+    margin-block: var(--space-xl);
+    padding: 0;
+  }
+</style>

package/template/src/pages/[slug].astro ADDED Viewed

@@ -0,0 +1,111 @@
+---
+/**
+ * Legal and policy pages: /privacy/, /terms/, /house-rules/.
+ *
+ * One route for all of them. Three near-identical .astro files is the thing
+ * this replaces, and the second cost is worse than the duplication: an editor
+ * who cannot change an effective date without a developer.
+ *
+ * ── WHY THIS SITS AT THE ROOT ──────────────────────────────────────────────
+ * Because /privacy/ is the URL, and on a migration it is a URL that already
+ * exists and must be preserved. /legal/privacy/ would be a redirect to write
+ * and a link everyone else has wrong.
+ *
+ * ── WHICH MAKES IT A CATCH-ALL, SO IT GUARDS ITSELF ────────────────────────
+ * Astro gives a static route precedence over a dynamic one, so adding
+ * src/content/legal/contact.md does NOT break /contact/ — it silently does
+ * nothing, which is worse. You would have a page in the collection, a link to
+ * it in the footer, and the contact form served at that URL. The check below
+ * turns that into a build failure naming both files.
+ *
+ * ── THERE IS NO DESIGN HERE, ON PURPOSE ────────────────────────────────────
+ * A heading, a date line and the prose. Legal pages are the one page type with
+ * genuinely nothing to art-direct, and `prose.css` already carries the
+ * long-form treatment this project chose. If this page needs a look, the look
+ * belongs in project.css.
+ */
+import { render } from 'astro:content';
+import PageHero from '../components/PageHero.astro';
+import Base from '../layouts/Base.astro';
+import { business } from '../data/business';
+import { getLegalPages, formatLegalDate, type LegalPage } from '../lib/legal';
+export async function getStaticPaths() {
+  /*
+   * Every route file that already exists, as its first path segment.
+   *
+   * import.meta.glob is resolved at build time, so this is the real directory
+   * rather than a list somebody maintains — the same reason the scripts
+   * discover routes instead of carrying an array.
+   *
+   * Declared INSIDE getStaticPaths deliberately: Astro hoists this function
+   * into its own scope for the prerender pass, so a module-level const here is
+   * `ReferenceError: RESERVED is not defined` at build time, not a lint error.
+   */
+  const reserved = new Set(
+    Object.keys(import.meta.glob('./**/*.{astro,md,ts,js}'))
+      .map((file) => file.replace(/^\.\//, '').split('/')[0])
+      .map((segment) => segment.replace(/\.(astro|md|ts|js)$/, ''))
+      .filter((segment) => !segment.startsWith('[')),
+  );
+  const pages = await getLegalPages();
+  for (const page of pages) {
+    if (reserved.has(page.id)) {
+      throw new Error(
+        `src/content/legal/${page.id}.md would be served at /${page.id}/, but src/pages/${page.id} ` +
+          `already claims that route.\n` +
+          `Astro gives the existing page precedence, so the legal page would be built, linked ` +
+          `from the footer, and never reachable.\n` +
+          `Rename the markdown file, or delete the page that shadows it.`,
+      );
+    }
+  }
+  return pages.map((page) => ({ params: { slug: page.id }, props: { page } }));
+}
+interface Props {
+  page: LegalPage;
+}
+const { page } = Astro.props;
+const { Content } = await render(page);
+---
+<Base
+  title={`${page.data.title} - ${business.name}`}
+  description={page.data.description}
+  canonical={`/${page.id}/`}
+  noindex={page.data.noindex}
+  breadcrumbs={[{ name: 'Home', href: '/' }, { name: page.data.title, href: `/${page.id}/` }]}
+>
+  <PageHero
+    title={page.data.title}
+    breadcrumbs={[{ name: 'Home', href: '/' }, { name: page.data.title, href: `/${page.id}/` }]}
+  />
+  <section class="section">
+    <div class="container container--text prose">
+      {/* A <time> with a machine-readable datetime: the visible string is
+          localised, the attribute stays ISO for anything that parses it. */}
+      <p>
+        <strong>Effective <time datetime={page.data.effective}>{formatLegalDate(page.data.effective)}</time></strong>
+        {
+          page.data.updated && (
+            <>
+              {' · '}
+              <span>
+                Last updated <time datetime={page.data.updated}>{formatLegalDate(page.data.updated)}</time>
+              </span>
+            </>
+          )
+        }
+      </p>
+      <Content />
+    </div>
+  </section>
+</Base>