pagelathe 0.1.0

package/dist/registry/sections/header/schema.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import type { SectionManifest } from "../src/manifest.js";
+
+export const navLinkSchema = z.object({ label: z.string().min(1), href: z.string().min(1) });
+
+export const propsSchema = z.object({
+  brand: z.string().min(1),
+  links: z.array(navLinkSchema).max(6).default([]),
+  github: z.object({ href: z.string().min(1), stars: z.string().optional() }).optional(),
+  cta: z.object({ label: z.string().min(1), href: z.string().min(1) }).optional(),
+});
+
+export const entrySchema = z.object({
+  type: z.literal("header"),
+  id: z.string().min(1),
+  props: propsSchema,
+});
+
+export const manifest: SectionManifest = {
+  type: "header",
+  title: "Header / Navbar",
+  description: "Top navigation with brand, links, GitHub star badge, and a co-equal docs/CTA link.",
+  required: true,
+  archetypes: ["sdk-infra", "technical-app", "general"],
+  componentFile: "section.astro",
+  defaultProps: {
+    brand: "Branchy",
+    links: [
+      { label: "Docs", href: "/docs" },
+      { label: "Pricing", href: "#pricing" },
+    ],
+    github: { href: "https://github.com", stars: "4.2k" },
+    cta: { label: "Start free", href: "#get-started" },
+  } satisfies z.input<typeof propsSchema>,
+};

package/dist/registry/sections/header/section.astro

@@ -0,0 +1,28 @@
+---
+import type { z } from "zod";
+import type { propsSchema } from "./schema.js";
+
+type Props = z.infer<typeof propsSchema>;
+const { brand, links, github, cta } = Astro.props as Props;
+---
+
+<header class="sticky top-0 z-50 border-b border-white/10 bg-black/60 backdrop-blur" data-section="header">
+  <nav class="mx-auto flex max-w-6xl items-center justify-between px-6 py-4" aria-label="Primary">
+    <a href="/" class="text-sm font-bold text-white">{brand}</a>
+    <div class="flex items-center gap-6">
+      {links.map((l) => (
+        <a href={l.href} class="hidden text-sm text-white/70 hover:text-white sm:inline">{l.label}</a>
+      ))}
+      {github && (
+        <a href={github.href} class="text-sm text-white/70 hover:text-white" aria-label="Star on GitHub">
+          ★ {github.stars ?? "GitHub"}
+        </a>
+      )}
+      {cta && (
+        <a href={cta.href} class="rounded-[var(--radius)] bg-[var(--color-primary)] px-4 py-2 text-sm font-semibold text-white hover:opacity-90">
+          {cta.label}
+        </a>
+      )}
+    </div>
+  </nav>
+</header>

package/dist/registry/sections/hero/schema.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import type { SectionManifest } from "../src/manifest.js";
+
+export const ctaSchema = z.object({
+  label: z.string().min(1),
+  href: z.string().min(1),
+  style: z.enum(["primary", "secondary", "ghost"]).default("primary"),
+});
+
+export const propsSchema = z.object({
+  variant: z.enum(["code-snippet", "product-ui"]).default("code-snippet"),
+  eyebrow: z.string().optional(),
+  headline: z.string().min(1),
+  subhead: z.string().min(1),
+  ctas: z.array(ctaSchema).min(1).max(3),
+  /** Shown when variant === "code-snippet". */
+  code: z.object({ lang: z.string().min(1), source: z.string().min(1) }).optional(),
+  /** Shown when variant === "product-ui". */
+  image: z.object({ src: z.string().min(1), alt: z.string().min(1) }).optional(),
+});
+
+export const entrySchema = z.object({
+  type: z.literal("hero"),
+  id: z.string().min(1),
+  props: propsSchema,
+});
+
+export const manifest: SectionManifest = {
+  type: "hero",
+  title: "Hero",
+  description: "Above-the-fold value statement with CTAs; adaptive code or product-UI variant.",
+  required: true,
+  archetypes: ["sdk-infra", "technical-app", "general"],
+  variants: ["code-snippet", "product-ui"],
+  componentFile: "section.astro",
+  defaultProps: {
+    variant: "code-snippet",
+    eyebrow: "Open source",
+    headline: "Postgres branching for teams",
+    subhead: "Spin up an isolated database branch per pull request in one command.",
+    ctas: [
+      { label: "Start free", href: "#get-started", style: "primary" },
+      { label: "View on GitHub", href: "https://github.com", style: "secondary" },
+    ],
+    code: {
+      lang: "bash",
+      source: "npx branchy create --from main\n# → branch ready in 1.2s",
+    },
+  } satisfies z.input<typeof propsSchema>,
+};

package/dist/registry/sections/hero/section.astro

@@ -0,0 +1,56 @@
+---
+import { codeToHtml } from "shiki";
+import type { z } from "zod";
+import type { propsSchema } from "./schema.js";
+
+type Props = z.infer<typeof propsSchema>;
+const { variant, eyebrow, headline, subhead, ctas, code, image } = Astro.props as Props;
+
+const ctaClass: Record<string, string> = {
+  primary: "bg-[var(--color-primary)] text-white hover:opacity-90",
+  secondary: "border border-white/15 text-white hover:bg-white/5",
+  ghost: "text-white/70 hover:text-white",
+};
+
+let codeHtml = "";
+if (variant === "code-snippet" && code) {
+  codeHtml = await codeToHtml(code.source, { lang: code.lang, theme: "github-dark" });
+}
+---
+
+<section class="relative mx-auto max-w-6xl px-6 py-24" data-section="hero">
+  <div class="grid items-center gap-12 lg:grid-cols-2">
+    <div>
+      {eyebrow && <p class="mb-3 text-sm font-medium text-[var(--color-primary)]">{eyebrow}</p>}
+      <h1 class="text-4xl font-bold tracking-tight text-white sm:text-5xl">{headline}</h1>
+      <p class="mt-5 text-lg text-white/70">{subhead}</p>
+      <div class="mt-8 flex flex-wrap gap-3">
+        {ctas.map((c) => (
+          <a
+            href={c.href}
+            class={`inline-flex items-center rounded-[var(--radius)] px-5 py-2.5 text-sm font-semibold transition ${ctaClass[c.style]}`}
+          >
+            {c.label}
+          </a>
+        ))}
+      </div>
+    </div>
+    <div class="min-w-0">
+      {variant === "code-snippet" && code && (
+        <div
+          class="overflow-x-auto rounded-[var(--radius)] border border-white/10 bg-black/40 p-4 text-sm [&_pre]:!bg-transparent"
+          set:html={codeHtml}
+        />
+      )}
+      {variant === "product-ui" && image && (
+        <img
+          src={image.src}
+          alt={image.alt}
+          class="w-full rounded-[var(--radius)] border border-white/10"
+          loading="eager"
+          decoding="async"
+        />
+      )}
+    </div>
+  </div>
+</section>

package/dist/registry/sections/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@pagelathe/sections",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/registry.ts",
+    "./manifest": "./src/manifest.ts",
+    "./page": "./src/page.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "astro": "^6.4.4",
+    "shiki": "^1.24.0",
+    "vitest": "^3.2.6"
+  }
+}

package/dist/registry/sections/pricing/schema.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import type { SectionManifest } from "../src/manifest.js";
+
+export const tierSchema = z.object({
+  name: z.string().min(1),
+  price: z.string().min(1),
+  period: z.string().optional(),
+  description: z.string().min(1),
+  features: z.array(z.string().min(1)).min(1),
+  cta: z.object({ label: z.string().min(1), href: z.string().min(1) }),
+  featured: z.boolean().default(false),
+});
+
+export const propsSchema = z.object({
+  heading: z.string().min(1),
+  subhead: z.string().optional(),
+  tiers: z.array(tierSchema).min(1).max(4),
+});
+
+export const entrySchema = z.object({
+  type: z.literal("pricing"),
+  id: z.string().min(1),
+  props: propsSchema,
+});
+
+export const manifest: SectionManifest = {
+  type: "pricing",
+  title: "Pricing",
+  description: "Transparent pricing tiers with honest constraints (rate limits, free tier).",
+  required: true,
+  archetypes: ["sdk-infra", "technical-app", "general"],
+  componentFile: "section.astro",
+  defaultProps: {
+    heading: "Honest pricing",
+    subhead: "Start free. No credit card.",
+    tiers: [
+      {
+        name: "Open source",
+        price: "$0",
+        description: "Self-host, unlimited branches.",
+        features: ["Self-hosted", "Community support", "Apache-2.0"],
+        cta: { label: "Get started", href: "#get-started" },
+      },
+      {
+        name: "Team",
+        price: "$29",
+        period: "/mo",
+        description: "Managed cloud for small teams.",
+        features: ["10 projects", "Daily backups", "Email support"],
+        cta: { label: "Start trial", href: "#trial" },
+        featured: true,
+      },
+    ],
+  } satisfies z.input<typeof propsSchema>,
+};

package/dist/registry/sections/pricing/section.astro

@@ -0,0 +1,29 @@
+---
+import type { z } from "zod";
+import type { propsSchema } from "./schema.js";
+
+type Props = z.infer<typeof propsSchema>;
+const { heading, subhead, tiers } = Astro.props as Props;
+---
+
+<section id="pricing" class="mx-auto max-w-6xl px-6 py-24" data-section="pricing">
+  <div class="mx-auto max-w-2xl text-center">
+    <h2 class="text-3xl font-bold tracking-tight text-white">{heading}</h2>
+    {subhead && <p class="mt-3 text-white/60">{subhead}</p>}
+  </div>
+  <div class="mt-12 grid gap-6 sm:grid-cols-2 lg:grid-cols-3">
+    {tiers.map((t) => (
+      <div class={`flex flex-col rounded-[var(--radius)] border p-7 ${t.featured ? "border-[var(--color-primary)] bg-white/[0.03]" : "border-white/10"}`}>
+        <h3 class="text-sm font-semibold text-white/80">{t.name}</h3>
+        <p class="mt-3"><span class="text-3xl font-bold text-white">{t.price}</span>{t.period && <span class="text-white/50">{t.period}</span>}</p>
+        <p class="mt-2 text-sm text-white/60">{t.description}</p>
+        <ul class="mt-5 flex-1 space-y-2">
+          {t.features.map((f) => <li class="text-sm text-white/70">✓ {f}</li>)}
+        </ul>
+        <a href={t.cta.href} class={`mt-6 rounded-[var(--radius)] px-4 py-2.5 text-center text-sm font-semibold ${t.featured ? "bg-[var(--color-primary)] text-white hover:opacity-90" : "border border-white/15 text-white hover:bg-white/5"}`}>
+          {t.cta.label}
+        </a>
+      </div>
+    ))}
+  </div>
+</section>

package/dist/registry/sections/src/a11y.ts

@@ -0,0 +1,34 @@
+export interface A11yExpectations {
+  /** Require at least one landmark element from this list (e.g. ["nav"]). */
+  landmarks?: string[];
+  /** Every <img> must have a non-empty alt attribute. */
+  imagesHaveAlt?: boolean;
+  /** Every <a> must have non-whitespace text or an aria-label. */
+  linksHaveText?: boolean;
+}
+
+/** Lightweight, dependency-free structural a11y assertions over rendered HTML.
+ *  Returns an array of human-readable violation messages (empty == pass). */
+export function checkA11y(html: string, expect: A11yExpectations): string[] {
+  const violations: string[] = [];
+  for (const tag of expect.landmarks ?? []) {
+    if (!new RegExp(`<${tag}[\\s>]`, "i").test(html)) {
+      violations.push(`missing <${tag}> landmark`);
+    }
+  }
+  if (expect.imagesHaveAlt) {
+    for (const img of html.match(/<img\b[^>]*>/gi) ?? []) {
+      if (!/\balt\s*=\s*["'][^"']+["']/i.test(img)) violations.push(`<img> without alt: ${img}`);
+    }
+  }
+  if (expect.linksHaveText) {
+    for (const m of html.matchAll(/<a\b([^>]*)>([\s\S]*?)<\/a>/gi)) {
+      const attrs = m[1] ?? "";
+      const inner = (m[2] ?? "").replace(/<[^>]+>/g, "").trim();
+      if (inner.length === 0 && !/\baria-label\s*=/i.test(attrs)) {
+        violations.push(`<a> without text or aria-label`);
+      }
+    }
+  }
+  return violations;
+}

package/dist/registry/sections/src/env.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="astro/client" />
+
+declare module "*.astro" {
+  import type { AstroComponentFactory } from "astro/runtime/server/index.js";
+  const Component: AstroComponentFactory;
+  export default Component;
+}

package/dist/registry/sections/src/manifest.ts

@@ -0,0 +1,41 @@
+import type { ZodTypeAny } from "zod";
+
+export type Archetype = "sdk-infra" | "technical-app" | "general";
+
+export type PrimaryGoal = "signup" | "github_star" | "docs" | "contact" | "waitlist" | "purchase";
+
+/** Canonical M2 section types. Extending the registry adds to this union. */
+export type SectionType =
+  | "header"
+  | "hero"
+  | "features"
+  | "codeDemo"
+  | "pricing"
+  | "finalCta"
+  | "footer";
+
+export interface SectionManifest {
+  /** Stable id; equals the section directory name. */
+  type: SectionType;
+  /** Human title for docs/registry listings. */
+  title: string;
+  /** One-line description of the section's purpose. */
+  description: string;
+  /** Required-by-default in a generated page. */
+  required: boolean;
+  /** Archetypes that include this section by default. */
+  archetypes: Archetype[];
+  /** Optional named variants (e.g. hero: code-snippet | product-ui). */
+  variants?: string[];
+  /** Component file name within the section directory. Always "section.astro". */
+  componentFile: string;
+  /** Default props — MUST validate against the section's propsSchema. Used by
+   *  the init starter document and (M3) as a structured-output seed/example. */
+  defaultProps: unknown;
+}
+
+export interface RegistryEntry {
+  manifest: SectionManifest;
+  propsSchema: ZodTypeAny;
+  entrySchema: ZodTypeAny;
+}

package/dist/registry/sections/src/page.ts

@@ -0,0 +1,48 @@
+import { z, type ZodTypeAny } from "zod";
+
+export const primaryGoalSchema = z.enum([
+  "signup",
+  "github_star",
+  "docs",
+  "contact",
+  "waitlist",
+  "purchase",
+]);
+
+export const archetypeSchema = z.enum(["sdk-infra", "technical-app", "general"]);
+
+export const metaSchema = z.object({
+  title: z.string().min(1),
+  description: z.string().min(1),
+  locales: z.array(z.string().min(2)).min(1).default(["en"]),
+  primaryGoal: primaryGoalSchema.default("signup"),
+});
+
+export const themeSchema = z.object({
+  tokens: z
+    .object({
+      colorPrimary: z.string().min(1).default("#3A6463"),
+      radius: z.string().min(1).default("0.5rem"),
+      font: z.string().min(1).default("Inter"),
+    })
+    .default({}),
+});
+
+/**
+ * Assemble the full page-document schema from the per-section entry schemas.
+ * `entrySchemas` is the list of each section's `{ type, id, props }` object
+ * schema; their literal `type` discriminators form the section union.
+ */
+export function buildPageDocumentSchema(entrySchemas: [ZodTypeAny, ...ZodTypeAny[]]) {
+  const sectionUnion =
+    entrySchemas.length === 1
+      ? entrySchemas[0]
+      : // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        z.discriminatedUnion("type", entrySchemas as any);
+  return z.object({
+    meta: metaSchema,
+    theme: themeSchema.default({ tokens: {} }),
+    archetype: archetypeSchema.default("general"),
+    sections: z.array(sectionUnion).min(1),
+  });
+}

package/dist/registry/sections/src/registry.ts

@@ -0,0 +1,62 @@
+import { buildPageDocumentSchema } from "./page.js";
+import type { RegistryEntry, SectionType } from "./manifest.js";
+import * as hero from "../hero/schema.js";
+import * as header from "../header/schema.js";
+import * as footer from "../footer/schema.js";
+import * as features from "../features/schema.js";
+import * as codeDemo from "../codeDemo/schema.js";
+import * as pricing from "../pricing/schema.js";
+import * as finalCta from "../finalCta/schema.js";
+
+/**
+ * Each section module (registry/sections/<type>/schema.ts) exports
+ * `propsSchema`, `manifest`, and `entrySchema`. Section tasks append their
+ * module to this list — this is the single enumeration point (shadcn-style).
+ */
+export const sectionModules: RegistryEntry[] = [
+  { manifest: hero.manifest, propsSchema: hero.propsSchema, entrySchema: hero.entrySchema },
+  { manifest: header.manifest, propsSchema: header.propsSchema, entrySchema: header.entrySchema },
+  { manifest: footer.manifest, propsSchema: footer.propsSchema, entrySchema: footer.entrySchema },
+  {
+    manifest: features.manifest,
+    propsSchema: features.propsSchema,
+    entrySchema: features.entrySchema,
+  },
+  {
+    manifest: codeDemo.manifest,
+    propsSchema: codeDemo.propsSchema,
+    entrySchema: codeDemo.entrySchema,
+  },
+  {
+    manifest: pricing.manifest,
+    propsSchema: pricing.propsSchema,
+    entrySchema: pricing.entrySchema,
+  },
+  {
+    manifest: finalCta.manifest,
+    propsSchema: finalCta.propsSchema,
+    entrySchema: finalCta.entrySchema,
+  },
+];
+
+export const registry: Partial<Record<SectionType, RegistryEntry>> = Object.fromEntries(
+  sectionModules.map((m) => [m.manifest.type, m]),
+) as Partial<Record<SectionType, RegistryEntry>>;
+
+export function listSections(): RegistryEntry[] {
+  return [...sectionModules];
+}
+
+export function getSection(type: string): RegistryEntry | undefined {
+  return registry[type as SectionType];
+}
+
+const entrySchemas = sectionModules.map((m) => m.entrySchema);
+
+/** Full page-document schema, assembled from every registered section's entry
+ *  schema (the discriminated union over section `type`). */
+export const pageDocumentSchema = buildPageDocumentSchema(
+  entrySchemas as [(typeof entrySchemas)[number], ...typeof entrySchemas],
+);
+
+export type PageDocument = import("zod").infer<typeof pageDocumentSchema>;

package/dist/registry/sections/src/render-harness.ts

@@ -0,0 +1,11 @@
+import { experimental_AstroContainer as AstroContainer } from "astro/container";
+import type { AstroComponentFactory } from "astro/runtime/server/index.js";
+
+/** Render a section component to an HTML string with the given props. */
+export async function renderToHtml(
+  Component: AstroComponentFactory,
+  props: Record<string, unknown>,
+): Promise<string> {
+  const container = await AstroContainer.create();
+  return container.renderToString(Component, { props });
+}

package/dist/registry/sections/test/chrome.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import * as header from "../header/schema.js";
+import * as footer from "../footer/schema.js";
+import Header from "../header/section.astro";
+import Footer from "../footer/section.astro";
+import { renderToHtml } from "../src/render-harness.js";
+import { checkA11y } from "../src/a11y.js";
+
+describe("header", () => {
+  it("validates defaultProps", () => {
+    expect(header.propsSchema.safeParse(header.manifest.defaultProps).success).toBe(true);
+  });
+  it("renders a nav landmark and brand", async () => {
+    const html = await renderToHtml(Header, header.propsSchema.parse(header.manifest.defaultProps));
+    expect(html).toContain("Branchy");
+    expect(checkA11y(html, { landmarks: ["nav"], linksHaveText: true })).toEqual([]);
+  });
+});
+
+describe("footer", () => {
+  it("validates defaultProps", () => {
+    expect(footer.propsSchema.safeParse(footer.manifest.defaultProps).success).toBe(true);
+  });
+  it("renders a footer landmark and copyright", async () => {
+    const html = await renderToHtml(Footer, footer.propsSchema.parse(footer.manifest.defaultProps));
+    expect(html).toContain("Apache-2.0");
+    expect(checkA11y(html, { landmarks: ["footer"], linksHaveText: true })).toEqual([]);
+  });
+});

package/dist/registry/sections/test/codeDemo.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { propsSchema, manifest } from "../codeDemo/schema.js";
+import CodeDemo from "../codeDemo/section.astro";
+import { renderToHtml } from "../src/render-harness.js";
+
+describe("codeDemo", () => {
+  it("validates defaultProps", () => {
+    expect(propsSchema.safeParse(manifest.defaultProps).success).toBe(true);
+  });
+  it("renders a tab per snippet and highlights code (shiki <pre>)", async () => {
+    const html = await renderToHtml(CodeDemo, propsSchema.parse(manifest.defaultProps));
+    expect(html).toContain('role="tablist"');
+    expect((html.match(/role="tab"/g) ?? []).length).toBe(3);
+    expect(html).toContain("<pre");
+  });
+});

package/dist/registry/sections/test/features.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { propsSchema, manifest } from "../features/schema.js";
+import Features from "../features/section.astro";
+import { renderToHtml } from "../src/render-harness.js";
+
+describe("features", () => {
+  it("validates defaultProps and requires >=2 items", () => {
+    expect(propsSchema.safeParse(manifest.defaultProps).success).toBe(true);
+    expect(
+      propsSchema.safeParse({ heading: "H", items: [{ title: "x", body: "y" }] }).success,
+    ).toBe(false);
+  });
+  it("renders all feature titles", async () => {
+    const html = await renderToHtml(Features, propsSchema.parse(manifest.defaultProps));
+    expect(html).toContain("Branch per PR");
+    expect(html).toContain("1-second reset");
+  });
+});

package/dist/registry/sections/test/finalCta.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { propsSchema, manifest } from "../finalCta/schema.js";
+import FinalCta from "../finalCta/section.astro";
+import { renderToHtml } from "../src/render-harness.js";
+
+describe("finalCta", () => {
+  it("validates defaultProps", () => {
+    expect(propsSchema.safeParse(manifest.defaultProps).success).toBe(true);
+  });
+  it("renders headline and CTA", async () => {
+    const html = await renderToHtml(FinalCta, propsSchema.parse(manifest.defaultProps));
+    expect(html).toContain("Ship your first branch today");
+    expect(html).toContain("Start free");
+  });
+});

package/dist/registry/sections/test/hero.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { propsSchema, manifest, entrySchema } from "../hero/schema.js";
+import Hero from "../hero/section.astro";
+import { renderToHtml } from "../src/render-harness.js";
+import { checkA11y } from "../src/a11y.js";
+
+describe("hero schema", () => {
+  it("validates its own defaultProps", () => {
+    expect(propsSchema.safeParse(manifest.defaultProps).success).toBe(true);
+  });
+  it("requires at least one CTA", () => {
+    const bad = { ...(manifest.defaultProps as object), ctas: [] };
+    expect(propsSchema.safeParse(bad).success).toBe(false);
+  });
+  it("entrySchema pins the type literal", () => {
+    expect(
+      entrySchema.safeParse({ type: "header", id: "x", props: manifest.defaultProps }).success,
+    ).toBe(false);
+  });
+});
+
+describe("hero render", () => {
+  it("renders headline + CTA and passes basic a11y", async () => {
+    const props = propsSchema.parse(manifest.defaultProps);
+    const html = await renderToHtml(Hero, props);
+    expect(html).toContain("Postgres branching for teams");
+    expect(html).toContain("Start free");
+    expect(checkA11y(html, { linksHaveText: true, imagesHaveAlt: true })).toEqual([]);
+  });
+});

package/dist/registry/sections/test/page.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { metaSchema, themeSchema, archetypeSchema, buildPageDocumentSchema } from "../src/page.js";
+import { z } from "zod";
+
+describe("metaSchema", () => {
+  it("defaults locales and primaryGoal", () => {
+    const m = metaSchema.parse({ title: "T", description: "D" });
+    expect(m.locales).toEqual(["en"]);
+    expect(m.primaryGoal).toBe("signup");
+  });
+  it("rejects empty title", () => {
+    expect(metaSchema.safeParse({ title: "", description: "D" }).success).toBe(false);
+  });
+});
+
+describe("themeSchema", () => {
+  it("fills token defaults", () => {
+    const t = themeSchema.parse({ tokens: {} });
+    expect(t.tokens.radius).toBe("0.5rem");
+    expect(t.tokens.font).toBe("Inter");
+  });
+});
+
+describe("buildPageDocumentSchema", () => {
+  const entry = z.object({
+    type: z.literal("hero"),
+    id: z.string(),
+    props: z.object({ headline: z.string() }),
+  });
+  const doc = buildPageDocumentSchema([entry]);
+
+  it("accepts a valid one-section document", () => {
+    const r = doc.safeParse({
+      meta: { title: "T", description: "D" },
+      sections: [{ type: "hero", id: "h1", props: { headline: "Hi" } }],
+    });
+    expect(r.success).toBe(true);
+  });
+  it("rejects an empty sections array", () => {
+    const r = doc.safeParse({ meta: { title: "T", description: "D" }, sections: [] });
+    expect(r.success).toBe(false);
+  });
+  it("rejects an unknown section type", () => {
+    const r = doc.safeParse({
+      meta: { title: "T", description: "D" },
+      sections: [{ type: "nope", id: "x", props: {} }],
+    });
+    expect(r.success).toBe(false);
+  });
+});
+
+describe("archetypeSchema", () => {
+  it("accepts the three archetypes", () => {
+    for (const a of ["sdk-infra", "technical-app", "general"]) {
+      expect(archetypeSchema.safeParse(a).success).toBe(true);
+    }
+  });
+});