first commit

templates/blog/.agents/skills/building-emdash-site/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: building-emdash-site
+description: Build and customize EmDash CMS sites on Astro. Use when creating pages, defining collections, writing seed files, querying content, rendering Portable Text, setting up menus/taxonomies/widgets, configuring deployment, or any task involving an EmDash-powered Astro site. Assumes basic Astro knowledge but provides all EmDash-specific patterns.
+---
+
+# Building an EmDash Site
+
+EmDash is a CMS built on Astro. It stores schema in the database (not in code), serves content via live content collections, and provides a full admin UI at `/_emdash/admin`. Sites are standard Astro projects with the `emdash` integration.
+
+## Common Gotchas
+
+These are the things that silently break sites. Know them before you start.
+
+1. **Image fields are objects, not strings.** `post.data.featured_image` is `{ id, src, alt }`. Writing `<img src={post.data.featured_image} />` renders `[object Object]`. Use `<Image image={post.data.featured_image} />` from `"emdash/ui"`.
+
+2. **`entry.id` vs `entry.data.id` are different things.** `entry.id` is the slug (use in URLs). `entry.data.id` is the database ULID (use for `getEntryTerms`, `Comments`, and other API calls that need the real ID). Mixing them up causes silent empty results.
+
+3. **Taxonomy names must match the seed exactly.** If your seed defines `"name": "category"`, you must query `getTerm("category", slug)` -- not `"categories"`. Wrong name = empty results, no error.
+
+4. **Always pass `cacheHint` to `Astro.cache.set()`.** Every query returns a `cacheHint`. Call `Astro.cache.set(cacheHint)` on every page that queries content, or cache invalidation won't work when editors publish changes.
+
+5. **No `getStaticPaths` for CMS content.** EmDash content is dynamic. Pages must be server-rendered (`output: "server"` in `astro.config.mjs`).
+
+## File Structure
+
+Every EmDash site has these key files:
+
+```
+my-site/
+├── astro.config.mjs          # Astro config with emdash() integration
+├── src/
+│   ├── live.config.ts         # EmDash loader registration (boilerplate)
+│   ├── pages/                 # Astro pages (all server-rendered)
+│   ├── layouts/               # Layout components
+│   └── components/            # Reusable components
+├── seed/
+│   └── seed.json              # Schema + demo content
+├── emdash-env.d.ts          # Generated types (from `emdash types`)
+└── package.json
+```
+
+## Workflow
+
+### 1. Configure the project
+
+Read **[references/configuration.md](references/configuration.md)** for `astro.config.mjs`, `live.config.ts`, deployment targets (Node vs Cloudflare), and type generation.
+
+### 2. Design the schema
+
+Read **[references/schema-and-seed.md](references/schema-and-seed.md)** for collection definitions, field types, taxonomies, menus, widget areas, sections, bylines, and the complete seed file format.
+
+### 3. Build the pages
+
+Read **[references/querying-and-rendering.md](references/querying-and-rendering.md)** for content queries, Portable Text rendering, the Image component, visual editing attributes, caching, and common page patterns (list, detail, taxonomy archive, RSS, search, 404).
+
+### 4. Wire up site features
+
+Read **[references/site-features.md](references/site-features.md)** for site settings, navigation menus, taxonomies, widget areas, search, SEO meta, comments, and page contributions.
+
+### 5. Create the seed file
+
+Write `seed/seed.json` with collections, fields, taxonomies, menus, widgets, and sample content. Validate with:
+
+```bash
+npx emdash seed seed/seed.json --validate
+```
+
+### 6. Run and verify
+
+```bash
+npx emdash dev          # Start dev server (runs migrations + seeds, and generates types)
+```
+
+The admin UI is at `http://localhost:4321/_emdash/admin`.
+
+## Quick API Cheat Sheet
+
+```typescript
+// Content (entries have .data.byline and .data.bylines eagerly loaded)
+import { getEmDashCollection, getEmDashEntry } from "emdash";
+const { entries, nextCursor, cacheHint } = await getEmDashCollection("posts", {
+	limit: 10,
+	cursor,
+	orderBy: { published_at: "desc" },
+});
+const { entry: post, cacheHint } = await getEmDashEntry("posts", slug);
+
+// Site features
+import {
+	getSiteSettings,
+	getMenu,
+	getTaxonomyTerms,
+	getTerm,
+	getEntryTerms,
+	getEntriesByTerm,
+	getWidgetArea,
+	search,
+	getSection,
+	getSeoMeta,
+} from "emdash";
+
+// Bylines (standalone queries -- usually not needed since entries have bylines attached)
+import { getEntryBylines, getBylinesForEntries, getByline, getBylineBySlug } from "emdash";
+
+// UI components
+import {
+	PortableText,
+	Image,
+	Comments,
+	CommentForm,
+	WidgetArea,
+	EmDashHead,
+	EmDashBodyStart,
+	EmDashBodyEnd,
+} from "emdash/ui";
+import LiveSearch from "emdash/ui/search";
+
+// Page context (for plugin contributions)
+import { createPublicPageContext } from "emdash/page";
+```
+
+## Plugins
+
+EmDash supports plugins for extending the CMS with hooks, storage, settings, admin UI, API routes, and custom Portable Text block types. Consider a plugin when you need to:
+
+- React to content lifecycle events (e.g., send a notification on publish, sync to an external service)
+- Add custom admin pages or dashboard widgets
+- Add custom block types to the Portable Text editor (e.g., embedded maps, code playgrounds, CTAs)
+- Provide a reusable service (e.g., analytics, forms, comments via a third-party provider)
+
+Plugins are registered in `astro.config.mjs`:
+
+```javascript
+emdash({
+	database: sqlite({ url: "file:./data.db" }),
+	storage: local({ directory: "./uploads", baseUrl: "/_emdash/api/media/file" }),
+	plugins: [myPlugin()],
+}),
+```
+
+**To build a plugin, load the `creating-plugins` skill** (in `.agents/skills/creating-plugins/`). It covers plugin anatomy, hooks, storage, admin UI, API routes, Portable Text blocks, capabilities, and the full `definePlugin()` API.
+
+## Reference Documents
+
+| File                                                                         | Contents                                                            |
+| ---------------------------------------------------------------------------- | ------------------------------------------------------------------- |
+| [references/configuration.md](references/configuration.md)                   | Project setup, astro.config, live.config, deployment, types         |
+| [references/schema-and-seed.md](references/schema-and-seed.md)               | Collections, fields, taxonomies, menus, widgets, seed format        |
+| [references/querying-and-rendering.md](references/querying-and-rendering.md) | Content APIs, PortableText, Image, caching, page patterns           |
+| [references/site-features.md](references/site-features.md)                   | Settings, menus, widgets, search, SEO, comments, page contributions |

templates/blog/.agents/skills/building-emdash-site/references/configuration.md

@@ -0,0 +1,193 @@
+# Configuration
+
+## astro.config.mjs
+
+### Node.js (local development / self-hosted)
+
+```javascript
+import node from "@astrojs/node";
+import react from "@astrojs/react";
+import { defineConfig } from "astro/config";
+import emdash, { local } from "emdash/astro";
+import { sqlite } from "emdash/db";
+
+export default defineConfig({
+	output: "server",
+	adapter: node({ mode: "standalone" }),
+	image: {
+		layout: "constrained",
+		responsiveStyles: true,
+	},
+	integrations: [
+		react(),
+		emdash({
+			database: sqlite({ url: "file:./data.db" }),
+			storage: local({
+				directory: "./uploads",
+				baseUrl: "/_emdash/api/media/file",
+			}),
+		}),
+	],
+	devToolbar: { enabled: false },
+});
+```
+
+### Cloudflare (D1 + R2)
+
+```javascript
+import cloudflare from "@astrojs/cloudflare";
+import react from "@astrojs/react";
+import { d1, r2 } from "@emdashcms/cloudflare";
+import { defineConfig } from "astro/config";
+import emdash from "emdash/astro";
+
+export default defineConfig({
+	output: "server",
+	adapter: cloudflare(),
+	image: {
+		layout: "constrained",
+		responsiveStyles: true,
+	},
+	integrations: [
+		react(),
+		emdash({
+			database: d1({ binding: "DB", session: "auto" }),
+			storage: r2({ binding: "MEDIA" }),
+		}),
+	],
+	devToolbar: { enabled: false },
+});
+```
+
+Requires a `wrangler.jsonc` with D1 and R2 bindings:
+
+```jsonc
+{
+	"name": "my-site",
+	"compatibility_date": "2026-02-24",
+	"compatibility_flags": ["nodejs_compat"],
+	"assets": { "directory": "./dist" },
+	"d1_databases": [
+		{
+			"binding": "DB",
+			"database_name": "my-site",
+			"database_id": "", // from `wrangler d1 create my-site`
+		},
+	],
+	"r2_buckets": [
+		{
+			"binding": "MEDIA",
+			"bucket_name": "my-site-media",
+		},
+	],
+}
+```
+
+### Plugins
+
+Register plugins in `astro.config.mjs`:
+
+```javascript
+import { auditLogPlugin } from "@emdashcms/plugin-audit-log";
+
+emdash({
+	database: sqlite({ url: "file:./data.db" }),
+	storage: local({ directory: "./uploads", baseUrl: "/_emdash/api/media/file" }),
+	plugins: [auditLogPlugin()],
+}),
+```
+
+## live.config.ts
+
+Every EmDash site needs this file at `src/live.config.ts`. It's boilerplate -- the same in every project:
+
+```typescript
+import { defineLiveCollection } from "astro:content";
+import { emdashLoader } from "emdash/runtime";
+
+export const collections = {
+	_emdash: defineLiveCollection({ loader: emdashLoader() }),
+};
+```
+
+This registers EmDash's live content collections with Astro. All content types are served through the single `_emdash` collection -- you query specific types using `getEmDashCollection("posts")` etc.
+
+## emdash-env.d.ts
+
+Auto-generated at the project root when the dev server starts. Provides TypeScript types for your collections. This is the file your `tsconfig.json` includes.
+
+```typescript
+/// <reference types="emdash/locals" />
+
+import type { PortableTextBlock } from "emdash";
+
+export interface Post {
+	id: string;
+	slug: string | null;
+	status: string;
+	title: string;
+	featured_image?: {
+		id: string;
+		src?: string;
+		alt?: string;
+		width?: number;
+		height?: number;
+	};
+	content?: PortableTextBlock[];
+	excerpt?: string;
+	createdAt: Date;
+	updatedAt: Date;
+	publishedAt: Date | null;
+}
+
+declare module "emdash" {
+	interface EmDashCollections {
+		posts: Post;
+	}
+}
+```
+
+The dev server regenerates this file automatically when schema changes. You can also generate it manually:
+
+## Type Generation
+
+```bash
+# From local dev server (writes emdash-env.d.ts at project root)
+npx emdash types
+
+# From remote instance
+npx emdash types --url https://my-site.pages.dev
+
+# Custom output path
+npx emdash types --output src/types/cms.ts
+```
+
+The CLI also writes `.emdash/schema.json` with the raw schema for tooling.
+
+## package.json
+
+Key dependencies for a Node.js site:
+
+```json
+{
+	"dependencies": {
+		"astro": "^6.0.0",
+		"emdash": "workspace:*",
+		"@astrojs/node": "^9.0.0",
+		"@astrojs/react": "^4.0.0",
+		"react": "^18.0.0",
+		"react-dom": "^18.0.0"
+	}
+}
+```
+
+For Cloudflare, replace `@astrojs/node` with `@astrojs/cloudflare` and add `@emdashcms/cloudflare`.
+
+## Dev Server
+
+```bash
+npx emdash dev              # Start dev server (runs migrations, applies seed)
+npx emdash dev --types      # Start and generate types from schema
+```
+
+The admin UI is at `http://localhost:4321/_emdash/admin`. On first run, you'll go through setup to create an admin account.

templates/blog/.agents/skills/building-emdash-site/references/querying-and-rendering.md

@@ -0,0 +1,388 @@
+# Querying and Rendering Content
+
+## Content Queries
+
+All query functions are imported from `"emdash"`.
+
+### getEmDashCollection
+
+Fetch multiple entries from a collection. Returns `{ entries, error, cacheHint, nextCursor }`.
+
+```typescript
+import { getEmDashCollection } from "emdash";
+
+// Basic
+const { entries: posts } = await getEmDashCollection("posts");
+
+// With options
+const { entries: posts, cacheHint } = await getEmDashCollection("posts", {
+	status: "published",
+	limit: 10,
+	orderBy: { published_at: "desc" },
+	where: { category: "news" },
+});
+```
+
+Options:
+
+- `status` -- filter by status (`"published"`, `"draft"`, etc.)
+- `limit` -- max entries
+- `cursor` -- opaque cursor for keyset pagination (pass `nextCursor` from a previous result)
+- `orderBy` -- `{ field: "asc" | "desc" }` (default: `{ created_at: "desc" }`)
+- `where` -- filter by field values or taxonomy terms. Supports arrays for OR: `{ category: ["news", "featured"] }`
+- `locale` -- filter by locale (when i18n is configured)
+
+### getEmDashEntry
+
+Fetch a single entry by slug. Returns `{ entry, error, isPreview, cacheHint }`.
+
+```typescript
+import { getEmDashEntry } from "emdash";
+
+const { entry: post, cacheHint } = await getEmDashEntry("posts", slug);
+
+if (!post) {
+	return Astro.redirect("/404");
+}
+```
+
+### Entry Shape
+
+```typescript
+interface ContentEntry<T> {
+	id: string; // The slug (used in URLs)
+	data: T; // All fields, including system fields
+	edit: EditProxy; // Visual editing attributes (spread onto elements)
+}
+
+// data includes system fields plus your custom fields:
+interface PostData {
+	id: string; // Database ULID (use for taxonomy lookups, etc.)
+	slug: string;
+	status: string;
+	title: string;
+	featured_image?: {
+		id: string;
+		src?: string;
+		alt?: string;
+		width?: number;
+		height?: number;
+	};
+	content?: PortableTextBlock[];
+	createdAt: Date;
+	updatedAt: Date;
+	publishedAt: Date | null;
+	// Bylines (eagerly loaded)
+	byline: BylineSummary | null; // Primary author
+	bylines: ContentBylineCredit[]; // All credits (with roleLabel, source)
+	// ... your custom fields
+}
+```
+
+**Important:** `entry.id` is the slug (for URLs), `entry.data.id` is the database ULID (for API calls like `getEntryTerms`).
+
+### Caching
+
+Query results include a `cacheHint` for Astro's Route Caching:
+
+```astro
+---
+const { entries: posts, cacheHint } = await getEmDashCollection("posts");
+Astro.cache.set(cacheHint);
+---
+```
+
+Always call `Astro.cache.set(cacheHint)` -- it enables automatic cache invalidation when content changes.
+
+## Rendering Portable Text
+
+### PortableText component
+
+```astro
+---
+import { PortableText } from "emdash/ui";
+---
+<PortableText value={post.data.content} />
+```
+
+Renders standard blocks (paragraphs, headings, lists, blockquotes, code blocks, images) and inline marks (bold, italic, code, strikethrough, links).
+
+### Custom block types
+
+For custom PT blocks (e.g., marketing components), pass a `components` prop:
+
+```astro
+---
+import { PortableText } from "emdash/ui";
+import Hero from "./blocks/Hero.astro";
+import Features from "./blocks/Features.astro";
+
+const customTypes = {
+	"marketing.hero": Hero,
+	"marketing.features": Features,
+};
+---
+<PortableText value={page.data.content} components={{ type: customTypes }} />
+```
+
+Each custom component receives the block data as props.
+
+## Image Component
+
+**Always use the EmDash Image component for CMS images.** Image fields are objects, not strings.
+
+```astro
+---
+import { Image } from "emdash/ui";
+---
+
+{/* Correct -- passes the image object */}
+<Image image={post.data.featured_image} />
+
+{/* Also works with explicit props */}
+{post.data.featured_image?.src && (
+	<img src={post.data.featured_image.src} alt={post.data.featured_image.alt || ""} />
+)}
+```
+
+**Common mistake:**
+
+```astro
+{/* WRONG -- image is an object, not a string */}
+<img src={post.data.featured_image} />
+```
+
+## Visual Editing Attributes
+
+Entries include `edit` attributes for inline editing. Spread them onto the element that displays the field:
+
+```astro
+<h1 {...post.edit.title}>{post.data.title}</h1>
+<p {...post.edit.excerpt}>{post.data.excerpt}</p>
+<div {...post.edit.featured_image}>
+	<Image image={post.data.featured_image} />
+</div>
+```
+
+When an admin is logged in and views the site, these attributes enable click-to-edit functionality.
+
+## Common Page Patterns
+
+### List page (e.g., `/posts/index.astro`)
+
+```astro
+---
+import { getEmDashCollection, getEntryTerms } from "emdash";
+import { Image } from "emdash/ui";
+import Base from "../../layouts/Base.astro";
+
+const { entries: posts, cacheHint } = await getEmDashCollection("posts", {
+	orderBy: { published_at: "desc" },
+});
+Astro.cache.set(cacheHint);
+
+const sortedPosts = posts.toSorted((a, b) => {
+	const dateA = a.data.publishedAt?.getTime() ?? 0;
+	const dateB = b.data.publishedAt?.getTime() ?? 0;
+	return dateB - dateA;
+});
+---
+<Base title="Posts">
+	{sortedPosts.map(post => (
+		<article>
+			{post.data.featured_image && <Image image={post.data.featured_image} />}
+			<a href={`/posts/${post.id}`}>{post.data.title}</a>
+			{post.data.excerpt && <p>{post.data.excerpt}</p>}
+		</article>
+	))}
+</Base>
+```
+
+### Detail page (e.g., `/posts/[slug].astro`)
+
+```astro
+---
+import { getEmDashEntry, getEntryTerms, getSeoMeta } from "emdash";
+import { Image, PortableText } from "emdash/ui";
+import Base from "../../layouts/Base.astro";
+
+const { slug } = Astro.params;
+if (!slug) return Astro.redirect("/404");
+
+const { entry: post, cacheHint } = await getEmDashEntry("posts", slug);
+if (!post) return Astro.redirect("/404");
+
+Astro.cache.set(cacheHint);
+
+const seo = getSeoMeta(post, {
+	siteTitle: "My Blog",
+	siteUrl: Astro.url.origin,
+	path: `/posts/${slug}`,
+});
+
+const tags = await getEntryTerms("posts", post.data.id, "tag");
+---
+<Base title={seo.title} description={seo.description}>
+	<article>
+		{post.data.featured_image && (
+			<div {...post.edit.featured_image}>
+				<Image image={post.data.featured_image} />
+			</div>
+		)}
+		<h1 {...post.edit.title}>{post.data.title}</h1>
+		<PortableText value={post.data.content} />
+		{tags.length > 0 && (
+			<div>
+				{tags.map(t => <a href={`/tag/${t.slug}`}>{t.label}</a>)}
+			</div>
+		)}
+	</article>
+</Base>
+```
+
+### Taxonomy archive (e.g., `/category/[slug].astro`)
+
+```astro
+---
+import { getTerm, getEmDashCollection } from "emdash";
+import Base from "../../layouts/Base.astro";
+
+const { slug } = Astro.params;
+const term = slug ? await getTerm("category", slug) : null;
+if (!term) return Astro.redirect("/404");
+
+const { entries: posts } = await getEmDashCollection("posts", {
+	where: { category: term.slug },
+	orderBy: { published_at: "desc" },
+});
+---
+<Base title={`${term.label} posts`}>
+	<h1>{term.label}</h1>
+	{posts.map(post => (
+		<a href={`/posts/${post.id}`}>{post.data.title}</a>
+	))}
+</Base>
+```
+
+### RSS feed (e.g., `/rss.xml.ts`)
+
+```typescript
+import type { APIRoute } from "astro";
+import { getEmDashCollection } from "emdash";
+
+const siteTitle = "My Site";
+
+export const GET: APIRoute = async ({ url }) => {
+	const siteUrl = url.origin;
+	const { entries: posts } = await getEmDashCollection("posts", {
+		orderBy: { published_at: "desc" },
+		limit: 20,
+	});
+
+	const items = posts
+		.filter((p) => p.data.publishedAt)
+		.map((post) => {
+			const postUrl = `${siteUrl}/posts/${post.id}`;
+			return `    <item>
+      <title>${escapeXml(post.data.title)}</title>
+      <link>${postUrl}</link>
+      <guid isPermaLink="true">${postUrl}</guid>
+      <pubDate>${post.data.publishedAt!.toUTCString()}</pubDate>
+      <description>${escapeXml(post.data.excerpt || "")}</description>
+    </item>`;
+		})
+		.join("\n");
+
+	return new Response(
+		`<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${escapeXml(siteTitle)}</title>
+    <link>${siteUrl}</link>
+    <atom:link href="${siteUrl}/rss.xml" rel="self" type="application/rss+xml"/>
+    <language>en-us</language>
+    <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>
+${items}
+  </channel>
+</rss>`,
+		{
+			headers: {
+				"Content-Type": "application/rss+xml; charset=utf-8",
+				"Cache-Control": "public, max-age=3600",
+			},
+		},
+	);
+};
+
+function escapeXml(s: string): string {
+	return s
+		.replace(/&/g, "&amp;")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;")
+		.replace(/'/g, "&apos;");
+}
+```
+
+### 404 page (`/404.astro`)
+
+```astro
+---
+import Base from "../layouts/Base.astro";
+---
+<Base title="Not Found">
+	<h1>Page not found</h1>
+	<p>The page you're looking for doesn't exist.</p>
+	<a href="/">Go home</a>
+</Base>
+```
+
+### Empty state
+
+When a collection has no content, show a helpful empty state:
+
+```astro
+{posts.length === 0 ? (
+	<section>
+		<h2>No posts yet</h2>
+		<p>Create your first post in the admin panel.</p>
+		<a href="/_emdash/admin/content/posts/new">Create a post</a>
+	</section>
+) : (
+	/* ... render posts ... */
+)}
+```
+
+## Pagination
+
+`getEmDashCollection` supports cursor-based keyset pagination. Pass `cursor` from a previous result's `nextCursor` to get the next page:
+
+```astro
+---
+const cursor = Astro.url.searchParams.get("cursor") ?? undefined;
+const { entries, nextCursor, cacheHint } = await getEmDashCollection("posts", {
+	limit: 10,
+	cursor,
+	orderBy: { published_at: "desc" },
+});
+Astro.cache.set(cacheHint);
+---
+{entries.map(post => (
+	<a href={`/posts/${post.id}`}>{post.data.title}</a>
+))}
+{nextCursor && <a href={`?cursor=${nextCursor}`}>Next page</a>}
+```
+
+`nextCursor` is `undefined` when there are no more results.
+
+## Date Formatting
+
+Dates come as `Date` objects. Use `toLocaleDateString` or `Intl.DateTimeFormat`:
+
+```typescript
+const formatted = post.data.publishedAt?.toLocaleDateString("en-US", {
+	year: "numeric",
+	month: "long",
+	day: "numeric",
+});
+```

templates/blog/.agents/skills/building-emdash-site/references/schema-and-seed.md

@@ -0,0 +1,469 @@
+# Schema and Seed Files
+
+The seed file (`seed/seed.json`) defines the site's entire schema and optional demo content. It's applied on first run or via `npx emdash seed seed/seed.json`.
+
+## Seed File Structure
+
+```json
+{
+	"$schema": "https://emdashcms.com/seed.schema.json",
+	"version": "1",
+	"meta": {
+		"name": "My Site",
+		"description": "A description of this site",
+		"author": "Author Name"
+	},
+	"settings": { ... },
+	"collections": [ ... ],
+	"taxonomies": [ ... ],
+	"menus": [ ... ],
+	"widgetAreas": [ ... ],
+	"sections": [ ... ],
+	"bylines": [ ... ],
+	"content": { ... }
+}
+```
+
+## Collections
+
+Collections define content types. Each collection becomes a database table (`ec_{slug}`).
+
+```json
+{
+	"slug": "posts",
+	"label": "Posts",
+	"labelSingular": "Post",
+	"supports": ["drafts", "revisions", "search", "seo"],
+	"commentsEnabled": true,
+	"fields": [ ... ]
+}
+```
+
+### Collection Supports
+
+| Support     | Description               |
+| ----------- | ------------------------- |
+| `drafts`    | Draft/published workflow  |
+| `revisions` | Revision history          |
+| `search`    | Full-text search indexing |
+| `seo`       | SEO meta fields in admin  |
+
+### Slug Rules
+
+- Lowercase alphanumeric + underscores: `/^[a-z][a-z0-9_]*$/`
+- Max 63 characters
+- Cannot conflict with reserved slugs
+
+## Field Types
+
+| Type           | Column type | Runtime shape                         | Notes                        |
+| -------------- | ----------- | ------------------------------------- | ---------------------------- |
+| `string`       | TEXT        | `string`                              | Single line text             |
+| `text`         | TEXT        | `string`                              | Multi-line text (textarea)   |
+| `number`       | REAL        | `number`                              | Floating point               |
+| `integer`      | INTEGER     | `number`                              | Whole numbers                |
+| `boolean`      | INTEGER     | `boolean`                             | Stored as 0/1                |
+| `datetime`     | TEXT        | `Date`                                | ISO 8601 string in DB        |
+| `image`        | TEXT        | `{ id, src?, alt?, width?, height? }` | **Object, not a string**     |
+| `reference`    | TEXT        | `string` (ID)                         | Reference to another entry   |
+| `portableText` | JSON        | `PortableTextBlock[]`                 | Rich text as structured JSON |
+| `json`         | JSON        | `any`                                 | Arbitrary JSON data          |
+
+### Field Definition
+
+```json
+{
+	"slug": "title",
+	"label": "Title",
+	"type": "string",
+	"required": true,
+	"searchable": true
+}
+```
+
+Fields can have:
+
+- `slug` (required) -- field identifier
+- `label` (required) -- display label in admin
+- `type` (required) -- one of the types above
+- `required` -- validation
+- `searchable` -- include in full-text search index
+
+### Common Field Patterns
+
+**Blog post:**
+
+```json
+"fields": [
+	{ "slug": "title", "label": "Title", "type": "string", "required": true, "searchable": true },
+	{ "slug": "featured_image", "label": "Featured Image", "type": "image" },
+	{ "slug": "content", "label": "Content", "type": "portableText", "searchable": true },
+	{ "slug": "excerpt", "label": "Excerpt", "type": "text" }
+]
+```
+
+**Portfolio project:**
+
+```json
+"fields": [
+	{ "slug": "title", "label": "Title", "type": "string", "required": true, "searchable": true },
+	{ "slug": "featured_image", "label": "Featured Image", "type": "image", "required": true },
+	{ "slug": "client", "label": "Client", "type": "string" },
+	{ "slug": "year", "label": "Year", "type": "string" },
+	{ "slug": "summary", "label": "Summary", "type": "text", "searchable": true },
+	{ "slug": "content", "label": "Content", "type": "portableText", "searchable": true },
+	{ "slug": "gallery", "label": "Gallery", "type": "json" },
+	{ "slug": "url", "label": "Project URL", "type": "string" }
+]
+```
+
+**Page (minimal):**
+
+```json
+"fields": [
+	{ "slug": "title", "label": "Title", "type": "string", "required": true, "searchable": true },
+	{ "slug": "content", "label": "Content", "type": "portableText", "searchable": true }
+]
+```
+
+## Taxonomies
+
+Taxonomies are tag/category systems attached to collections.
+
+```json
+{
+	"name": "category",
+	"label": "Categories",
+	"labelSingular": "Category",
+	"hierarchical": true,
+	"collections": ["posts"],
+	"terms": [
+		{ "slug": "development", "label": "Development" },
+		{ "slug": "design", "label": "Design" }
+	]
+}
+```
+
+- `hierarchical: true` -- tree structure (like WordPress categories)
+- `hierarchical: false` -- flat list (like WordPress tags)
+- `collections` -- which collections this taxonomy applies to
+- `terms` -- pre-defined terms to create
+
+## Menus
+
+Navigation menus, managed from the admin UI.
+
+```json
+{
+	"name": "primary",
+	"label": "Primary Navigation",
+	"items": [
+		{ "type": "custom", "label": "Home", "url": "/" },
+		{ "type": "custom", "label": "About", "url": "/pages/about" },
+		{ "type": "custom", "label": "Posts", "url": "/posts" }
+	]
+}
+```
+
+Menu item types:
+
+- `custom` -- arbitrary URL
+- Content references are resolved at render time
+
+## Widget Areas
+
+Named regions where editors can add configurable widgets.
+
+```json
+{
+	"name": "sidebar",
+	"label": "Sidebar",
+	"description": "Widget area displayed on single post pages",
+	"widgets": [
+		{
+			"type": "component",
+			"componentId": "core:search",
+			"title": "Search"
+		},
+		{
+			"type": "component",
+			"componentId": "core:categories",
+			"title": "Categories"
+		},
+		{
+			"type": "component",
+			"componentId": "core:tags",
+			"title": "Tags"
+		},
+		{
+			"type": "component",
+			"componentId": "core:recent-posts",
+			"title": "Recent Posts",
+			"settings": { "count": 5, "showDate": true }
+		},
+		{
+			"type": "component",
+			"componentId": "core:archives",
+			"title": "Archives",
+			"settings": { "type": "monthly", "limit": 6 }
+		},
+		{
+			"type": "content",
+			"title": "About",
+			"content": [
+				{
+					"_type": "block",
+					"style": "normal",
+					"children": [{ "_type": "span", "text": "Some rich text content." }]
+				}
+			]
+		}
+	]
+}
+```
+
+### Widget types
+
+| Type        | Description               | Key fields                |
+| ----------- | ------------------------- | ------------------------- |
+| `content`   | Rich text (Portable Text) | `content`                 |
+| `menu`      | Navigation menu           | `menuName`                |
+| `component` | Core or custom component  | `componentId`, `settings` |
+
+### Core widget components
+
+- `core:search` -- search form
+- `core:categories` -- category list with counts
+- `core:tags` -- tag cloud
+- `core:recent-posts` -- latest posts list
+- `core:archives` -- monthly archive links
+
+## Sections (Reusable Blocks)
+
+Reusable content blocks that editors can insert via `/section` slash command in the editor.
+
+```json
+{
+	"slug": "newsletter-signup",
+	"title": "Newsletter Signup",
+	"description": "A call-to-action block for newsletter subscriptions",
+	"keywords": ["newsletter", "subscribe", "email", "cta"],
+	"source": "theme",
+	"content": [
+		{
+			"_type": "block",
+			"style": "h3",
+			"children": [{ "_type": "span", "text": "Stay in the loop" }]
+		},
+		{
+			"_type": "block",
+			"style": "normal",
+			"children": [{ "_type": "span", "text": "Get notified when new posts are published." }]
+		}
+	]
+}
+```
+
+## Bylines
+
+Named author profiles, independent of user accounts.
+
+```json
+{
+	"id": "byline-editorial",
+	"slug": "emdash-editorial",
+	"displayName": "EmDash Editorial"
+}
+```
+
+Guest bylines:
+
+```json
+{
+	"id": "byline-guest",
+	"slug": "guest-contributor",
+	"displayName": "Guest Contributor",
+	"isGuest": true
+}
+```
+
+## Settings
+
+Site-wide settings:
+
+```json
+"settings": {
+	"title": "My Blog",
+	"tagline": "Thoughts on building for the web"
+}
+```
+
+Available keys: `title`, `tagline`, `logo`, `favicon`, `social`, `timezone`, `dateFormat`.
+
+## Content
+
+Sample content organized by collection slug:
+
+```json
+"content": {
+	"posts": [
+		{
+			"id": "post-1",
+			"slug": "hello-world",
+			"status": "published",
+			"data": {
+				"title": "Hello World",
+				"excerpt": "My first post.",
+				"featured_image": {
+					"$media": {
+						"url": "https://images.unsplash.com/photo-xxx?w=1200&h=800&fit=crop",
+						"alt": "Description of image",
+						"filename": "hello-world.jpg"
+					}
+				},
+				"content": [
+					{
+						"_type": "block",
+						"style": "normal",
+						"children": [{ "_type": "span", "text": "This is the body text." }]
+					}
+				]
+			},
+			"bylines": [
+				{ "byline": "byline-editorial" }
+			],
+			"taxonomies": {
+				"category": ["development"],
+				"tag": ["webdev", "opinion"]
+			}
+		}
+	],
+	"pages": [
+		{
+			"id": "about",
+			"slug": "about",
+			"status": "published",
+			"data": {
+				"title": "About",
+				"content": [
+					{
+						"_type": "block",
+						"style": "normal",
+						"children": [{ "_type": "span", "text": "About this site." }]
+					}
+				]
+			}
+		}
+	]
+}
+```
+
+### Media references in seed content
+
+Use `$media` for image fields -- EmDash downloads and stores the image:
+
+```json
+"featured_image": {
+	"$media": {
+		"url": "https://images.unsplash.com/photo-xxx?w=1200&h=800&fit=crop",
+		"alt": "Description",
+		"filename": "my-image.jpg"
+	}
+}
+```
+
+For external images without downloading:
+
+```json
+"featured_image": "https://images.unsplash.com/photo-xxx?w=1200"
+```
+
+### Reference fields in seed content
+
+Use `$ref:id` format to reference other entries:
+
+```json
+"author": "$ref:byline-editorial"
+```
+
+### Portable Text in seed content
+
+Content fields of type `portableText` are arrays of blocks:
+
+```json
+[
+	{
+		"_type": "block",
+		"style": "normal",
+		"children": [{ "_type": "span", "text": "A paragraph." }]
+	},
+	{
+		"_type": "block",
+		"style": "h2",
+		"children": [{ "_type": "span", "text": "A heading" }]
+	},
+	{
+		"_type": "block",
+		"style": "blockquote",
+		"children": [{ "_type": "span", "text": "A quote." }]
+	}
+]
+```
+
+Inline marks (bold, italic, links):
+
+```json
+{
+	"_type": "block",
+	"style": "normal",
+	"children": [
+		{ "_type": "span", "text": "This is " },
+		{ "_type": "span", "text": "bold", "marks": ["strong"] },
+		{ "_type": "span", "text": " and " },
+		{ "_type": "span", "text": "italic", "marks": ["em"] }
+	]
+}
+```
+
+Block styles: `normal`, `h1`-`h6`, `blockquote`.
+
+### Draft content
+
+Set `"status": "draft"` to create unpublished content:
+
+```json
+{
+	"id": "post-draft",
+	"slug": "work-in-progress",
+	"status": "draft",
+	"data": { ... }
+}
+```
+
+## Validation
+
+```bash
+npx emdash seed seed/seed.json --validate
+```
+
+Catches:
+
+- Image fields with raw URLs (should use `$media`)
+- Reference fields with raw IDs (should use `$ref:id`)
+- PortableText not an array or missing `_type`
+- Type mismatches (string vs number, etc.)
+
+## Applying Seeds
+
+```bash
+npx emdash seed seed/seed.json              # Apply with content
+npx emdash seed seed/seed.json --no-content  # Schema only (no sample content)
+```
+
+## Exporting Seeds
+
+```bash
+npx emdash export-seed                      # Schema only
+npx emdash export-seed --with-content       # Schema + all content
+npx emdash export-seed --with-content=posts,pages  # Specific collections
+```

templates/blog/.agents/skills/building-emdash-site/references/site-features.md

@@ -0,0 +1,495 @@
+# Site Features
+
+## Site Settings
+
+```typescript
+import { getSiteSettings, getSiteSetting } from "emdash";
+
+// All settings
+const settings = await getSiteSettings();
+settings.title; // "My Site"
+settings.tagline; // "A description"
+settings.logo?.url; // Resolved media URL
+settings.favicon?.url;
+
+// Single setting
+const title = await getSiteSetting("title");
+```
+
+Available keys: `title`, `tagline`, `logo`, `favicon`, `social`, `timezone`, `dateFormat`.
+
+Use these instead of hard-coding site name, logo, etc.
+
+## Navigation Menus
+
+```typescript
+import { getMenu, getMenus } from "emdash";
+
+// Fetch a named menu
+const menu = await getMenu("primary");
+
+// List all menus
+const menus = await getMenus();
+```
+
+### Rendering a menu
+
+```astro
+---
+import { getMenu } from "emdash";
+const primaryMenu = await getMenu("primary");
+---
+<nav>
+	{primaryMenu?.items.map(item => (
+		<a href={item.url} target={item.target}>{item.label}</a>
+	))}
+</nav>
+```
+
+### Nested menus (dropdowns)
+
+```astro
+{primaryMenu?.items.map(item => (
+	<li>
+		<a href={item.url}>{item.label}</a>
+		{item.children.length > 0 && (
+			<ul class="submenu">
+				{item.children.map(child => (
+					<li><a href={child.url}>{child.label}</a></li>
+				))}
+			</ul>
+		)}
+	</li>
+))}
+```
+
+### MenuItem shape
+
+```typescript
+interface MenuItem {
+	id: string;
+	label: string;
+	url: string; // Resolved URL
+	target?: string; // "_blank" etc.
+	children: MenuItem[];
+}
+```
+
+## Taxonomies
+
+```typescript
+import { getTaxonomyTerms, getTerm, getEntryTerms, getEntriesByTerm } from "emdash";
+
+// All terms in a taxonomy (name must match your seed's "name" field exactly)
+const categories = await getTaxonomyTerms("category");
+const tags = await getTaxonomyTerms("tag");
+
+// Single term by slug
+const term = await getTerm("category", "news");
+// { id, name, slug, label, children, count }
+
+// Terms for a specific entry (use data.id, not entry.id!)
+const postCategories = await getEntryTerms("posts", post.data.id, "category");
+const postTags = await getEntryTerms("posts", post.data.id, "tag");
+
+// Entries with a specific term
+const newsPosts = await getEntriesByTerm("posts", "category", "news");
+```
+
+**Important:** The taxonomy name argument must match exactly what your seed defines in `"name"`. The blog seed uses `"category"` and `"tag"` (singular). Using `"categories"` returns empty results with no error.
+
+**Important:** `getEntryTerms` takes the database ULID (`post.data.id`), not the slug (`post.id`).
+
+### Displaying post terms
+
+```astro
+---
+const tags = await getEntryTerms("posts", post.data.id, "tag");
+---
+{tags.map(t => (
+	<a href={`/tag/${t.slug}`}>{t.label}</a>
+))}
+```
+
+### Filtering by taxonomy
+
+```astro
+---
+const { entries: posts } = await getEmDashCollection("posts", {
+	where: { category: term.slug },
+	orderBy: { published_at: "desc" },
+});
+---
+```
+
+## Widget Areas
+
+Render a named widget area:
+
+```astro
+---
+import { WidgetArea } from "emdash/ui";
+---
+<aside>
+	<WidgetArea name="sidebar" />
+</aside>
+```
+
+The `WidgetArea` component automatically renders all widgets in the area (search, categories, tags, recent posts, rich text, etc.) with appropriate HTML and CSS classes.
+
+### Manual widget rendering
+
+For more control, use the `getWidgetArea` function:
+
+```astro
+---
+import { getWidgetArea } from "emdash";
+import { PortableText } from "emdash/ui";
+
+const sidebar = await getWidgetArea("sidebar");
+---
+{sidebar?.widgets.map(widget => (
+	<div class="widget">
+		{widget.title && <h3>{widget.title}</h3>}
+		{widget.type === "content" && widget.content && (
+			<PortableText value={widget.content} />
+		)}
+	</div>
+))}
+```
+
+## Search
+
+### LiveSearch component (instant search)
+
+```astro
+---
+import LiveSearch from "emdash/ui/search";
+---
+<LiveSearch
+	placeholder="Search..."
+	collections={["posts", "pages"]}
+/>
+```
+
+Customizable CSS classes:
+
+```astro
+<LiveSearch
+	placeholder="Search..."
+	class="site-search"
+	inputClass="site-search-input"
+	resultsClass="site-search-results"
+	resultClass="site-search-result"
+	collections={["posts", "pages"]}
+	expandOnFocus={{ collapsed: "180px", expanded: "280px" }}
+/>
+```
+
+Theme via CSS variables:
+
+```css
+:root {
+	--emdash-search-bg: var(--color-bg);
+	--emdash-search-text: var(--color-text);
+	--emdash-search-muted: var(--color-muted);
+	--emdash-search-border: var(--color-border);
+	--emdash-search-hover: var(--color-surface);
+	--emdash-search-highlight: var(--color-text);
+}
+```
+
+### Programmatic search
+
+```typescript
+import { search } from "emdash";
+
+const results = await search("hello world", {
+	collections: ["posts", "pages"],
+	status: "published",
+	limit: 20,
+});
+// { results: SearchResult[], total, nextCursor? }
+```
+
+Each result has: `collection`, `id`, `title`, `slug`, `snippet` (HTML with `<mark>` highlights), `score`.
+
+### Search page
+
+```astro
+---
+import LiveSearch from "emdash/ui/search";
+import Base from "../layouts/Base.astro";
+
+const query = Astro.url.searchParams.get("q") || "";
+---
+<Base title="Search">
+	<h1>Search</h1>
+	<LiveSearch
+		placeholder="Search posts..."
+		collections={["posts", "pages"]}
+	/>
+</Base>
+```
+
+### Keyboard shortcut
+
+Add Cmd+K / Ctrl+K to focus search:
+
+```html
+<script>
+	document.addEventListener("keydown", (e) => {
+		if ((e.metaKey || e.ctrlKey) && e.key === "k") {
+			e.preventDefault();
+			document.querySelector(".site-search-input")?.focus();
+		}
+	});
+</script>
+```
+
+### Search prerequisites
+
+Search requires per-collection enablement:
+
+1. In admin: Edit Content Type -> check "Search" in Features
+2. Mark fields as `"searchable": true` in the seed file
+3. Only searchable fields of searchable collections are indexed
+
+## SEO Meta
+
+Generate SEO meta from content entries:
+
+```typescript
+import { getSeoMeta } from "emdash";
+
+const seo = getSeoMeta(post, {
+	siteTitle: "My Blog",
+	siteUrl: Astro.url.origin,
+	path: `/posts/${slug}`,
+	defaultOgImage: featuredImageUrl, // Optional fallback
+});
+
+// Returns: { title, description, canonical, ogImage, robots }
+```
+
+Use in your layout's `<head>`:
+
+```astro
+<title>{seo.title}</title>
+<meta name="description" content={seo.description} />
+<link rel="canonical" href={seo.canonical} />
+<meta property="og:image" content={seo.ogImage} />
+{seo.robots && <meta name="robots" content={seo.robots} />}
+```
+
+## Comments
+
+Built-in comments system:
+
+```astro
+---
+import { Comments, CommentForm } from "emdash/ui";
+---
+<Comments collection="posts" contentId={post.data.id} threaded />
+<CommentForm collection="posts" contentId={post.data.id} />
+```
+
+Comments are enabled per-collection in the seed: `"commentsEnabled": true`.
+
+## Page Contributions (Plugin Head/Body Injection)
+
+Plugins can inject content into the `<head>` and `<body>` of pages. To support this, use the page contribution components:
+
+```astro
+---
+import { EmDashHead, EmDashBodyStart, EmDashBodyEnd } from "emdash/ui";
+import { createPublicPageContext } from "emdash/page";
+
+const pageCtx = createPublicPageContext({
+	Astro,
+	kind: content ? "content" : "custom",
+	pageType: "article",
+	title: fullTitle,
+	description,
+	canonical,
+	image,
+	content: { collection: "posts", id: post.data.id, slug },
+});
+---
+<html>
+	<head>
+		<!-- your meta tags -->
+		<EmDashHead page={pageCtx} />
+	</head>
+	<body>
+		<EmDashBodyStart page={pageCtx} />
+		<!-- your content -->
+		<EmDashBodyEnd page={pageCtx} />
+	</body>
+</html>
+```
+
+This enables plugins (analytics, tracking pixels, structured data, etc.) to contribute to any page.
+
+## Bylines
+
+Bylines are author profiles, independent of user accounts. They support guest authors and multi-author attribution with role labels.
+
+### Eagerly loaded on entries
+
+Bylines are automatically attached to every entry by the query layer:
+
+```astro
+{/* Primary author */}
+{post.data.byline && (
+	<span>{post.data.byline.displayName}</span>
+)}
+
+{/* All credits (includes roleLabel for co-authors, guest essays, etc.) */}
+{post.data.bylines?.map(credit => (
+	<span>
+		{credit.byline.displayName}
+		{credit.roleLabel && <em> ({credit.roleLabel})</em>}
+	</span>
+))}
+```
+
+- `entry.data.byline` -- primary `BylineSummary` or `null`
+- `entry.data.bylines` -- array of `ContentBylineCredit` (each has `.byline`, `.roleLabel`, `.source`)
+
+### Standalone query functions
+
+```typescript
+import { getEntryBylines, getByline, getBylineBySlug, getBylinesForEntries } from "emdash";
+
+// Bylines for a single entry
+const credits = await getEntryBylines("posts", post.data.id);
+
+// Batch-fetch for a list page (avoids N+1)
+const ids = entries.map((e) => e.data.id);
+const bylinesMap = await getBylinesForEntries("posts", ids);
+// bylinesMap.get(entryId) => ContentBylineCredit[]
+
+// Look up a specific byline
+const byline = await getBylineBySlug("jane-doe");
+```
+
+### BylineSummary shape
+
+```typescript
+interface BylineSummary {
+	id: string;
+	slug: string;
+	displayName: string;
+	bio: string | null;
+	avatarMediaId: string | null;
+	websiteUrl: string | null;
+	isGuest: boolean;
+}
+```
+
+### ContentBylineCredit shape
+
+```typescript
+interface ContentBylineCredit {
+	byline: BylineSummary;
+	sortOrder: number;
+	roleLabel: string | null; // e.g., "Guest essay", "Photographer"
+	source?: "explicit" | "inferred"; // "inferred" = fallback from author_id
+}
+```
+
+## Dark Mode Pattern
+
+Cookie-based theme switching (no flash on load):
+
+```html
+<!-- In <head>, before styles load -->
+<script is:inline>
+	(function () {
+		var c = document.cookie;
+		var i = c.indexOf("theme=");
+		var theme = i >= 0 ? c.slice(i + 6).split(";")[0] : null;
+		if (theme === "dark" || theme === "light") {
+			document.documentElement.classList.add(theme);
+		} else if (window.matchMedia("(prefers-color-scheme: dark)").matches) {
+			document.documentElement.classList.add("dark");
+		}
+	})();
+</script>
+```
+
+Then use CSS variables that change based on `.dark` class:
+
+```css
+:root {
+	--color-bg: #ffffff;
+	--color-text: #1a1a1a;
+}
+:root.dark {
+	--color-bg: #0d0d0d;
+	--color-text: #ededed;
+}
+```
+
+## Layout Pattern
+
+A typical base layout:
+
+```astro
+---
+import { getMenu, getEmDashCollection } from "emdash";
+import { WidgetArea, EmDashHead, EmDashBodyStart, EmDashBodyEnd } from "emdash/ui";
+import { createPublicPageContext } from "emdash/page";
+import LiveSearch from "emdash/ui/search";
+
+interface Props {
+	title: string;
+	description?: string | null;
+	image?: string | null;
+	content?: { collection: string; id: string; slug?: string | null };
+}
+
+const { title, description, image, content } = Astro.props;
+const menu = await getMenu("primary");
+
+const pageCtx = createPublicPageContext({
+	Astro,
+	kind: content ? "content" : "custom",
+	pageType: "website",
+	title,
+	description,
+	image,
+	content,
+});
+---
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<title>{title}</title>
+		{description && <meta name="description" content={description} />}
+		<EmDashHead page={pageCtx} />
+	</head>
+	<body>
+		<EmDashBodyStart page={pageCtx} />
+		<header>
+			<nav>
+				<a href="/">My Site</a>
+				<LiveSearch placeholder="Search..." collections={["posts", "pages"]} />
+				{menu?.items.map(item => (
+					<a href={item.url}>{item.label}</a>
+				))}
+			</nav>
+		</header>
+		<main>
+			<slot />
+		</main>
+		<footer>
+			<WidgetArea name="footer" />
+		</footer>
+		<EmDashBodyEnd page={pageCtx} />
+	</body>
+</html>
+```

templates/blog/.agents/skills/creating-plugins/SKILL.md

@@ -0,0 +1,457 @@
+---
+name: creating-plugins
+description: Create EmDash CMS plugins with hooks, storage, settings, admin UI, API routes, and Portable Text block types. Use this skill when asked to build, scaffold, or implement an EmDash plugin, or when creating plugin features like custom block types, admin pages, or content hooks.
+---
+
+# Creating EmDash Plugins
+
+EmDash plugins extend the CMS with hooks, storage, settings, admin UI, API routes, and custom Portable Text block types. All plugins are TypeScript packages.
+
+## Plugin Types
+
+EmDash has two plugin formats:
+
+| Type         | Format                                                  | Admin UI           | Where it runs                               |
+| ------------ | ------------------------------------------------------- | ------------------ | ------------------------------------------- |
+| **Standard** | `definePlugin({ hooks, routes })`                       | Block Kit          | Isolate on Cloudflare, in-process elsewhere |
+| **Native**   | `createPlugin()` / `definePlugin()` with `id`+`version` | React or Block Kit | Always in host isolate                      |
+
+**Standard is the default.** Most plugins should use it. Standard plugins can be published to the marketplace and work in both trusted and sandboxed modes.
+
+**Native is an escape hatch** for plugins that need React admin components, direct DB access, or custom Astro components. Native plugins can only run in `plugins: []` -- they cannot be sandboxed or published to the marketplace.
+
+## Plugin Anatomy
+
+Every plugin has two parts that **run in different contexts**:
+
+1. **Plugin descriptor** (`PluginDescriptor`) — returned by the factory function in `index.ts`. Declares metadata (id, version, capabilities, storage). **Runs at build time in Vite** (imported in `astro.config.mjs`). Must be side-effect-free.
+2. **Plugin definition** (`definePlugin()`) — contains the runtime logic (hooks, routes). **Runs at request time on the deployed server.** Has access to the full plugin context (`ctx`). Lives in a separate file (typically `sandbox-entry.ts`).
+
+These must be in **separate entrypoints** because they execute in completely different environments:
+
+```
+my-plugin/
+├── src/
+│   ├── index.ts            # Descriptor factory (runs in Vite at build time)
+│   ├── sandbox-entry.ts    # Plugin definition with definePlugin() (runs at deploy time)
+│   ├── admin.tsx            # Admin UI exports (React) — optional, native only
+│   └── astro/               # Site-side rendering components — optional, native only
+│       └── index.ts         # Must export `blockComponents`
+├── package.json
+└── tsconfig.json
+```
+
+## Minimal Plugin (Standard Format)
+
+The simplest possible plugin -- just hooks:
+
+```typescript
+// src/index.ts — descriptor factory, runs in Vite at build time
+import type { PluginDescriptor } from "emdash";
+
+export function myPlugin(): PluginDescriptor {
+	return {
+		id: "my-plugin",
+		version: "1.0.0",
+		format: "standard",
+		entrypoint: "@my-org/my-plugin/sandbox",
+		options: {},
+	};
+}
+```
+
+```typescript
+// src/sandbox-entry.ts — plugin definition, runs at request time
+import { definePlugin } from "emdash";
+import type { PluginContext } from "emdash";
+
+export default definePlugin({
+	hooks: {
+		"content:afterSave": {
+			handler: async (event: any, ctx: PluginContext) => {
+				ctx.log.info(`Saved ${event.collection}/${event.content.id}`);
+			},
+		},
+	},
+});
+```
+
+The descriptor is what gets imported in `astro.config.mjs`. The `entrypoint` field points to the module containing the `definePlugin()` default export. For standard plugins, this is the `./sandbox` export from `package.json`.
+
+Key differences from native format:
+
+- No `id`, `version`, or `capabilities` in `definePlugin()` -- those live in the descriptor
+- `definePlugin()` is an identity function providing type inference
+- Hook handlers use `(event, ctx)` two-arg pattern
+- Route handlers use `(routeCtx, ctx)` two-arg pattern
+- Exported as `default` (not a factory function)
+
+## Plugin ID Rules
+
+- Lowercase alphanumeric + hyphens only
+- Simple (`my-plugin`) or scoped (`@my-org/my-plugin`)
+- Unique across all installed plugins
+
+## Registration
+
+The descriptor is imported in `astro.config.mjs` (Vite context):
+
+```typescript
+import { myPlugin } from "@my-org/my-plugin";
+
+export default defineConfig({
+	integrations: [
+		emdash({
+			plugins: [myPlugin()], // runs in-process
+			// OR
+			sandboxed: [myPlugin()], // runs in isolate on Cloudflare
+		}),
+	],
+});
+```
+
+Standard plugins work in either array. Native plugins only work in `plugins: []`.
+
+## Trusted vs Sandboxed Plugins
+
+EmDash has two execution modes. Plugin code is identical in both — only the enforcement changes.
+
+|                     | Trusted                                   | Sandboxed                                              |
+| ------------------- | ----------------------------------------- | ------------------------------------------------------ |
+| **Runs in**         | Main process                              | Isolated V8 isolate (Dynamic Worker Loader)            |
+| **Install method**  | `astro.config.mjs` (code change + deploy) | Admin UI (one-click from marketplace)                  |
+| **Capabilities**    | Advisory (not enforced)                   | Enforced at runtime via RPC bridge                     |
+| **Resource limits** | None                                      | CPU 50ms, 10 subrequests, 30s wall-time, ~128MB memory |
+| **Network access**  | Unrestricted                              | Blocked; only via `ctx.http` with `allowedHosts`       |
+| **Data access**     | Full database access                      | Scoped to declared capabilities                        |
+| **Node.js APIs**    | Full access                               | Not available (V8 isolate only)                        |
+| **Available on**    | All platforms                             | Cloudflare Workers only                                |
+| **Best for**        | First-party code, reviewed npm packages   | Third-party extensions, marketplace plugins            |
+
+### Trusted Mode
+
+Trusted plugins are npm packages or local files added in `astro.config.mjs`. They run in-process with your Astro site.
+
+- **Capabilities are documentation only.** Declaring `["read:content"]` documents intent but isn't enforced — the plugin has full process access.
+- Only install from sources you trust. A malicious trusted plugin has the same access as your application code.
+
+### Sandboxed Mode
+
+Sandboxed plugins run in isolated V8 isolates on Cloudflare Workers via [Dynamic Worker Loader](https://developers.cloudflare.com/workers/runtime-apis/bindings/worker-loader/). Each plugin gets its own isolate.
+
+- **Capabilities are enforced.** If a plugin declares `["read:content"]`, it can only call `ctx.content.get()` and `ctx.content.list()`. Attempting `ctx.content.create()` throws a permission error.
+- **Network is blocked by default.** Direct `fetch()` calls fail. Plugins must use `ctx.http.fetch()`, which validates against `allowedHosts`.
+- **Storage is scoped.** A plugin can only access its own KV and storage collections.
+- **Admin UI uses Block Kit.** Sandboxed plugins describe their UI as JSON blocks -- no plugin JavaScript runs in the browser. See [Block Kit reference](./references/block-kit.md).
+- **No Portable Text block types.** PT blocks require Astro components for site-side rendering (`componentsEntry`), which are loaded at build time from npm. Sandboxed plugins are installed at runtime and can't ship components. PT blocks are a native-plugin-only feature.
+- **Routes work.** Standard plugin routes are available in both trusted and sandboxed modes via the sandbox runner's `invokeRoute()` RPC.
+
+Sandboxing is not available on Node.js. All plugins run in trusted mode on non-Cloudflare platforms.
+
+### Developing for Both Modes
+
+Write the same code. Develop locally in trusted mode (faster iteration, easier debugging). Deploy to sandboxed mode in production without code changes. With the standard format, the same entrypoint serves both modes -- no separate sandbox entry needed.
+
+```typescript
+// src/sandbox-entry.ts -- works in both trusted and sandboxed modes
+import { definePlugin } from "emdash";
+import type { PluginContext } from "emdash";
+
+export default definePlugin({
+	hooks: {
+		"content:afterSave": {
+			handler: async (event: any, ctx: PluginContext) => {
+				// Trusted: ctx.http present because descriptor declares network:fetch
+				// Sandboxed: ctx.http present and enforced via RPC bridge
+				if (!ctx.http) return;
+				await ctx.http.fetch("https://api.analytics.example.com/track", {
+					method: "POST",
+					body: JSON.stringify({ contentId: event.content.id }),
+				});
+			},
+		},
+	},
+});
+```
+
+Key constraint for sandbox compatibility: **no Node.js built-ins** (`fs`, `path`, `child_process`, etc.) in backend code. Use Web APIs instead.
+
+## Capabilities
+
+Capabilities control what APIs are available on `ctx`. Always declare what your plugin needs — even in trusted mode, they document intent and are required for sandboxed execution.
+
+| Capability        | Grants                                                                 | `ctx` property |
+| ----------------- | ---------------------------------------------------------------------- | -------------- |
+| `read:content`    | `ctx.content.get()`, `ctx.content.list()`                              | `content`      |
+| `write:content`   | `ctx.content.create()`, `ctx.content.update()`, `ctx.content.delete()` | `content`      |
+| `read:media`      | `ctx.media.get()`, `ctx.media.list()`                                  | `media`        |
+| `write:media`     | `ctx.media.getUploadUrl()`, `ctx.media.delete()`                       | `media`        |
+| `network:fetch`   | `ctx.http.fetch()` (restricted to `allowedHosts`)                      | `http`         |
+| `read:users`      | `ctx.users.get()`, `ctx.users.list()`, `ctx.users.getByEmail()`        | `users`        |
+| `email:send`      | `ctx.email.send()` — send email through the pipeline                   | `email`        |
+| `email:provide`   | Can register `email:deliver` exclusive hook (transport provider)       | —              |
+| `email:intercept` | Can register `email:beforeSend` / `email:afterSend` hooks              | —              |
+
+Storage (`ctx.storage`) and KV (`ctx.kv`) are **always available** — no capability needed. They're automatically scoped to the plugin.
+
+**Email capabilities are distinct:**
+
+- `email:send` — for plugins that _consume_ email (call `ctx.email.send()`)
+- `email:provide` — for plugins that _deliver_ email (implement the transport, e.g. Resend, SMTP)
+- `email:intercept` — for plugins that _observe or transform_ email (middleware hooks)
+
+```typescript
+// In the descriptor (index.ts)
+export function myPlugin(): PluginDescriptor {
+	return {
+		id: "my-plugin",
+		version: "1.0.0",
+		format: "standard",
+		entrypoint: "@my-org/my-plugin/sandbox",
+		options: {},
+		capabilities: ["read:content", "network:fetch"],
+		allowedHosts: ["api.example.com", "*.googleapis.com"], // Wildcards supported
+	};
+}
+```
+
+When a marketplace plugin is installed, the admin sees a capability consent dialog listing what the plugin can access. Users must approve before installation.
+
+## Publishing to the Marketplace
+
+Standard plugins can be published to the EmDash Marketplace for one-click installation:
+
+```bash
+emdash plugin bundle --dir packages/plugins/my-plugin  # creates .tar.gz
+emdash plugin login                                      # authenticate via GitHub
+emdash plugin publish --tarball dist/my-plugin-1.0.0.tar.gz
+```
+
+See [Publishing Reference](./references/publishing.md) for bundle format, validation, and security audit details.
+
+## Package Exports
+
+Configure `package.json` exports so EmDash can load each entry point:
+
+```json
+{
+	"name": "@my-org/my-plugin",
+	"type": "module",
+	"exports": {
+		".": "./src/index.ts",
+		"./sandbox": "./src/sandbox-entry.ts",
+		"./admin": "./src/admin.tsx"
+	},
+	"peerDependencies": {
+		"emdash": "^0.1.0"
+	}
+}
+```
+
+| Export        | Context           | Purpose                                                                |
+| ------------- | ----------------- | ---------------------------------------------------------------------- |
+| `"."`         | Vite (build time) | Descriptor factory -- imported in `astro.config.mjs`                   |
+| `"./sandbox"` | Server (runtime)  | `definePlugin({ hooks, routes })` -- loaded by `entrypoint` at runtime |
+| `"./admin"`   | Browser           | React components for admin pages/widgets (native plugins only)         |
+| `"./astro"`   | Server (SSR)      | Astro components for site-side block rendering (native plugins only)   |
+
+The `"."` export has the descriptor. The `"./sandbox"` export has the implementation. The descriptor's `entrypoint` field points to `"./sandbox"`. Only include `./admin` and `./astro` exports for native-format plugins.
+
+## Plugin Features
+
+Each feature is optional. Add only what your plugin needs:
+
+| Feature             | Where                        | Standard | Native | Purpose                                                 |
+| ------------------- | ---------------------------- | -------- | ------ | ------------------------------------------------------- |
+| **Hooks**           | `definePlugin({ hooks })`    | Yes      | Yes    | React to content/media/lifecycle events                 |
+| **Storage**         | descriptor `storage`         | Yes      | Yes    | Document collections with indexed queries               |
+| **KV**              | `ctx.kv` in hooks/routes     | Yes      | Yes    | Key-value store for internal state                      |
+| **API Routes**      | `definePlugin({ routes })`   | Yes      | Yes    | REST endpoints at `/_emdash/api/plugins/<id>/<route>` |
+| **Admin Pages**     | Block Kit `admin` route      | Yes      | Yes    | Admin pages via Block Kit (JSON blocks)                 |
+| **Widgets**         | Block Kit `admin` route      | Yes      | Yes    | Dashboard cards via Block Kit                           |
+| **React Admin**     | `admin.entry` + React export | No       | Yes    | React-based admin pages and widgets (native only)       |
+| **PT Blocks**       | `admin.portableTextBlocks`   | No       | Yes    | Custom block types in the Portable Text editor          |
+| **Site Components** | `componentsEntry`            | No       | Yes    | Astro components for rendering blocks on the site       |
+
+See the reference files for detailed syntax:
+
+- **[Hooks Reference](./references/hooks.md)** — All hook types, signatures, configuration
+- **[Storage & Settings](./references/storage.md)** — Collections, KV, settings schema
+- **[Admin UI](./references/admin-ui.md)** — Pages, widgets, entry point structure
+- **[API Routes](./references/api-routes.md)** — Route handlers, validation, context
+- **[Block Kit](./references/block-kit.md)** — Declarative UI for sandboxed plugins (similar to Slack Block Kit but not identical)
+- **[Portable Text Blocks](./references/portable-text-blocks.md)** — Custom block types + frontend rendering
+- **[Publishing](./references/publishing.md)** — Bundle format, validation, marketplace publishing
+
+## Complete Example: Standard Plugin with Hooks, Routes, and Storage
+
+```typescript
+// src/index.ts — descriptor factory, runs in Vite at build time
+import type { PluginDescriptor } from "emdash";
+
+export function submissionsPlugin(): PluginDescriptor {
+	return {
+		id: "submissions",
+		version: "1.0.0",
+		format: "standard",
+		entrypoint: "@my-org/plugin-submissions/sandbox",
+		options: {},
+		capabilities: ["read:content"],
+		storage: {
+			submissions: {
+				indexes: ["formId", "status", "createdAt"],
+			},
+		},
+		adminPages: [{ path: "/submissions", label: "Submissions", icon: "list" }],
+		adminWidgets: [{ id: "recent-submissions", title: "Recent Submissions", size: "half" }],
+	};
+}
+```
+
+```typescript
+// src/sandbox-entry.ts — plugin definition, runs at request time
+import { definePlugin } from "emdash";
+import type { PluginContext } from "emdash";
+
+export default definePlugin({
+	hooks: {
+		"plugin:install": {
+			handler: async (_event: any, ctx: PluginContext) => {
+				ctx.log.info("Submissions plugin installed");
+				await ctx.kv.set("settings:maxSubmissions", 1000);
+			},
+		},
+	},
+
+	routes: {
+		submit: {
+			public: true, // No auth required
+			handler: async (routeCtx: any, ctx: PluginContext) => {
+				const { formId, ...data } = routeCtx.input as Record<string, unknown>;
+
+				const count = await ctx.storage.submissions.count({ formId });
+				const max = (await ctx.kv.get<number>("settings:maxSubmissions")) ?? 1000;
+
+				if (count >= max) {
+					return { success: false, error: "Submission limit reached" };
+				}
+
+				const id = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+				await ctx.storage.submissions.put(id, {
+					formId,
+					data,
+					status: "pending",
+					createdAt: new Date().toISOString(),
+				});
+
+				return { success: true, id };
+			},
+		},
+
+		list: {
+			handler: async (routeCtx: any, ctx: PluginContext) => {
+				const url = new URL(routeCtx.request.url);
+				const limit = Math.max(
+					1,
+					Math.min(parseInt(url.searchParams.get("limit") || "50", 10) || 50, 100),
+				);
+				const cursor = url.searchParams.get("cursor") || undefined;
+
+				const result = await ctx.storage.submissions.query({
+					orderBy: { createdAt: "desc" },
+					limit,
+					cursor,
+				});
+
+				return {
+					items: result.items.map((item: any) => ({ id: item.id, ...item.data })),
+					cursor: result.cursor,
+					hasMore: result.hasMore,
+				};
+			},
+		},
+
+		// Block Kit admin handler for pages and widgets
+		admin: {
+			handler: async (routeCtx: any, ctx: PluginContext) => {
+				const interaction = routeCtx.input as { type: string; page?: string };
+
+				if (interaction.type === "page_load" && interaction.page === "/submissions") {
+					const result = await ctx.storage.submissions.query({
+						orderBy: { createdAt: "desc" },
+						limit: 50,
+					});
+					return {
+						blocks: [
+							{ type: "header", text: "Submissions" },
+							{
+								type: "table",
+								blockId: "submissions-table",
+								columns: [
+									{ key: "formId", label: "Form", format: "text" },
+									{ key: "status", label: "Status", format: "badge" },
+									{ key: "createdAt", label: "Date", format: "relative_time" },
+								],
+								rows: result.items.map((item: any) => item.data),
+							},
+						],
+					};
+				}
+
+				return { blocks: [] };
+			},
+		},
+	},
+});
+```
+
+## Plugin Context
+
+All hooks and routes receive `ctx` (PluginContext):
+
+```typescript
+interface PluginContext {
+	plugin: { id: string; version: string };
+	storage: Record<string, StorageCollection>; // Declared collections
+	kv: KVAccess; // Key-value store
+	log: LogAccess; // Structured logger
+	content?: ContentAccess; // If "read:content" capability
+	media?: MediaAccess; // If "read:media" capability
+	http?: HttpAccess; // If "network:fetch" capability
+	users?: UserAccess; // If "read:users" capability
+	cron?: CronAccess; // Always available — scoped to plugin
+	email?: EmailAccess; // If "email:send" capability AND a provider is configured
+}
+```
+
+Capabilities are declared in the **descriptor** (not in `definePlugin()` for standard format):
+
+```typescript
+// In the descriptor
+export function myPlugin(): PluginDescriptor {
+	return {
+		id: "my-plugin",
+		version: "1.0.0",
+		format: "standard",
+		entrypoint: "@my-org/my-plugin/sandbox",
+		options: {},
+		capabilities: ["read:content", "network:fetch"],
+		allowedHosts: ["api.example.com"],
+		storage: { events: { indexes: ["timestamp"] } },
+	};
+}
+```
+
+## Output Checklist
+
+When creating a standard-format plugin, provide:
+
+1. **`src/index.ts`** -- Descriptor factory (runs in Vite at build time)
+2. **`src/sandbox-entry.ts`** -- `definePlugin({ hooks, routes })` as default export (runs at request time)
+3. **`package.json`** -- With exports `"."` (descriptor) and `"./sandbox"` (implementation)
+4. **`tsconfig.json`** -- Standard TypeScript config
+
+For native-format plugins (React admin, PT blocks, Astro components), also provide:
+
+5. **`src/admin.tsx`** -- Admin entry point with React components
+6. **`src/astro/index.ts`** -- Block components export (if PT blocks)

templates/blog/.agents/skills/creating-plugins/references/admin-ui.md

@@ -0,0 +1,191 @@
+# Admin UI
+
+Plugins extend the admin panel with React pages and dashboard widgets.
+
+## Entry Point
+
+Export pages and widgets from `src/admin.tsx`:
+
+```typescript
+// src/admin.tsx
+import { SettingsPage } from "./components/SettingsPage";
+import { ReportsPage } from "./components/ReportsPage";
+import { StatusWidget } from "./components/StatusWidget";
+
+// Pages keyed by path (must match admin.pages paths)
+export const pages = {
+	"/settings": SettingsPage,
+	"/reports": ReportsPage,
+};
+
+// Widgets keyed by ID (must match admin.widgets IDs)
+export const widgets = {
+	status: StatusWidget,
+};
+```
+
+Reference in plugin definition:
+
+```typescript
+definePlugin({
+	id: "my-plugin",
+	version: "1.0.0",
+
+	admin: {
+		entry: "@my-org/my-plugin/admin",
+		pages: [
+			{ path: "/settings", label: "Settings", icon: "settings" },
+			{ path: "/reports", label: "Reports", icon: "chart" },
+		],
+		widgets: [{ id: "status", title: "Status", size: "half" }],
+	},
+});
+```
+
+Pages mount at `/_emdash/admin/plugins/<plugin-id>/<path>`.
+
+## Pages
+
+React components. Use `usePluginAPI()` to call plugin routes.
+
+```typescript
+// src/components/SettingsPage.tsx
+import { useState, useEffect } from "react";
+import { usePluginAPI } from "@emdashcms/admin";
+
+export function SettingsPage() {
+	const api = usePluginAPI();
+	const [settings, setSettings] = useState<Record<string, unknown>>({});
+	const [saving, setSaving] = useState(false);
+
+	useEffect(() => {
+		api.get("settings").then(setSettings);
+	}, []);
+
+	const handleSave = async () => {
+		setSaving(true);
+		await api.post("settings/save", settings);
+		setSaving(false);
+	};
+
+	return (
+		<div>
+			<h1>Settings</h1>
+			<label>
+				Site Title
+				<input
+					type="text"
+					value={settings.siteTitle || ""}
+					onChange={(e) => setSettings({ ...settings, siteTitle: e.target.value })}
+				/>
+			</label>
+			<button onClick={handleSave} disabled={saving}>
+				{saving ? "Saving..." : "Save"}
+			</button>
+		</div>
+	);
+}
+```
+
+## Widgets
+
+Dashboard cards with at-a-glance info.
+
+```typescript
+// src/components/StatusWidget.tsx
+import { useState, useEffect } from "react";
+import { usePluginAPI } from "@emdashcms/admin";
+
+export function StatusWidget() {
+	const api = usePluginAPI();
+	const [data, setData] = useState({ count: 0 });
+
+	useEffect(() => {
+		api.get("status").then(setData);
+	}, []);
+
+	return (
+		<div className="widget-content">
+			<div className="score">{data.count}</div>
+		</div>
+	);
+}
+```
+
+### Widget Sizes
+
+| Size    | Width                |
+| ------- | -------------------- |
+| `full`  | Full dashboard width |
+| `half`  | Half width           |
+| `third` | One-third width      |
+
+## usePluginAPI()
+
+Auto-prefixes plugin ID to route URLs:
+
+```typescript
+const api = usePluginAPI();
+
+const data = await api.get("status"); // GET /.../plugins/<id>/status
+await api.post("settings/save", { enabled: true }); // POST with body
+const result = await api.get("history?limit=50"); // Query params
+```
+
+## Admin Components
+
+Pre-built components from `@emdashcms/admin`:
+
+```typescript
+import { Card, Button, Input, Select, Toggle, Table, Loading, Alert } from "@emdashcms/admin";
+```
+
+## Auto-Generated Settings
+
+If your plugin only needs settings, skip custom pages — use `settingsSchema` and EmDash generates the form:
+
+```typescript
+admin: {
+	settingsSchema: {
+		apiKey: { type: "secret", label: "API Key" },
+		enabled: { type: "boolean", label: "Enabled", default: true },
+	}
+}
+```
+
+## Build Configuration
+
+Admin components need a separate build entry:
+
+```typescript
+// tsdown.config.ts
+export default {
+	entry: {
+		index: "src/index.ts",
+		admin: "src/admin.tsx",
+	},
+	format: "esm",
+	dts: true,
+	external: ["react", "react-dom", "emdash", "@emdashcms/admin"],
+};
+```
+
+Keep React and `@emdashcms/admin` as externals to avoid bundling duplicates.
+
+## Plugin Descriptor
+
+The descriptor (returned by factory function) also declares admin metadata:
+
+```typescript
+export function myPlugin(options = {}): PluginDescriptor {
+	return {
+		id: "my-plugin",
+		entrypoint: "@my-org/my-plugin",
+		version: "1.0.0",
+		options,
+		adminEntry: "@my-org/my-plugin/admin",
+		adminPages: [{ path: "/settings", label: "Settings", icon: "settings" }],
+		adminWidgets: [{ id: "status", title: "Status", size: "half" }],
+	};
+}
+```

templates/blog/.agents/skills/creating-plugins/references/api-routes.md

@@ -0,0 +1,265 @@
+# API Routes
+
+Plugin routes work in both standard and native plugins, and in both trusted and sandboxed modes. Sandboxed plugin routes are invoked via the sandbox runner's `invokeRoute()` RPC.
+
+Plugin routes expose REST endpoints at `/_emdash/api/plugins/<plugin-id>/<route-name>`.
+
+## Defining Routes
+
+```typescript
+import { definePlugin } from "emdash";
+import { z } from "astro/zod";
+
+definePlugin({
+	id: "forms",
+	version: "1.0.0",
+
+	routes: {
+		// Simple route
+		status: {
+			handler: async (ctx) => {
+				return { ok: true };
+			},
+		},
+
+		// Route with input validation
+		submissions: {
+			input: z.object({
+				formId: z.string().optional(),
+				limit: z.number().default(50),
+				cursor: z.string().optional(),
+			}),
+			handler: async (ctx) => {
+				const { formId, limit, cursor } = ctx.input;
+				const result = await ctx.storage.submissions!.query({
+					where: formId ? { formId } : undefined,
+					orderBy: { createdAt: "desc" },
+					limit,
+					cursor,
+				});
+				return {
+					items: result.items,
+					cursor: result.cursor,
+					hasMore: result.hasMore,
+				};
+			},
+		},
+
+		// Nested path
+		"settings/save": {
+			input: z.object({
+				enabled: z.boolean().optional(),
+				apiKey: z.string().optional(),
+			}),
+			handler: async (ctx) => {
+				for (const [key, value] of Object.entries(ctx.input)) {
+					if (value !== undefined) {
+						await ctx.kv.set(`settings:${key}`, value);
+					}
+				}
+				return { success: true };
+			},
+		},
+	},
+});
+```
+
+## Route URLs
+
+| Plugin ID | Route Name      | URL                                        |
+| --------- | --------------- | ------------------------------------------ |
+| `forms`   | `status`        | `/_emdash/api/plugins/forms/status`      |
+| `forms`   | `submissions`   | `/_emdash/api/plugins/forms/submissions` |
+| `seo`     | `settings/save` | `/_emdash/api/plugins/seo/settings/save` |
+
+## Handler Context
+
+```typescript
+interface RouteContext<TInput = unknown> extends PluginContext {
+	input: TInput; // Validated input
+	request: Request; // Original request
+	plugin: { id: string; version: string };
+	storage: Record<string, StorageCollection>;
+	kv: KVAccess;
+	content?: ContentAccess; // If capability declared
+	media?: MediaAccess;
+	http?: HttpAccess;
+	log: LogAccess;
+}
+```
+
+## Input Validation
+
+Use Zod schemas. Invalid input returns 400.
+
+```typescript
+routes: {
+	create: {
+		input: z.object({
+			title: z.string().min(1).max(200),
+			email: z.string().email(),
+			priority: z.enum(["low", "medium", "high"]).default("medium"),
+			tags: z.array(z.string()).optional(),
+		}),
+		handler: async (ctx) => {
+			// ctx.input is typed and validated
+			const { title, email, priority } = ctx.input;
+			// ...
+		},
+	},
+}
+```
+
+Input sources:
+
+- **POST/PUT/PATCH** — Request body (JSON)
+- **GET/DELETE** — URL query parameters
+
+## Return Values
+
+Return any JSON-serializable value. Response is always `Content-Type: application/json`.
+
+```typescript
+return { success: true, data: items }; // Object
+return items; // Array
+return 42; // Primitive
+```
+
+## Errors
+
+Throw to return error response:
+
+```typescript
+throw new Error("Item not found"); // 500 with { error: "Item not found" }
+
+// Custom status code
+throw new Response(JSON.stringify({ error: "Not found" }), {
+	status: 404,
+	headers: { "Content-Type": "application/json" },
+});
+```
+
+## HTTP Methods
+
+Routes respond to all methods. Check `ctx.request.method`:
+
+```typescript
+handler: async (ctx) => {
+	switch (ctx.request.method) {
+		case "GET":
+			return await ctx.storage.items!.get(ctx.input.id);
+		case "DELETE":
+			await ctx.storage.items!.delete(ctx.input.id);
+			return { deleted: true };
+		default:
+			throw new Response("Method not allowed", { status: 405 });
+	}
+};
+```
+
+## Common Patterns
+
+### Settings CRUD
+
+```typescript
+routes: {
+	settings: {
+		handler: async (ctx) => {
+			const settings = await ctx.kv.list("settings:");
+			const result: Record<string, unknown> = {};
+			for (const entry of settings) {
+				result[entry.key.replace("settings:", "")] = entry.value;
+			}
+			return result;
+		},
+	},
+	"settings/save": {
+		handler: async (ctx) => {
+			const input = await ctx.request.json();
+			for (const [key, value] of Object.entries(input)) {
+				if (value !== undefined) await ctx.kv.set(`settings:${key}`, value);
+			}
+			return { success: true };
+		},
+	},
+}
+```
+
+### Paginated List
+
+```typescript
+routes: {
+	list: {
+		input: z.object({
+			limit: z.number().min(1).max(100).default(50),
+			cursor: z.string().optional(),
+			status: z.string().optional(),
+		}),
+		handler: async (ctx) => {
+			const { limit, cursor, status } = ctx.input;
+			const result = await ctx.storage.items!.query({
+				where: status ? { status } : undefined,
+				orderBy: { createdAt: "desc" },
+				limit,
+				cursor,
+			});
+			return {
+				items: result.items.map((item) => ({ id: item.id, ...item.data })),
+				cursor: result.cursor,
+				hasMore: result.hasMore,
+			};
+		},
+	},
+}
+```
+
+### External API Proxy
+
+Requires `network:fetch` capability and `allowedHosts`:
+
+```typescript
+definePlugin({
+	capabilities: ["network:fetch"],
+	allowedHosts: ["api.weather.example.com"],
+
+	routes: {
+		forecast: {
+			input: z.object({ city: z.string() }),
+			handler: async (ctx) => {
+				const apiKey = await ctx.kv.get<string>("settings:apiKey");
+				if (!apiKey) throw new Error("API key not configured");
+
+				const response = await ctx.http!.fetch(
+					`https://api.weather.example.com/forecast?city=${ctx.input.city}`,
+					{ headers: { "X-API-Key": apiKey } },
+				);
+
+				if (!response.ok) throw new Error(`API error: ${response.status}`);
+				return response.json();
+			},
+		},
+	},
+});
+```
+
+## Calling from Admin UI
+
+```typescript
+import { usePluginAPI } from "@emdashcms/admin";
+
+const api = usePluginAPI();
+const data = await api.get("status");
+await api.post("settings/save", { enabled: true });
+```
+
+## Calling Externally
+
+```bash
+curl https://your-site.com/_emdash/api/plugins/forms/submissions?limit=10
+
+curl -X POST https://your-site.com/_emdash/api/plugins/forms/create \
+  -H "Content-Type: application/json" \
+  -d '{"title": "Hello"}'
+```
+
+Plugin routes don't have built-in auth. Admin-only routes are protected by the admin session middleware.

templates/blog/.agents/skills/creating-plugins/references/block-kit.md

@@ -0,0 +1,415 @@
+# Block Kit
+
+Declarative JSON UI for sandboxed plugin admin pages. The host renders blocks — no plugin JavaScript runs in the browser. Inspired by Slack's Block Kit but not identical — similar concepts and naming, different block/element types and capabilities.
+
+Trusted plugins (declared in `astro.config.ts`) can ship custom React components instead. Block Kit is for runtime-installed sandboxed plugins.
+
+Block Kit elements are also used for [Portable Text block editing fields](./portable-text-blocks.md). When a plugin declares `fields` on a block type, the editor renders a Block Kit form.
+
+## How It Works
+
+1. User navigates to plugin admin page
+2. Admin sends `page_load` interaction to plugin's admin route
+3. Plugin returns `BlockResponse` with array of blocks
+4. Admin renders blocks using `BlockRenderer`
+5. User interacts (button click, form submit) → interaction sent back
+6. Plugin returns new blocks
+
+```typescript
+routes: {
+	admin: {
+		handler: async (ctx) => {
+			const interaction = await ctx.request.json();
+
+			if (interaction.type === "page_load") {
+				return {
+					blocks: [
+						{ type: "header", text: "My Plugin Settings" },
+						{
+							type: "form",
+							block_id: "settings",
+							fields: [
+								{ type: "text_input", action_id: "api_url", label: "API URL" },
+								{ type: "toggle", action_id: "enabled", label: "Enabled", initial_value: true },
+							],
+							submit: { label: "Save", action_id: "save" },
+						},
+					],
+				};
+			}
+
+			if (interaction.type === "form_submit" && interaction.action_id === "save") {
+				await ctx.kv.set("settings", interaction.values);
+				return {
+					blocks: [/* updated blocks */],
+					toast: { message: "Settings saved", type: "success" },
+				};
+			}
+		},
+	},
+}
+```
+
+## Block Types
+
+| Type      | Description                                         |
+| --------- | --------------------------------------------------- |
+| `header`  | Large bold heading                                  |
+| `section` | Text with optional accessory element                |
+| `divider` | Horizontal rule                                     |
+| `fields`  | Two-column label/value grid                         |
+| `table`   | Data table with formatting, sorting, pagination     |
+| `actions` | Horizontal row of buttons and controls              |
+| `stats`   | Dashboard metric cards with trend indicators        |
+| `form`    | Input fields with conditional visibility and submit |
+| `image`   | Block-level image with caption                      |
+| `context` | Small muted help text                               |
+| `columns` | 2-3 column layout with nested blocks                |
+| `chart`   | Charts (timeseries line/bar, pie, custom ECharts)   |
+| `code`    | Syntax-highlighted code block                       |
+| `meter`   | Progress/quota meter bar                            |
+| `banner`  | Info, warning, or error inline messages             |
+
+## Element Types
+
+| Type           | Description                                     |
+| -------------- | ----------------------------------------------- |
+| `button`       | Action button with optional confirmation dialog |
+| `text_input`   | Single-line or multiline text input             |
+| `number_input` | Numeric input with min/max                      |
+| `select`       | Dropdown select                                 |
+| `toggle`       | On/off switch                                   |
+| `secret_input` | Masked input for API keys and tokens            |
+| `checkbox`     | Multi-select checkboxes                         |
+| `radio`        | Single-select radio buttons                     |
+| `date_input`   | Date picker                                     |
+| `combobox`     | Searchable dropdown select                      |
+
+## Block Syntax
+
+### Header
+
+```json
+{ "type": "header", "text": "Settings" }
+```
+
+### Section
+
+```json
+{
+	"type": "section",
+	"text": "Configure your plugin settings below.",
+	"accessory": { "type": "button", "text": "Refresh", "action_id": "refresh" }
+}
+```
+
+### Divider
+
+```json
+{ "type": "divider" }
+```
+
+### Fields
+
+```json
+{
+	"type": "fields",
+	"fields": [
+		{ "label": "Status", "value": "Active" },
+		{ "label": "Last Sync", "value": "2 hours ago" }
+	]
+}
+```
+
+### Stats
+
+```json
+{
+	"type": "stats",
+	"stats": [
+		{ "label": "Total", "value": "1,234", "trend": "+12%", "trend_direction": "up" },
+		{ "label": "Active", "value": "567" }
+	]
+}
+```
+
+### Table
+
+```json
+{
+	"type": "table",
+	"columns": [
+		{ "key": "name", "label": "Name" },
+		{ "key": "status", "label": "Status" },
+		{ "key": "date", "label": "Date" }
+	],
+	"rows": [{ "name": "Item 1", "status": "Active", "date": "2025-01-01" }]
+}
+```
+
+### Actions
+
+```json
+{
+	"type": "actions",
+	"elements": [
+		{ "type": "button", "text": "Save", "action_id": "save", "style": "primary" },
+		{ "type": "button", "text": "Cancel", "action_id": "cancel" }
+	]
+}
+```
+
+### Form
+
+```json
+{
+	"type": "form",
+	"block_id": "settings",
+	"fields": [
+		{ "type": "text_input", "action_id": "name", "label": "Name" },
+		{ "type": "number_input", "action_id": "count", "label": "Count", "min": 0, "max": 100 },
+		{
+			"type": "select",
+			"action_id": "theme",
+			"label": "Theme",
+			"options": [
+				{ "label": "Light", "value": "light" },
+				{ "label": "Dark", "value": "dark" }
+			]
+		},
+		{ "type": "toggle", "action_id": "enabled", "label": "Enabled", "initial_value": true },
+		{ "type": "secret_input", "action_id": "api_key", "label": "API Key" }
+	],
+	"submit": { "label": "Save", "action_id": "save_settings" }
+}
+```
+
+### Columns
+
+```json
+{
+	"type": "columns",
+	"columns": [
+		{ "blocks": [{ "type": "header", "text": "Left" }] },
+		{ "blocks": [{ "type": "header", "text": "Right" }] }
+	]
+}
+```
+
+### Chart (Timeseries)
+
+```json
+{
+	"type": "chart",
+	"config": {
+		"chart_type": "timeseries",
+		"series": [
+			{
+				"name": "Requests",
+				"data": [
+					[1709596800000, 42],
+					[1709600400000, 67],
+					[1709604000000, 53]
+				],
+				"color": "#086FFF"
+			},
+			{
+				"name": "Errors",
+				"data": [
+					[1709596800000, 2],
+					[1709600400000, 5],
+					[1709604000000, 1]
+				]
+			}
+		],
+		"x_axis_name": "Time",
+		"y_axis_name": "Count",
+		"style": "line",
+		"gradient": true,
+		"height": 300
+	}
+}
+```
+
+- `series[].data` — array of `[timestamp_ms, value]` tuples
+- `series[].color` — hex color (optional, auto-assigned from Kumo palette)
+- `style` — `"line"` (default) or `"bar"`
+- `gradient` — fill gradient beneath lines (default false)
+- `height` — chart height in pixels (default 350)
+
+### Chart (Custom)
+
+For pie charts, gauges, or any ECharts visualization:
+
+```json
+{
+	"type": "chart",
+	"config": {
+		"chart_type": "custom",
+		"options": {
+			"series": [
+				{
+					"type": "pie",
+					"data": [
+						{ "value": 335, "name": "Published" },
+						{ "value": 234, "name": "Draft" },
+						{ "value": 120, "name": "Scheduled" }
+					]
+				}
+			]
+		},
+		"height": 300
+	}
+}
+```
+
+- `options` — raw ECharts option object passed through to `chart.setOption()`
+
+### Code
+
+```json
+{
+	"type": "code",
+	"code": "const greeting = \"Hello!\";\nconsole.log(greeting);",
+	"language": "ts"
+}
+```
+
+- `language` — `"ts"`, `"tsx"`, `"jsonc"`, `"bash"`, or `"css"` (defaults to `"ts"`)
+
+### Meter
+
+```json
+{
+	"type": "meter",
+	"label": "Storage used",
+	"value": 65,
+	"custom_value": "6.5 GB / 10 GB"
+}
+```
+
+- `value` — numeric value (default range 0-100)
+- `max` / `min` — custom range (defaults to 0-100)
+- `custom_value` — display string instead of percentage (e.g. "750 / 1,000")
+
+### Banner
+
+```json
+{
+	"type": "banner",
+	"title": "API key invalid",
+	"description": "Please check your API key in settings.",
+	"variant": "error"
+}
+```
+
+- `variant` — `"default"` (info, default), `"alert"` (warning), or `"error"`
+- At least one of `title` or `description` is required
+
+## Conditional Fields
+
+Show/hide fields based on other field values. Evaluated client-side, no round-trip.
+
+```json
+{
+	"type": "toggle",
+	"action_id": "auth_enabled",
+	"label": "Enable Authentication"
+}
+```
+
+```json
+{
+	"type": "secret_input",
+	"action_id": "api_key",
+	"label": "API Key",
+	"condition": { "field": "auth_enabled", "eq": true }
+}
+```
+
+## Builder Helpers
+
+`@emdashcms/blocks` provides TypeScript helpers:
+
+```typescript
+import { blocks, elements } from "@emdashcms/blocks";
+
+const { header, form, section, stats, timeseriesChart, customChart, banner: bannerBlock } = blocks;
+const { textInput, toggle, select, button } = elements;
+
+return {
+	blocks: [
+		header("Settings"),
+		form({
+			blockId: "settings",
+			fields: [
+				textInput("site_title", "Site Title", { initialValue: "My Site" }),
+				toggle("generate_sitemap", "Generate Sitemap", { initialValue: true }),
+				select("robots", "Default Robots", [
+					{ label: "Index, Follow", value: "index,follow" },
+					{ label: "No Index", value: "noindex,follow" },
+				]),
+			],
+			submit: { label: "Save", actionId: "save" },
+		}),
+		// Timeseries chart
+		timeseriesChart({
+			series: [
+				{
+					name: "Page Views",
+					data: [
+						[Date.now() - 3600000, 100],
+						[Date.now(), 150],
+					],
+				},
+			],
+			yAxisName: "Views",
+			gradient: true,
+		}),
+		// Pie chart via custom ECharts options
+		customChart({
+			options: {
+				series: [
+					{
+						type: "pie",
+						data: [
+							{ value: 335, name: "Published" },
+							{ value: 234, name: "Draft" },
+						],
+					},
+				],
+			},
+		}),
+	],
+};
+```
+
+## Button Confirmations
+
+```json
+{
+	"type": "button",
+	"text": "Delete All",
+	"action_id": "delete_all",
+	"style": "danger",
+	"confirm": {
+		"title": "Are you sure?",
+		"text": "This cannot be undone.",
+		"confirm": "Delete",
+		"deny": "Cancel"
+	}
+}
+```
+
+## Toast Responses
+
+Return a `toast` alongside blocks to show a notification:
+
+```typescript
+return {
+	blocks: [
+		/* ... */
+	],
+	toast: { message: "Settings saved", type: "success" }, // "success" | "error" | "info"
+};
+```

templates/blog/.agents/skills/creating-plugins/references/hooks.md

@@ -0,0 +1,412 @@
+# Hooks Reference
+
+Hooks let plugins run code in response to events. Declared in `definePlugin({ hooks })`.
+
+## Signature
+
+```typescript
+async (event: EventType, ctx: PluginContext) => ReturnType;
+```
+
+## Configuration
+
+Simple handler or full config:
+
+```typescript
+// Simple
+hooks: {
+	"content:afterSave": async (event, ctx) => {
+		ctx.log.info("Saved");
+	}
+}
+
+// Full config
+hooks: {
+	"content:afterSave": {
+		priority: 100,      // Lower runs first (default: 100)
+		timeout: 5000,      // Max execution time ms (default: 5000)
+		dependencies: [],   // Plugin IDs that must run first
+		errorPolicy: "abort", // "abort" | "continue"
+		handler: async (event, ctx) => {
+			ctx.log.info("Saved");
+		}
+	}
+}
+```
+
+## Lifecycle Hooks
+
+### `plugin:install`
+
+Runs once on first install. Use to seed defaults.
+
+```typescript
+"plugin:install": async (_event, ctx) => {
+	await ctx.kv.set("settings:enabled", true);
+	await ctx.storage.items!.put("default", { name: "Default" });
+}
+```
+
+Event: `{}`
+Returns: `void`
+
+### `plugin:activate`
+
+Runs when plugin is enabled (after install or re-enable).
+
+```typescript
+"plugin:activate": async (_event, ctx) => {
+	ctx.log.info("Activated");
+}
+```
+
+Event: `{}`
+Returns: `void`
+
+### `plugin:deactivate`
+
+Runs when plugin is disabled (not removed).
+
+```typescript
+"plugin:deactivate": async (_event, ctx) => {
+	ctx.log.info("Deactivated");
+}
+```
+
+Event: `{}`
+Returns: `void`
+
+### `plugin:uninstall`
+
+Runs when plugin is removed. Only delete data if `event.deleteData` is true.
+
+```typescript
+"plugin:uninstall": async (event, ctx) => {
+	if (event.deleteData) {
+		const result = await ctx.storage.items!.query({ limit: 1000 });
+		await ctx.storage.items!.deleteMany(result.items.map(i => i.id));
+	}
+}
+```
+
+Event: `{ deleteData: boolean }`
+Returns: `void`
+
+## Content Hooks
+
+### `content:beforeSave`
+
+Runs before save. Return modified content, void to keep unchanged, or throw to cancel.
+
+```typescript
+"content:beforeSave": async (event, ctx) => {
+	const { content, collection, isNew } = event;
+
+	if (collection === "posts" && !content.title) {
+		throw new Error("Posts require a title");
+	}
+
+	// Transform
+	if (content.slug) {
+		content.slug = content.slug.toLowerCase().replace(/\s+/g, "-");
+	}
+
+	return content;
+}
+```
+
+Event: `{ content: Record<string, unknown>, collection: string, isNew: boolean }`
+Returns: `Record<string, unknown> | void`
+
+### `content:afterSave`
+
+Runs after successful save. Side effects only — logging, notifications, syncing.
+
+```typescript
+"content:afterSave": async (event, ctx) => {
+	const { content, collection, isNew } = event;
+	ctx.log.info(`${isNew ? "Created" : "Updated"} ${collection}/${content.id}`);
+}
+```
+
+Event: `{ content: Record<string, unknown>, collection: string, isNew: boolean }`
+Returns: `void`
+
+### `content:beforeDelete`
+
+Runs before delete. Return `false` to cancel, `true` or void to allow.
+
+```typescript
+"content:beforeDelete": async (event, ctx) => {
+	if (event.collection === "pages" && event.id === "home") {
+		ctx.log.warn("Cannot delete home page");
+		return false;
+	}
+	return true;
+}
+```
+
+Event: `{ id: string, collection: string }`
+Returns: `boolean | void`
+
+### `content:afterDelete`
+
+Runs after successful delete.
+
+```typescript
+"content:afterDelete": async (event, ctx) => {
+	ctx.log.info(`Deleted ${event.collection}/${event.id}`);
+	await ctx.storage.cache!.delete(`${event.collection}:${event.id}`);
+}
+```
+
+Event: `{ id: string, collection: string }`
+Returns: `void`
+
+## Media Hooks
+
+### `media:beforeUpload`
+
+Runs before upload. Return modified file info, void to keep, or throw to cancel.
+
+```typescript
+"media:beforeUpload": async (event, ctx) => {
+	const { file } = event;
+
+	if (!file.type.startsWith("image/")) {
+		throw new Error("Only images allowed");
+	}
+
+	if (file.size > 10 * 1024 * 1024) {
+		throw new Error("Max 10MB");
+	}
+
+	return { ...file, name: `${Date.now()}-${file.name}` };
+}
+```
+
+Event: `{ file: { name: string, type: string, size: number } }`
+Returns: `{ name: string, type: string, size: number } | void`
+
+### `media:afterUpload`
+
+Runs after successful upload.
+
+```typescript
+"media:afterUpload": async (event, ctx) => {
+	ctx.log.info(`Uploaded ${event.media.filename}`, { id: event.media.id });
+}
+```
+
+Event: `{ media: { id: string, filename: string, mimeType: string, size: number | null, url: string, createdAt: string } }`
+Returns: `void`
+
+## Email Hooks
+
+Email hooks require specific capabilities. Without the required capability, hooks are silently skipped.
+
+### `email:beforeSend`
+
+**Requires:** `email:intercept` capability.
+
+Runs before email delivery. Return modified message, or `false` to cancel delivery. Handlers are chained — each receives the output of the previous one.
+
+```typescript
+definePlugin({
+	id: "email-footer",
+	capabilities: ["email:intercept"],
+	hooks: {
+		"email:beforeSend": async (event, ctx) => {
+			return { ...event.message, text: event.message.text + "\n\n-- Sent via EmDash" };
+		},
+	},
+});
+```
+
+Event: `{ message: EmailMessage, source: string }`
+Returns: `EmailMessage | false`
+
+### `email:deliver`
+
+**Requires:** `email:provide` capability. **Exclusive hook** — exactly one provider is active.
+
+Implements email transport (e.g. Resend, SMTP, SES). Selected by the admin in Settings > Email.
+
+```typescript
+definePlugin({
+	id: "emdash-resend",
+	capabilities: ["email:provide", "network:fetch"],
+	allowedHosts: ["api.resend.com"],
+	hooks: {
+		"email:deliver": {
+			exclusive: true,
+			handler: async ({ message }, ctx) => {
+				const apiKey = await ctx.kv.get("settings:apiKey");
+				await ctx.http!.fetch("https://api.resend.com/emails", {
+					method: "POST",
+					headers: { Authorization: `Bearer ${apiKey}` },
+					body: JSON.stringify({ to: message.to, subject: message.subject, text: message.text }),
+				});
+			},
+		},
+	},
+});
+```
+
+Event: `{ message: EmailMessage, source: string }`
+Returns: `void`
+
+### `email:afterSend`
+
+**Requires:** `email:intercept` capability.
+
+Runs after successful delivery. Fire-and-forget — errors are logged but don't propagate.
+
+```typescript
+definePlugin({
+	id: "email-logger",
+	capabilities: ["email:intercept"],
+	hooks: {
+		"email:afterSend": async (event, ctx) => {
+			ctx.log.info(`Email sent to ${event.message.to}`, { source: event.source });
+		},
+	},
+});
+```
+
+Event: `{ message: EmailMessage, source: string }`
+Returns: `void`
+
+## Cron Hook
+
+### `cron`
+
+Runs on a schedule. Configure schedules via `ctx.cron.schedule()` in `plugin:activate`.
+
+```typescript
+definePlugin({
+	id: "cleanup",
+	hooks: {
+		"plugin:activate": async (_event, ctx) => {
+			await ctx.cron!.schedule("daily-cleanup", { schedule: "0 2 * * *" });
+		},
+		cron: async (event, ctx) => {
+			if (event.name === "daily-cleanup") {
+				// ... cleanup logic
+			}
+		},
+	},
+});
+```
+
+Event: `{ name: string, data?: Record<string, unknown> }`
+Returns: `void`
+
+## Public Page Hooks
+
+Public page hooks let plugins contribute to the rendered output of public site pages. Templates opt in to these contributions with `<EmDashHead>`, `<EmDashBodyStart>`, and `<EmDashBodyEnd>` components.
+
+### `page:metadata`
+
+Contributes typed metadata to `<head>` — meta tags, OG properties, canonical/alternate links, and JSON-LD. Works in both trusted and sandboxed modes.
+
+Returns structured contributions that core validates, dedupes (first-wins), and renders. Plugins never emit raw HTML through this hook.
+
+```typescript
+"page:metadata": async (event, ctx) => {
+	if (event.page.kind !== "content") return null;
+
+	return [
+		{ kind: "meta", name: "author", content: "My Blog" },
+		{
+			kind: "jsonld",
+			id: `schema:${event.page.content?.collection}:${event.page.content?.id}`,
+			graph: {
+				"@context": "https://schema.org",
+				"@type": "BlogPosting",
+				headline: event.page.title,
+				description: event.page.description,
+			},
+		},
+	];
+}
+```
+
+Event: `{ page: PublicPageContext }`
+Returns: `PageMetadataContribution | PageMetadataContribution[] | null`
+
+Contribution types:
+
+- `{ kind: "meta", name: string, content: string, key?: string }` — `<meta name="..." content="...">`
+- `{ kind: "property", property: string, content: string, key?: string }` — `<meta property="..." content="...">` (OpenGraph)
+- `{ kind: "link", rel: "canonical" | "alternate", href: string, hreflang?: string, key?: string }` — `<link>` tag (HTTP/HTTPS URLs only)
+- `{ kind: "jsonld", id?: string, graph: object | object[] }` — `<script type="application/ld+json">`
+
+Dedupe rules: first contribution wins per key. Canonical is singleton.
+
+### `page:fragments` (Trusted Only)
+
+Contributes raw HTML, scripts, or markup to `head`, `body:start`, or `body:end`. **Trusted plugins only.** Sandboxed plugins cannot register this hook — the manifest schema rejects it.
+
+```typescript
+"page:fragments": async (event, ctx) => {
+	return [
+		{
+			kind: "external-script",
+			placement: "head",
+			src: "https://www.googletagmanager.com/gtm.js?id=GTM-XXXXX",
+			async: true,
+		},
+		{
+			kind: "html",
+			placement: "body:start",
+			html: '<noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-XXXXX" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>',
+		},
+	];
+}
+```
+
+Event: `{ page: PublicPageContext }`
+Returns: `PageFragmentContribution | PageFragmentContribution[] | null`
+
+Contribution types:
+
+- `{ kind: "external-script", placement, src, async?, defer?, attributes?, key? }`
+- `{ kind: "inline-script", placement, code, attributes?, key? }`
+- `{ kind: "html", placement, html, key? }`
+
+Placements: `"head"`, `"body:start"`, `"body:end"`
+
+## Execution Order
+
+1. Lower `priority` values run first
+2. Equal priorities: plugin registration order
+3. `dependencies` array forces ordering regardless of priority
+
+## Error Handling
+
+- `errorPolicy: "abort"` (default) — pipeline stops, operation may fail
+- `errorPolicy: "continue"` — error logged, remaining hooks still run
+
+Use `"continue"` for non-critical operations (analytics, notifications, external syncs).
+
+## Quick Reference
+
+| Hook                   | Trigger              | Capability Required | Return                       |
+| ---------------------- | -------------------- | ------------------- | ---------------------------- |
+| `plugin:install`       | First install        | —                   | `void`                       |
+| `plugin:activate`      | Plugin enabled       | —                   | `void`                       |
+| `plugin:deactivate`    | Plugin disabled      | —                   | `void`                       |
+| `plugin:uninstall`     | Plugin removed       | —                   | `void`                       |
+| `content:beforeSave`   | Before save          | —                   | Modified content or `void`   |
+| `content:afterSave`    | After save           | —                   | `void`                       |
+| `content:beforeDelete` | Before delete        | —                   | `false` to cancel            |
+| `content:afterDelete`  | After delete         | —                   | `void`                       |
+| `media:beforeUpload`   | Before upload        | —                   | Modified file info or `void` |
+| `media:afterUpload`    | After upload         | —                   | `void`                       |
+| `email:beforeSend`     | Before email send    | `email:intercept`   | Modified message or `false`  |
+| `email:deliver`        | Email delivery       | `email:provide`     | `void` (exclusive)           |
+| `email:afterSend`      | After email send     | `email:intercept`   | `void`                       |
+| `cron`                 | Scheduled task fires | —                   | `void`                       |
+| `page:metadata`        | Page render          | —                   | Metadata contributions       |
+| `page:fragments`       | Page render          | — (trusted only)    | Fragment contributions       |

templates/blog/.agents/skills/creating-plugins/references/portable-text-blocks.md

@@ -0,0 +1,251 @@
+# Portable Text Block Types
+
+**Trusted plugins only.** PT blocks require Astro components for site-side rendering (`componentsEntry`), loaded at build time from an npm package. Sandboxed/marketplace plugins cannot define PT blocks.
+
+Plugins can add custom block types to the Portable Text editor. These appear in the slash command menu and can be inserted into any `portableText` field.
+
+## Declaring Block Types
+
+In `definePlugin()`, declare blocks under `admin.portableTextBlocks`:
+
+```typescript
+admin: {
+	portableTextBlocks: [
+		{
+			type: "youtube",
+			label: "YouTube Video",
+			icon: "video",
+			placeholder: "Paste YouTube URL...",
+			fields: [
+				{ type: "text_input", action_id: "id", label: "YouTube URL" },
+				{ type: "text_input", action_id: "title", label: "Title" },
+				{ type: "text_input", action_id: "poster", label: "Poster Image URL" },
+			],
+		},
+		{
+			type: "codepen",
+			label: "CodePen",
+			icon: "code",
+			placeholder: "Paste CodePen URL...",
+		},
+	],
+}
+```
+
+### Block Config Fields
+
+| Field         | Type     | Description                                     |
+| ------------- | -------- | ----------------------------------------------- |
+| `type`        | `string` | Block type name (used in PT `_type`). Required. |
+| `label`       | `string` | Display name in slash command menu. Required.   |
+| `icon`        | `string` | Icon key. Optional.                             |
+| `description` | `string` | Description in slash command menu. Optional.    |
+| `placeholder` | `string` | Input placeholder text. Optional.               |
+| `fields`      | `array`  | Block Kit form fields for editing UI. Optional. |
+
+### Icons
+
+Named icons: `video`, `code`, `link`, `link-external`. Unknown or missing falls back to a generic cube icon.
+
+### Fields
+
+When `fields` is declared, the editor renders a Block Kit form for editing. When omitted, a simple URL input is shown.
+
+Fields use Block Kit element syntax:
+
+```typescript
+fields: [
+	{
+		type: "text_input",
+		action_id: "id",
+		label: "URL",
+		placeholder: "https://...",
+	},
+	{ type: "text_input", action_id: "title", label: "Title" },
+	{ type: "text_input", action_id: "poster", label: "Poster Image" },
+	{ type: "number_input", action_id: "start", label: "Start Time (seconds)" },
+	{ type: "toggle", action_id: "autoplay", label: "Autoplay" },
+	{
+		type: "select",
+		action_id: "size",
+		label: "Size",
+		options: [
+			{ label: "Small", value: "small" },
+			{ label: "Medium", value: "medium" },
+			{ label: "Large", value: "large" },
+		],
+	},
+];
+```
+
+See [Block Kit reference](./block-kit.md) for all element types.
+
+The `action_id` of each field becomes a key in the Portable Text block data. The field with `action_id: "id"` is treated as the primary identifier (typically the URL).
+
+### Data Flow
+
+1. User types `/` in the editor and selects a block type
+2. Modal opens with Block Kit form (or simple URL input if no fields)
+3. User fills in fields and submits
+4. Block is inserted with `_type` set to the block type and field values as properties
+5. Editing an existing block re-opens the modal pre-populated
+
+Portable Text output:
+
+```json
+{
+	"_type": "youtube",
+	"_key": "abc123",
+	"id": "https://youtube.com/watch?v=dQw4w9WgXcQ",
+	"title": "Never Gonna Give You Up",
+	"poster": "https://img.youtube.com/vi/dQw4w9WgXcQ/0.jpg"
+}
+```
+
+## Site-Side Rendering
+
+To render block types on the site, export Astro components from a `componentsEntry`.
+
+### Component File
+
+```typescript
+// src/astro/index.ts
+import YouTube from "./YouTube.astro";
+import CodePen from "./CodePen.astro";
+
+// This export name is required
+export const blockComponents = {
+	youtube: YouTube,
+	codepen: CodePen,
+};
+```
+
+### Astro Component
+
+```astro
+---
+// src/astro/YouTube.astro
+const { id, title, poster } = Astro.props.node;
+
+// Extract video ID from URL
+const videoId = id?.match(/(?:v=|youtu\.be\/)([^&]+)/)?.[1] ?? id;
+---
+
+<div class="youtube-embed">
+	<iframe
+		src={`https://www.youtube-nocookie.com/embed/${videoId}`}
+		title={title || "YouTube Video"}
+		allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+		allowfullscreen
+	></iframe>
+</div>
+```
+
+Component receives `Astro.props.node` with the full block data.
+
+### Plugin Descriptor
+
+Set `componentsEntry` in the descriptor:
+
+```typescript
+export function myPlugin(options = {}): PluginDescriptor {
+	return {
+		id: "my-plugin",
+		entrypoint: "@my-org/my-plugin",
+		componentsEntry: "@my-org/my-plugin/astro",
+		version: "1.0.0",
+		options,
+	};
+}
+```
+
+### Package Exports
+
+Add the `./astro` export:
+
+```json
+{
+	"exports": {
+		".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" },
+		"./admin": { "types": "./dist/admin.d.ts", "import": "./dist/admin.js" },
+		"./astro": {
+			"types": "./dist/astro/index.d.ts",
+			"import": "./dist/astro/index.js"
+		}
+	}
+}
+```
+
+### Auto-Wiring
+
+Plugin block components are automatically merged into `<PortableText>` on the site. Merge order:
+
+1. EmDash defaults (lowest priority)
+2. Plugin block components
+3. User-provided components (highest priority)
+
+Site authors don't need to import anything. User components take precedence over plugin defaults.
+
+## Complete Example
+
+```typescript
+// src/index.ts
+import { definePlugin } from "emdash";
+import type { PluginDescriptor } from "emdash";
+
+export function embedsPlugin(options = {}): PluginDescriptor {
+	return {
+		id: "embeds",
+		version: "1.0.0",
+		entrypoint: "@my-org/plugin-embeds",
+		componentsEntry: "@my-org/plugin-embeds/astro",
+		options,
+	};
+}
+
+export function createPlugin() {
+	return definePlugin({
+		id: "embeds",
+		version: "1.0.0",
+
+		admin: {
+			portableTextBlocks: [
+				{
+					type: "youtube",
+					label: "YouTube Video",
+					icon: "video",
+					placeholder: "Paste YouTube URL...",
+					fields: [
+						{ type: "text_input", action_id: "id", label: "YouTube URL" },
+						{ type: "text_input", action_id: "title", label: "Title" },
+						{
+							type: "text_input",
+							action_id: "poster",
+							label: "Poster Image URL",
+						},
+					],
+				},
+				{
+					type: "linkPreview",
+					label: "Link Preview",
+					icon: "link-external",
+					placeholder: "Paste any URL...",
+				},
+			],
+		},
+	});
+}
+
+export default createPlugin;
+```
+
+```typescript
+// src/astro/index.ts
+import YouTube from "./YouTube.astro";
+import LinkPreview from "./LinkPreview.astro";
+
+export const blockComponents = {
+	youtube: YouTube,
+	linkPreview: LinkPreview,
+};
+```

templates/blog/.agents/skills/creating-plugins/references/publishing.md

@@ -0,0 +1,82 @@
+# Publishing to the Marketplace
+
+Sandboxed plugins can be published to the EmDash Marketplace for one-click installation from the admin UI.
+
+## Bundle Format
+
+Published plugins are `.tar.gz` tarballs:
+
+| File            | Required | Description                                     |
+| --------------- | -------- | ----------------------------------------------- |
+| `manifest.json` | Yes      | Metadata extracted from `definePlugin()`        |
+| `backend.js`    | No       | Bundled sandbox code (self-contained ES module) |
+| `admin.js`      | No       | Bundled admin UI code                           |
+| `README.md`     | No       | Plugin documentation                            |
+| `icon.png`      | No       | Plugin icon (256x256 PNG)                       |
+| `screenshots/`  | No       | Up to 5 screenshots (PNG/JPEG, max 1920x1080)   |
+
+## Package Exports for Bundling
+
+The bundle command uses `package.json` exports to find entrypoints:
+
+```json
+{
+	"exports": {
+		".": { "import": "./dist/index.mjs" },
+		"./sandbox": { "import": "./dist/sandbox-entry.mjs" },
+		"./admin": { "import": "./dist/admin.mjs" }
+	}
+}
+```
+
+| Export        | Purpose                       | Built as                             |
+| ------------- | ----------------------------- | ------------------------------------ |
+| `"."`         | Main entry — extract manifest | Externals: `emdash`, `@emdashcms/*` |
+| `"./sandbox"` | Backend code for the sandbox  | Fully self-contained (no externals)  |
+| `"./admin"`   | Admin UI components           | Fully self-contained                 |
+
+If `"./sandbox"` is missing, the command looks for `src/sandbox-entry.ts`.
+
+## Build and Publish
+
+```bash
+# Bundle only (inspect first)
+emdash plugin bundle
+tar tzf dist/my-plugin-1.0.0.tar.gz
+
+# Publish (uploads to marketplace)
+emdash plugin publish
+
+# Build + publish in one step
+emdash plugin publish --build
+```
+
+First-time publish authenticates via GitHub device authorization. Token stored in `~/.config/emdash/auth.json` (30-day expiry).
+
+## Validation
+
+The bundle command checks:
+
+- **Size limit** — Total bundle under 5MB
+- **No Node.js built-ins** — `backend.js` cannot import `fs`, `path`, etc.
+- **Sandbox-incompatible features** — Warns if the plugin declares `portableTextBlocks`, `admin.entry` (React components), or API `routes`, since these require trusted mode
+- **Icon dimensions** — 256x256 PNG (warns if wrong)
+- **Screenshot limits** — Max 5, max 1920x1080
+
+## Security Audit
+
+Every published version is automatically audited for:
+
+- Data exfiltration patterns
+- Credential harvesting via settings
+- Obfuscated code
+- Resource abuse (crypto mining, etc.)
+- Suspicious network activity
+
+Verdict: **pass**, **warn**, or **fail** — displayed on marketplace listing.
+
+## Version Requirements
+
+- Each version must have higher semver than the last
+- Cannot overwrite or republish an existing version
+- Plugin ID is auto-registered on first publish

templates/blog/.agents/skills/creating-plugins/references/storage.md

@@ -0,0 +1,264 @@
+# Storage, KV & Settings
+
+Plugins have three data mechanisms:
+
+| Mechanism           | Purpose                                   | Access                 |
+| ------------------- | ----------------------------------------- | ---------------------- |
+| **Storage**         | Document collections with indexed queries | `ctx.storage`          |
+| **KV**              | Key-value pairs for state and settings    | `ctx.kv`               |
+| **Settings Schema** | Auto-generated admin UI for configuration | `admin.settingsSchema` |
+
+## Storage Collections
+
+Declare in `definePlugin({ storage })`. EmDash creates the schema automatically — no migrations.
+
+```typescript
+definePlugin({
+	id: "forms",
+	version: "1.0.0",
+
+	storage: {
+		submissions: {
+			indexes: [
+				"formId", // Single-field index
+				"status",
+				"createdAt",
+				["formId", "createdAt"], // Composite index
+			],
+		},
+		forms: {
+			indexes: ["slug"],
+		},
+	},
+});
+```
+
+Storage is scoped to the plugin — `submissions` in plugin `forms` is separate from `submissions` in another plugin.
+
+### CRUD
+
+```typescript
+const { submissions } = ctx.storage;
+
+await submissions.put("sub_123", { formId: "contact", email: "user@example.com" });
+const item = await submissions.get("sub_123");
+const exists = await submissions.exists("sub_123");
+await submissions.delete("sub_123");
+```
+
+### Batch Operations
+
+```typescript
+const items = await submissions.getMany(["sub_1", "sub_2"]); // Map<string, T>
+
+await submissions.putMany([
+	{ id: "sub_1", data: { formId: "contact", status: "new" } },
+	{ id: "sub_2", data: { formId: "contact", status: "new" } },
+]);
+
+const deletedCount = await submissions.deleteMany(["sub_1", "sub_2"]);
+```
+
+### Querying
+
+Only indexed fields can be queried. Non-indexed queries throw.
+
+```typescript
+const result = await ctx.storage.submissions.query({
+	where: {
+		formId: "contact",
+		status: "pending",
+	},
+	orderBy: { createdAt: "desc" },
+	limit: 20,
+});
+
+// result.items - Array of { id, data }
+// result.cursor - Pagination cursor
+// result.hasMore - Boolean
+```
+
+### Where Operators
+
+```typescript
+// Exact match
+where: { status: "pending" }
+
+// Range
+where: { createdAt: { gte: "2024-01-01" } }
+where: { score: { gt: 50, lte: 100 } }
+
+// In
+where: { status: { in: ["pending", "approved"] } }
+
+// Starts with
+where: { slug: { startsWith: "blog-" } }
+```
+
+### Pagination
+
+```typescript
+let cursor: string | undefined;
+do {
+	const result = await ctx.storage.submissions!.query({
+		orderBy: { createdAt: "desc" },
+		limit: 100,
+		cursor,
+	});
+	// process result.items
+	cursor = result.cursor;
+} while (cursor);
+```
+
+### Counting
+
+```typescript
+const total = await ctx.storage.submissions!.count();
+const pending = await ctx.storage.submissions!.count({ status: "pending" });
+```
+
+### Index Design
+
+| Query Pattern                            | Index Needed              |
+| ---------------------------------------- | ------------------------- |
+| Filter by `formId`                       | `"formId"`                |
+| Filter by `formId`, order by `createdAt` | `["formId", "createdAt"]` |
+| Order by `createdAt` only                | `"createdAt"`             |
+
+Composite indexes support filtering on the first field + ordering by the second.
+
+### Type Safety
+
+```typescript
+interface Submission {
+	formId: string;
+	status: "pending" | "approved" | "spam";
+	createdAt: string;
+}
+
+// Cast in hook/route handlers
+const submissions = ctx.storage.submissions as StorageCollection<Submission>;
+```
+
+### Full API
+
+```typescript
+interface StorageCollection<T = unknown> {
+	get(id: string): Promise<T | null>;
+	put(id: string, data: T): Promise<void>;
+	delete(id: string): Promise<boolean>;
+	exists(id: string): Promise<boolean>;
+	getMany(ids: string[]): Promise<Map<string, T>>;
+	putMany(items: Array<{ id: string; data: T }>): Promise<void>;
+	deleteMany(ids: string[]): Promise<number>;
+	query(options?: QueryOptions): Promise<PaginatedResult<{ id: string; data: T }>>;
+	count(where?: WhereClause): Promise<number>;
+}
+```
+
+## KV Store
+
+General-purpose key-value store. Use for internal state, cached computations, or programmatic access to settings.
+
+```typescript
+interface KVAccess {
+	get<T>(key: string): Promise<T | null>;
+	set(key: string, value: unknown): Promise<void>;
+	delete(key: string): Promise<boolean>;
+	list(prefix?: string): Promise<Array<{ key: string; value: unknown }>>;
+}
+```
+
+### Key Naming Conventions
+
+| Prefix      | Purpose                       | Example           |
+| ----------- | ----------------------------- | ----------------- |
+| `settings:` | User-configurable preferences | `settings:apiKey` |
+| `state:`    | Internal plugin state         | `state:lastSync`  |
+| `cache:`    | Cached data                   | `cache:results`   |
+
+```typescript
+await ctx.kv.set("settings:webhookUrl", url);
+await ctx.kv.set("state:lastRun", new Date().toISOString());
+const allSettings = await ctx.kv.list("settings:");
+```
+
+## Settings Schema
+
+Declare `admin.settingsSchema` to auto-generate a settings form in the admin UI:
+
+```typescript
+admin: {
+	settingsSchema: {
+		siteTitle: {
+			type: "string",
+			label: "Site Title",
+			description: "Used in title tags",
+			default: "",
+		},
+		maxItems: {
+			type: "number",
+			label: "Max Items",
+			default: 100,
+			min: 1,
+			max: 1000,
+		},
+		enabled: {
+			type: "boolean",
+			label: "Enabled",
+			default: true,
+		},
+		theme: {
+			type: "select",
+			label: "Theme",
+			options: [
+				{ value: "light", label: "Light" },
+				{ value: "dark", label: "Dark" },
+			],
+			default: "light",
+		},
+		apiKey: {
+			type: "secret",
+			label: "API Key",
+			description: "Encrypted at rest",
+		},
+	},
+}
+```
+
+### Setting Types
+
+| Type      | UI           | Notes                                     |
+| --------- | ------------ | ----------------------------------------- |
+| `string`  | Text input   | Optional `multiline: true` for textarea   |
+| `number`  | Number input | Optional `min`, `max`                     |
+| `boolean` | Toggle       |                                           |
+| `select`  | Dropdown     | Requires `options: [{ value, label }]`    |
+| `secret`  | Masked input | Encrypted at rest, never shown after save |
+
+### Reading Settings
+
+Settings are accessed via KV with `settings:` prefix:
+
+```typescript
+const enabled = (await ctx.kv.get<boolean>("settings:enabled")) ?? true;
+const apiKey = await ctx.kv.get<string>("settings:apiKey");
+```
+
+Schema defaults are UI defaults only — not auto-persisted. Handle missing values with `??` or persist defaults in `plugin:install`:
+
+```typescript
+"plugin:install": async (_event, ctx) => {
+	await ctx.kv.set("settings:enabled", true);
+	await ctx.kv.set("settings:maxItems", 100);
+}
+```
+
+## When to Use What
+
+| Use Case                                     | Mechanism                         |
+| -------------------------------------------- | --------------------------------- |
+| Admin-editable preferences                   | `settingsSchema` + KV `settings:` |
+| Internal state (timestamps, cursors)         | KV `state:`                       |
+| Collections of documents (logs, submissions) | Storage                           |
+| Cached computations                          | KV `cache:`                       |

templates/blog/.agents/skills/emdash-cli/EDITING-FLOW.md

@@ -0,0 +1,164 @@
+# Editing Flow
+
+How content editing works through the CLI. Covers Portable Text conversion, `_rev` tokens, and raw mode.
+
+## Portable Text and Markdown
+
+EmDash stores rich text as [Portable Text](https://portabletext.org/) (PT) — a structured JSON format. The CLI automatically converts between PT and markdown so you work with a familiar text format.
+
+### Automatic Conversion
+
+- **On read**: PT arrays in `portableText` fields are converted to markdown strings
+- **On write**: markdown strings in `portableText` fields are converted back to PT arrays
+- **Non-PT fields** (string, text, number, etc.) pass through unchanged
+
+The CLI detects which fields need conversion by fetching the collection's field schema.
+
+### Supported Markdown Syntax
+
+Standard blocks (lossless round-trip):
+
+| Markdown                     | PT block                                   |
+| ---------------------------- | ------------------------------------------ |
+| `# Heading` through `######` | h1-h6 blocks                               |
+| Plain paragraph              | normal block                               |
+| `> Quote`                    | blockquote                                 |
+| `- item` / `* item`          | bullet list (nesting via 2-space indent)   |
+| `1. item`                    | numbered list (nesting via 2-space indent) |
+| ` ``` ```lang``` `           | code block with language                   |
+| `![alt](url)`                | image block                                |
+
+Inline marks:
+
+| Markdown      | PT mark         |
+| ------------- | --------------- |
+| `**bold**`    | `strong`        |
+| `_italic_`    | `em`            |
+| `` `code` ``  | `code`          |
+| `~~strike~~`  | `strikethrough` |
+| `[text](url)` | link annotation |
+
+### Unknown Blocks (Opaque Fences)
+
+Blocks the converter doesn't recognize (custom blocks, embeds, etc.) are serialized as HTML comments:
+
+```markdown
+<!--ec:block {"_type":"callout","level":"warning","text":"Be careful"} -->
+```
+
+These survive round-trips intact. You can see and move them, but editing the JSON risks corruption. On write, they're deserialized back to the original PT block.
+
+### Raw Mode
+
+Skip markdown conversion entirely to work with raw PT JSON:
+
+```bash
+npx emdash content get posts 01ABC123 --raw
+```
+
+Use raw mode when:
+
+- You need exact control over PT structure
+- You're working with custom block types
+- You're copying PT between items without transformation
+
+### Writing Content
+
+When creating or updating content, each field is checked:
+
+- `portableText` field + **string value** → converts markdown to PT before sending
+- `portableText` field + **array value** → sends as raw PT (no conversion)
+- Any other field type → sends as-is
+
+```bash
+# Markdown string — converted to PT automatically
+npx emdash content create posts --data '{"title": "Hello", "body": "# Welcome\n\nThis is **bold**."}'
+
+# Raw PT array — passed through as-is
+npx emdash content create posts --data '{"title": "Hello", "body": [{"_type": "block", "children": [{"_type": "span", "text": "Welcome"}]}]}'
+```
+
+## Auto-Publishing
+
+The CLI is designed for agents. It auto-publishes on `create` and `update` by default so agents get read-after-write consistency without managing the draft/publish lifecycle.
+
+### How It Works
+
+- **`create`** — creates the item, then publishes it. The returned item is in `published` status.
+- **`update`** — updates the item. If the collection uses revisions and the update created a draft revision, it auto-publishes to promote the draft to the content table. The returned item reflects the updated data.
+- **`get`** — returns the latest state. If a pending draft exists (e.g. someone edited in the admin UI but didn't publish), the draft data is returned instead of the published data. Use `--published` to see only published data.
+
+Use `--draft` on create/update to skip auto-publishing.
+
+### Why Auto-Publish?
+
+EmDash collections can support draft revisions. When they do, `update` writes data to a draft revision instead of the content table. Without auto-publish, an agent would update, then `get` the item, and see stale published data — not the changes it just made. Auto-publish eliminates this confusion.
+
+## Read-Before-Write
+
+Updates use `_rev` tokens for optimistic concurrency — the same principle as a file editing tool that requires you to read a file before you can edit it. You must see what you're overwriting.
+
+### The Analogy
+
+Think of it like a filesystem edit tool:
+
+1. You **read** the file to see its current contents
+2. You decide what to change
+3. You **write** with a reference to the version you read
+
+If someone else changed the file between your read and your write, the write fails — you can't overwrite changes you haven't seen. The `_rev` token is your proof that you've seen the current state.
+
+### How It Works
+
+1. `content get` returns the item with a `_rev` token in the output
+2. You pass that `_rev` back to `content update` via `--rev`
+3. The server checks: if the item has changed since your read, it returns **409 Conflict**
+4. A successful update returns a new `_rev` for subsequent edits
+
+### What Is a `_rev` Token?
+
+An opaque base64 string. Don't parse it — just pass it back.
+
+### CLI Workflow
+
+The CLI **requires** `--rev` on updates. The typical workflow:
+
+```bash
+# 1. Read the item — note the _rev in the output
+npx emdash content get posts 01ABC123
+# Output includes: _rev: MToyMDI2LTAyLTE0...
+
+# 2. Update with the _rev you received — auto-publishes by default
+npx emdash content update posts 01ABC123 \
+  --rev MToyMDI2LTAyLTE0... \
+  --data '{"title": "New Title"}'
+# Output shows updated item with new _rev
+```
+
+If you try to update without `--rev`, the CLI rejects the command. This ensures you always know what you're overwriting.
+
+### Conflict Handling
+
+If someone else updated the item between your read and write:
+
+```
+EmDashApiError: Content has been modified since last read (version conflict)
+  status: 409
+  code: CONFLICT
+```
+
+Resolution: re-read with `get`, inspect the new state, then `update` with the fresh `_rev`.
+
+### Which Operations Need `_rev`?
+
+Only `update`. All other operations are either idempotent or non-destructive:
+
+| Command             | `--rev` needed? | Why                      |
+| ------------------- | --------------- | ------------------------ |
+| `content create`    | No              | Nothing exists yet       |
+| `content update`    | **Yes**         | Overwrites existing data |
+| `content delete`    | No              | Soft delete, reversible  |
+| `content publish`   | No              | Idempotent status change |
+| `content unpublish` | No              | Idempotent status change |
+| `content schedule`  | No              | Only changes metadata    |
+| `content restore`   | No              | Restores from trash      |

templates/blog/.agents/skills/emdash-cli/SKILL.md

@@ -0,0 +1,246 @@
+---
+name: emdash-cli
+description: Use the EmDash CLI to manage content, schema, media, and more. Use this skill when you need to interact with a running EmDash instance from the command line — creating content, managing collections, uploading media, generating types, or scripting CMS operations.
+---
+
+# EmDash CLI
+
+The EmDash CLI (`emdash` or `ec`) manages EmDash CMS instances. Commands fall into two categories:
+
+- **Local commands** — work directly on a SQLite file, no running server needed: `init`, `dev`, `seed`, `export-seed`, `auth secret`
+- **Remote commands** — talk to a running EmDash instance via HTTP: `types`, `login`, `logout`, `whoami`, `content`, `schema`, `media`, `search`, `taxonomy`, `menu`
+
+## Authentication
+
+Remote commands resolve auth automatically:
+
+1. `--token` flag
+2. `EMDASH_TOKEN` env var
+3. Stored credentials from `emdash login`
+4. Dev bypass (localhost only — no token needed)
+
+For local dev servers, just run the command — auth is handled automatically. For remote instances, run `emdash login --url https://my-site.pages.dev` first.
+
+## Custom Headers & Reverse Proxies
+
+Sites behind Cloudflare Access or other reverse proxies need auth headers on every request. The CLI supports this via `--header` flags and environment variables.
+
+### Service Tokens (Recommended for CI/Automation)
+
+```bash
+# Single header
+npx emdash login --url https://my-site.pages.dev \
+  --header "CF-Access-Client-Id: xxx.access" \
+  --header "CF-Access-Client-Secret: yyy"
+
+# Short form
+npx emdash login -H "CF-Access-Client-Id: xxx" -H "CF-Access-Client-Secret: yyy"
+
+# Via environment (newline-separated)
+export EMDASH_HEADERS="CF-Access-Client-Id: xxx
+CF-Access-Client-Secret: yyy"
+npx emdash login --url https://my-site.pages.dev
+```
+
+Headers are persisted to `~/.config/emdash/auth.json` after login, so subsequent commands inherit them automatically.
+
+### Cloudflare Access Browser Flow
+
+If you don't have service tokens and `cloudflared` is installed, the CLI will automatically:
+
+1. Detect when Access blocks the request
+2. Try to get a cached JWT via `cloudflared access token`
+3. Fall back to `cloudflared access login` for browser-based auth
+
+This works for interactive use but isn't suitable for CI. Use service tokens for automation.
+
+### Generic Reverse Proxy Auth
+
+The `--header` flag works with any auth scheme:
+
+```bash
+# Basic auth
+npx emdash login --url https://example.com -H "Authorization: Basic dXNlcjpwYXNz"
+
+# Custom auth header
+npx emdash login --url https://example.com -H "X-API-Key: secret123"
+```
+
+## Quick Reference
+
+### Database Setup
+
+```bash
+# Initialize database with migrations
+npx emdash init
+
+# Start dev server (runs migrations, starts Astro)
+npx emdash dev
+
+# Start dev server and generate types from remote
+npx emdash dev --types
+
+# Apply a seed file
+npx emdash seed .emdash/seed.json
+
+# Export database as seed
+npx emdash export-seed > seed.json
+npx emdash export-seed --with-content > seed.json
+```
+
+### Type Generation
+
+```bash
+# Generate types from local dev server
+npx emdash types
+
+# Generate from remote
+npx emdash types --url https://my-site.pages.dev
+
+# Custom output path
+npx emdash types --output src/types/cms.ts
+```
+
+Writes `.emdash/types.ts` (TypeScript interfaces) and `.emdash/schema.json`.
+
+### Authentication
+
+```bash
+# Login (OAuth Device Flow)
+npx emdash login --url https://my-site.pages.dev
+
+# Check current user
+npx emdash whoami
+
+# Logout
+npx emdash logout
+
+# Generate auth secret for deployment
+npx emdash auth secret
+```
+
+### Content CRUD
+
+The CLI is designed for agents. Create and update auto-publish by default so agents get read-after-write consistency without managing drafts.
+
+```bash
+# List content
+npx emdash content list posts
+npx emdash content list posts --status published --limit 10
+
+# Get a single item (Portable Text fields converted to markdown)
+# Returns draft data if a pending draft exists
+npx emdash content get posts 01ABC123
+npx emdash content get posts 01ABC123 --raw        # skip PT->markdown conversion
+npx emdash content get posts 01ABC123 --published   # ignore pending drafts
+
+# Create content (auto-publishes by default)
+npx emdash content create posts --data '{"title": "Hello", "body": "# World"}'
+npx emdash content create posts --file post.json --slug hello-world
+npx emdash content create posts --draft --data '...'  # keep as draft
+cat post.json | npx emdash content create posts --stdin
+
+# Update (requires --rev from a prior get, auto-publishes by default)
+npx emdash content update posts 01ABC123 --rev MToyMDI2... --data '{"title": "Updated"}'
+npx emdash content update posts 01ABC123 --rev MToyMDI2... --draft --data '...'  # keep as draft
+
+# Delete (soft delete)
+npx emdash content delete posts 01ABC123
+
+# Lifecycle
+npx emdash content publish posts 01ABC123
+npx emdash content unpublish posts 01ABC123
+npx emdash content schedule posts 01ABC123 --at 2026-03-01T09:00:00Z
+npx emdash content restore posts 01ABC123
+```
+
+### Schema Management
+
+```bash
+# List collections
+npx emdash schema list
+
+# Get collection with fields
+npx emdash schema get posts
+
+# Create collection
+npx emdash schema create articles --label Articles --description "Blog articles"
+
+# Delete collection
+npx emdash schema delete articles --force
+
+# Add field
+npx emdash schema add-field posts body --type portableText --label "Body Content"
+npx emdash schema add-field posts featured --type boolean --required
+
+# Remove field
+npx emdash schema remove-field posts featured
+```
+
+Field types: `string`, `text`, `number`, `integer`, `boolean`, `datetime`, `image`, `reference`, `portableText`, `json`.
+
+### Media
+
+```bash
+# List media
+npx emdash media list
+npx emdash media list --mime image/png
+
+# Upload
+npx emdash media upload ./photo.jpg --alt "A sunset" --caption "Bristol, 2026"
+
+# Get / delete
+npx emdash media get 01MEDIA123
+npx emdash media delete 01MEDIA123
+```
+
+### Search
+
+```bash
+npx emdash search "hello world"
+npx emdash search "hello" --collection posts --limit 5
+```
+
+### Taxonomies
+
+```bash
+npx emdash taxonomy list
+npx emdash taxonomy terms categories
+npx emdash taxonomy add-term categories --name "Tech" --slug tech
+npx emdash taxonomy add-term categories --name "Frontend" --parent 01PARENT123
+```
+
+### Menus
+
+```bash
+npx emdash menu list
+npx emdash menu get primary
+```
+
+## Drafts and Publishing
+
+The CLI auto-publishes on `create` and `update` by default. This means:
+
+- **`create`** creates the item and immediately publishes it
+- **`update`** updates the item and publishes if a draft revision was created
+- **`get`** returns draft data if a pending draft exists (e.g. from the admin UI)
+
+Use `--draft` on create/update to skip auto-publishing. Use `--published` on get to ignore pending drafts.
+
+Collections that support revisions store edits as draft revisions. The CLI handles this transparently — agents don't need to know whether a collection uses revisions or not.
+
+## JSON Output
+
+All remote commands support `--json` for machine-readable output. It's auto-enabled when stdout is piped.
+
+```bash
+# Pipe to jq
+npx emdash content list posts --json | jq '.items[].slug'
+
+# Use in scripts
+ID=$(npx emdash content create posts --data '{"title":"Hello"}' --json | jq -r '.id')
+```
+
+## Editing Flow
+
+For details on how content editing works — Portable Text/markdown conversion, `_rev` tokens, and raw mode — see **[EDITING-FLOW.md](./EDITING-FLOW.md)**.

templates/blog/.claude/skills

@@ -0,0 +1 @@
+../.agents/skills

templates/blog/.gitignore

@@ -0,0 +1,5 @@
+node_modules
+dist
+.astro
+uploads
+data.db

templates/blog/AGENTS.md

@@ -0,0 +1,38 @@
+This is an EmDash site -- a CMS built on Astro with a full admin UI.
+
+## Commands
+
+```bash
+npx emdash dev        # Start dev server (runs migrations, seeds, generates types)
+npx emdash types      # Regenerate TypeScript types from schema
+npx emdash seed seed/seed.json --validate  # Validate seed file
+```
+
+The admin UI is at `http://localhost:4321/_emdash/admin`.
+
+## Key Files
+
+| File                     | Purpose                                                                            |
+| ------------------------ | ---------------------------------------------------------------------------------- |
+| `astro.config.mjs`       | Astro config with `emdash()` integration, database, and storage                  |
+| `src/live.config.ts`     | EmDash loader registration (boilerplate -- don't modify)                         |
+| `seed/seed.json`         | Schema definition + demo content (collections, fields, taxonomies, menus, widgets) |
+| `emdash-env.d.ts`      | Generated types for collections (auto-regenerated on dev server start)             |
+| `src/layouts/Base.astro` | Base layout with EmDash wiring (menus, search, page contributions)               |
+| `src/pages/`             | Astro pages -- all server-rendered                                                 |
+
+## Skills
+
+Agent skills are in `.agents/skills/`. Load them when working on specific tasks:
+
+- **building-emdash-site** -- Querying content, rendering Portable Text, schema design, seed files, site features (menus, widgets, search, SEO, comments, bylines). Start here.
+- **creating-plugins** -- Building EmDash plugins with hooks, storage, admin UI, API routes, and Portable Text block types.
+- **emdash-cli** -- CLI commands for content management, seeding, type generation, and visual editing flow.
+
+## Rules
+
+- All content pages must be server-rendered (`output: "server"`). No `getStaticPaths()` for CMS content.
+- Image fields are objects (`{ src, alt }`), not strings. Use `<Image image={...} />` from `"emdash/ui"`.
+- `entry.id` is the slug (for URLs). `entry.data.id` is the database ULID (for API calls like `getEntryTerms`).
+- Always call `Astro.cache.set(cacheHint)` on pages that query content.
+- Taxonomy names in queries must match the seed's `"name"` field exactly (e.g., `"category"` not `"categories"`).

templates/blog/CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

templates/blog/astro.config.mjs

@@ -0,0 +1,29 @@
+import node from "@astrojs/node";
+import react from "@astrojs/react";
+import { auditLogPlugin } from "@emdashcms/plugin-audit-log";
+import { defineConfig } from "astro/config";
+import emdash, { local } from "emdash/astro";
+import { sqlite } from "emdash/db";
+
+export default defineConfig({
+	output: "server",
+	adapter: node({
+		mode: "standalone",
+	}),
+	image: {
+		layout: "constrained",
+		responsiveStyles: true,
+	},
+	integrations: [
+		react(),
+		emdash({
+			database: sqlite({ url: "file:./data.db" }),
+			storage: local({
+				directory: "./uploads",
+				baseUrl: "/_emdash/api/media/file",
+			}),
+			plugins: [auditLogPlugin()],
+		}),
+	],
+	devToolbar: { enabled: false },
+});

templates/blog/emdash-env.d.ts

@@ -0,0 +1,39 @@
+// Generated by EmDash on dev server start
+// Do not edit manually
+
+/// <reference types="emdash/locals" />
+
+import type { ContentBylineCredit, PortableTextBlock } from "emdash";
+
+export interface Page {
+  id: string;
+  slug: string | null;
+  status: string;
+  title: string;
+  content?: PortableTextBlock[];
+  createdAt: Date;
+  updatedAt: Date;
+  publishedAt: Date | null;
+  bylines?: ContentBylineCredit[];
+}
+
+export interface Post {
+  id: string;
+  slug: string | null;
+  status: string;
+  title: string;
+  featured_image?: { id: string; src?: string; alt?: string; width?: number; height?: number };
+  content?: PortableTextBlock[];
+  excerpt?: string;
+  createdAt: Date;
+  updatedAt: Date;
+  publishedAt: Date | null;
+  bylines?: ContentBylineCredit[];
+}
+
+declare module "emdash" {
+  interface EmDashCollections {
+    pages: Page;
+    posts: Post;
+  }
+}

templates/blog/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@emdashcms/template-blog",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "emdash": {
+    "seed": "seed/seed.json"
+  },
+  "scripts": {
+    "dev": "astro dev",
+    "build": "astro build",
+    "preview": "astro preview",
+    "start": "node ./dist/server/entry.mjs",
+    "bootstrap": "emdash init && emdash seed",
+    "seed": "emdash seed",
+    "typecheck": "astro check"
+  },
+  "dependencies": {
+    "@astrojs/node": "catalog:",
+    "@astrojs/react": "catalog:",
+    "@emdashcms/plugin-audit-log": "workspace:*",
+    "astro": "catalog:",
+    "better-sqlite3": "catalog:",
+    "emdash": "workspace:*",
+    "react": "catalog:",
+    "react-dom": "catalog:"
+  },
+  "devDependencies": {
+    "@astrojs/check": "catalog:"
+  },
+  "peerDependencies": {},
+  "optionalDependencies": {}
+}

templates/blog/seed/seed.json

@@ -0,0 +1,778 @@
+{
+	"$schema": "https://emdashcms.com/seed.schema.json",
+	"version": "1",
+	"meta": {
+		"name": "Blog Starter",
+		"description": "A blog with posts and pages",
+		"author": "EmDash"
+	},
+
+	"settings": {
+		"title": "My Blog",
+		"tagline": "Thoughts on building for the web"
+	},
+
+	"collections": [
+		{
+			"slug": "posts",
+			"label": "Posts",
+			"labelSingular": "Post",
+			"supports": ["drafts", "revisions", "search", "seo"],
+			"commentsEnabled": true,
+			"fields": [
+				{
+					"slug": "title",
+					"label": "Title",
+					"type": "string",
+					"required": true,
+					"searchable": true
+				},
+				{
+					"slug": "featured_image",
+					"label": "Featured Image",
+					"type": "image"
+				},
+				{
+					"slug": "content",
+					"label": "Content",
+					"type": "portableText",
+					"searchable": true
+				},
+				{
+					"slug": "excerpt",
+					"label": "Excerpt",
+					"type": "text"
+				}
+			]
+		},
+		{
+			"slug": "pages",
+			"label": "Pages",
+			"labelSingular": "Page",
+			"supports": ["drafts", "revisions", "search"],
+			"fields": [
+				{
+					"slug": "title",
+					"label": "Title",
+					"type": "string",
+					"required": true,
+					"searchable": true
+				},
+				{
+					"slug": "content",
+					"label": "Content",
+					"type": "portableText",
+					"searchable": true
+				}
+			]
+		}
+	],
+
+	"taxonomies": [
+		{
+			"name": "category",
+			"label": "Categories",
+			"labelSingular": "Category",
+			"hierarchical": true,
+			"collections": ["posts"],
+			"terms": [
+				{ "slug": "development", "label": "Development" },
+				{ "slug": "design", "label": "Design" },
+				{ "slug": "notes", "label": "Notes" }
+			]
+		},
+		{
+			"name": "tag",
+			"label": "Tags",
+			"labelSingular": "Tag",
+			"hierarchical": false,
+			"collections": ["posts"],
+			"terms": [
+				{ "slug": "webdev", "label": "Web Development" },
+				{ "slug": "opinion", "label": "Opinion" },
+				{ "slug": "tools", "label": "Tools" },
+				{ "slug": "creativity", "label": "Creativity" }
+			]
+		}
+	],
+
+	"bylines": [
+		{
+			"id": "byline-editorial",
+			"slug": "emdash-editorial",
+			"displayName": "EmDash Editorial"
+		},
+		{
+			"id": "byline-guest",
+			"slug": "guest-contributor",
+			"displayName": "Guest Contributor",
+			"isGuest": true
+		}
+	],
+
+	"menus": [
+		{
+			"name": "primary",
+			"label": "Primary Navigation",
+			"items": [
+				{ "type": "custom", "label": "Home", "url": "/" },
+				{ "type": "custom", "label": "About", "url": "/pages/about" },
+				{ "type": "custom", "label": "Posts", "url": "/posts" }
+			]
+		}
+	],
+
+	"widgetAreas": [
+		{
+			"name": "sidebar",
+			"label": "Sidebar",
+			"description": "Widget area displayed on single post pages",
+			"widgets": [
+				{
+					"type": "component",
+					"componentId": "core:search",
+					"title": "Search"
+				},
+				{
+					"type": "component",
+					"componentId": "core:categories",
+					"title": "Categories"
+				},
+				{
+					"type": "component",
+					"componentId": "core:tags",
+					"title": "Tags"
+				},
+				{
+					"type": "component",
+					"componentId": "core:recent-posts",
+					"title": "Recent Posts",
+					"settings": {
+						"count": 5,
+						"showDate": true
+					}
+				},
+				{
+					"type": "component",
+					"componentId": "core:archives",
+					"title": "Archives",
+					"settings": {
+						"type": "monthly",
+						"limit": 6
+					}
+				}
+			]
+		},
+		{
+			"name": "footer",
+			"label": "Footer",
+			"description": "Widget area displayed in the site footer",
+			"widgets": [
+				{
+					"type": "content",
+					"title": "About",
+					"content": [
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "A blog about software, design, and the occasional stray thought."
+								}
+							]
+						}
+					]
+				}
+			]
+		}
+	],
+
+	"sections": [
+		{
+			"slug": "newsletter-signup",
+			"title": "Newsletter Signup",
+			"description": "A call-to-action block for newsletter subscriptions",
+			"keywords": ["newsletter", "subscribe", "email", "cta"],
+			"source": "theme",
+			"content": [
+				{
+					"_type": "block",
+					"style": "h3",
+					"children": [{ "_type": "span", "text": "Stay in the loop" }]
+				},
+				{
+					"_type": "block",
+					"style": "normal",
+					"children": [
+						{
+							"_type": "span",
+							"text": "Get notified when new posts are published. No spam, unsubscribe anytime."
+						}
+					]
+				}
+			]
+		},
+		{
+			"slug": "about-author",
+			"title": "About the Author",
+			"description": "Brief author bio for use in posts or pages",
+			"keywords": ["author", "bio", "about"],
+			"source": "theme",
+			"content": [
+				{
+					"_type": "block",
+					"style": "normal",
+					"children": [
+						{
+							"_type": "span",
+							"text": "A software developer who writes about building things on the web. Based somewhere with good coffee and reliable internet."
+						}
+					]
+				}
+			]
+		}
+	],
+
+	"content": {
+		"pages": [
+			{
+				"id": "about",
+				"slug": "about",
+				"status": "published",
+				"data": {
+					"title": "About",
+					"content": [
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "A place for writing about software, design, and the occasional stray thought. No posting schedule, no newsletter funnel. Just things I wanted to write down."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "Built with Astro and EmDash. The source is open if you want to see how it works."
+								}
+							]
+						}
+					]
+				}
+			}
+		],
+		"posts": [
+			{
+				"id": "post-1",
+				"slug": "building-for-the-long-term",
+				"status": "published",
+				"data": {
+					"title": "Building for the Long Term",
+					"excerpt": "The frameworks will change. The databases will change. What survives is the clarity of your thinking.",
+					"featured_image": {
+						"$media": {
+							"url": "https://images.unsplash.com/photo-1461749280684-dccba630e2f6?w=1200&h=800&fit=crop",
+							"alt": "Code on a monitor in a dark room",
+							"filename": "building-long-term.jpg"
+						}
+					},
+					"content": [
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "Every few years the industry collectively decides that everything we've been doing is wrong and there's a better way. New frameworks, new paradigms, new build tools. The churn is relentless, and if you're not careful, you spend more time migrating than building."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "I've been writing software long enough to have seen several of these cycles. jQuery to Backbone to Angular to React to whatever comes next. Each transition felt urgent at the time. Looking back, the things that actually mattered were rarely about the framework."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "h2",
+							"children": [{ "_type": "span", "text": "What survives" }]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "Clean data models survive. Clear boundaries between systems survive. Good naming survives. The decision to keep things simple when you could have made them clever - that definitely survives."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "What doesn't survive is code that was written to impress, abstractions built for problems that never materialized, and architectures designed around a framework's opinions rather than the domain's reality."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "The best code I've written is boring. It reads like prose, does one thing well, and doesn't require a PhD in category theory to understand. The worst code I've written was technically impressive at the time."
+								}
+							]
+						}
+					]
+				},
+				"bylines": [
+					{ "byline": "byline-editorial" },
+					{ "byline": "byline-guest", "roleLabel": "Guest essay" }
+				],
+				"taxonomies": {
+					"category": ["development"],
+					"tag": ["opinion"]
+				}
+			},
+			{
+				"id": "post-2",
+				"slug": "the-case-for-static",
+				"status": "published",
+				"data": {
+					"title": "The Case for Static",
+					"excerpt": "Static sites aren't a step backwards. They're what you get when you take performance and simplicity seriously.",
+					"featured_image": {
+						"$media": {
+							"url": "https://images.unsplash.com/photo-1499750310107-5fef28a66643?w=1200&h=800&fit=crop",
+							"alt": "Laptop and coffee on a wooden table",
+							"filename": "case-for-static.jpg"
+						}
+					},
+					"content": [
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "There's a certain irony in the fact that the web started static, went dynamic, and is now swinging back toward static again. But the static sites of today aren't the hand-coded HTML pages of 1998. They're generated, optimized, and deployed to edge networks that serve them in milliseconds."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "The pitch for server-rendered everything was compelling: dynamic content, personalization, real-time data. But most sites don't need most of that most of the time. A blog post doesn't need to be rendered on every request. A product page doesn't change every second."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "h2",
+							"children": [{ "_type": "span", "text": "The performance argument" }]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "A static file served from a CDN is as fast as the web gets. No cold starts, no database queries, no server-side rendering overhead. The Time to First Byte is essentially the network latency to your nearest edge node. You can't beat physics."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "And when you do need dynamic behavior, you can add it surgically. An island of interactivity in a sea of static HTML. The best of both worlds, without paying the cost of either at all times."
+								}
+							]
+						}
+					]
+				},
+				"bylines": [{ "byline": "byline-editorial" }],
+				"taxonomies": {
+					"category": ["development"],
+					"tag": ["webdev", "opinion"]
+				}
+			},
+			{
+				"id": "post-3",
+				"slug": "learning-in-public",
+				"status": "published",
+				"data": {
+					"title": "Learning in Public",
+					"excerpt": "Writing about what you're learning is the fastest way to find out what you don't actually understand.",
+					"featured_image": {
+						"$media": {
+							"url": "https://images.unsplash.com/photo-1432821596592-e2c18b78144f?w=1200&h=800&fit=crop",
+							"alt": "Notebook and pen on a desk",
+							"filename": "learning-in-public.jpg"
+						}
+					},
+					"content": [
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "I started writing about things I was learning not because I had anything original to say, but because I kept forgetting what I'd figured out. The blog posts were notes to my future self, published publicly more out of laziness than courage."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "What I didn't expect was how much the writing itself would accelerate the learning. There's a particular kind of clarity that comes from trying to explain something to someone else. The gaps in your understanding, which you can happily ignore when the knowledge lives only in your head, become painfully obvious when you try to put it into sentences."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "h2",
+							"children": [{ "_type": "span", "text": "The fear of being wrong" }]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "The biggest barrier isn't time or writing skill. It's the fear of publishing something that turns out to be wrong. But here's the thing: being wrong publicly is one of the most efficient ways to learn. Someone will correct you, often kindly, and you'll remember that correction forever."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "The posts that helped me most weren't written by experts. They were written by people one step ahead of me on the same path, in language that hadn't yet been polished into abstraction. There's a place for that kind of writing, and it's more valuable than most people realize."
+								}
+							]
+						}
+					]
+				},
+				"taxonomies": {
+					"category": ["notes"],
+					"tag": ["opinion"]
+				}
+			},
+			{
+				"id": "post-4",
+				"slug": "small-tools-big-impact",
+				"status": "published",
+				"data": {
+					"title": "Small Tools, Big Impact",
+					"excerpt": "The best developer tools do one thing well and get out of your way. A love letter to focused software.",
+					"featured_image": {
+						"$media": {
+							"url": "https://images.unsplash.com/photo-1575026615908-666710ae5e47?w=1200&h=800&fit=crop",
+							"alt": "Wrenches and hand tools hanging on a workshop wall",
+							"filename": "small-tools.jpg"
+						}
+					},
+					"content": [
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "There's a class of software that doesn't get enough appreciation. Not the frameworks or the platforms or the IDEs, but the small, sharp tools that solve one problem so well you stop thinking about them. They become invisible, which is the highest compliment you can pay a tool."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "I'm talking about things like ripgrep, which searches code so fast it changed how I think about searching. Or jq, which makes JSON feel like a first-class data format in the terminal. Or curl, which has been quietly powering the internet's plumbing for decades."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "h2",
+							"children": [{ "_type": "span", "text": "The Unix philosophy, revisited" }]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "Do one thing well. The advice is old enough to be a cliche, but the best modern tools still follow it. They don't try to be platforms. They don't have plugin ecosystems or configuration languages or startup wizards. They do their job and they compose with other tools that do theirs."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "The temptation is always to add more. One more feature, one more option, one more integration. But every addition is a decision someone has to make, a path through the code that has to be maintained, a thing that can break. The best tools resist this. They stay small, and in staying small, they stay reliable."
+								}
+							]
+						}
+					]
+				},
+				"taxonomies": {
+					"category": ["development"],
+					"tag": ["tools"]
+				}
+			},
+			{
+				"id": "post-5",
+				"slug": "designing-with-constraints",
+				"status": "published",
+				"data": {
+					"title": "Designing with Constraints",
+					"excerpt": "Limitations aren't obstacles to creativity. They're the structure that makes creativity possible.",
+					"featured_image": {
+						"$media": {
+							"url": "https://images.unsplash.com/photo-1513542789411-b6a5d4f31634?w=1200&h=800&fit=crop",
+							"alt": "Pencils and design tools on a desk",
+							"filename": "designing-with-constraints.jpg"
+						}
+					},
+					"content": [
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "Give a designer a blank canvas and unlimited time, and they'll often produce something mediocre. Give them a tight brief, a small screen, and a deadline, and they'll surprise you. This isn't a paradox - it's how creativity actually works."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "Constraints force decisions. When you can't use more than two typefaces, you have to choose carefully. When the page has to load in under a second, every element earns its place. When the interface has to work on a 320px screen, you discover what's truly essential."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "h2",
+							"children": [{ "_type": "span", "text": "Embracing the box" }]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "The web itself is a constraint. HTML flows in one direction. CSS has a box model. Browsers have viewport sizes and font rendering quirks. You can fight these constraints or you can work with them, and the results are dramatically different."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "The designs I admire most don't look like they were forced through a framework. They look like they grew naturally from the medium, respecting its grain rather than working against it. That only happens when you treat constraints as creative partners rather than enemies."
+								}
+							]
+						}
+					]
+				},
+				"taxonomies": {
+					"category": ["design"],
+					"tag": ["creativity"]
+				}
+			},
+			{
+				"id": "post-6",
+				"slug": "a-weekend-with-a-side-project",
+				"status": "published",
+				"data": {
+					"title": "A Weekend with a Side Project",
+					"excerpt": "No stakeholders, no deadlines, no Jira tickets. Just you and a dumb idea that might turn into something.",
+					"featured_image": {
+						"$media": {
+							"url": "https://images.unsplash.com/photo-1542831371-29b0f74f9713?w=1200&h=800&fit=crop",
+							"alt": "Code on a screen with a dark theme",
+							"filename": "weekend-side-project.jpg"
+						}
+					},
+					"content": [
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "Saturday morning. Coffee's made, the house is quiet, and I've got an idea that's been nagging at me all week. Not a good idea, necessarily - just a persistent one. A small tool that does a thing I keep doing manually. How hard could it be?"
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "This is the best kind of programming. No requirements document, no sprint planning, no pull request reviews. Just a text editor and a problem. The freedom to make terrible architectural decisions, rewrite everything twice, and follow tangents that turn out to be dead ends."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "h2",
+							"children": [{ "_type": "span", "text": "Why side projects matter" }]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "Side projects are where you learn things your day job would never teach you. Not because the problems are harder, but because you're free to take risks. Try a language you've never used. Build something without a framework. Deploy to a platform you've only read about. The stakes are zero, which makes the learning maximum."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "By Sunday evening, the thing sort of works. It's rough, the error handling is nonexistent, and the README is a single sentence. But it solves the problem I set out to solve, and I learned three things I didn't know on Friday. Not a bad weekend."
+								}
+							]
+						}
+					]
+				},
+				"taxonomies": {
+					"category": ["development"],
+					"tag": ["creativity"]
+				}
+			},
+			{
+				"id": "post-7",
+				"slug": "notes-on-simplicity",
+				"status": "published",
+				"data": {
+					"title": "Notes on Simplicity",
+					"excerpt": "Simplicity isn't the absence of complexity. It's the result of understanding a problem well enough to solve it cleanly.",
+					"featured_image": {
+						"$media": {
+							"url": "https://images.unsplash.com/photo-1559051668-e1fa58f25786?w=1200&h=800&fit=crop",
+							"alt": "Geometric pattern carved into white paper",
+							"filename": "notes-on-simplicity.jpg"
+						}
+					},
+					"content": [
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "Every piece of software starts simple. A few files, a clear purpose, a small surface area. Then features get added, edge cases get handled, and before long you're looking at something that requires a diagram to understand. This isn't inevitable, but it takes discipline to prevent."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "The hard part of simplicity isn't the initial design. It's the ongoing resistance to complication. Every feature request, every bug fix, every refactor is an opportunity to add complexity. Saying no is the most important design skill, and the least celebrated."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "h2",
+							"children": [{ "_type": "span", "text": "Removing as a feature" }]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "The best version of a product often has fewer features than the previous one. Not because features were missing, but because someone had the courage to remove things that weren't earning their keep. Every feature has a cost - in maintenance, in cognitive load, in the weight of the interface."
+								}
+							]
+						},
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "Simplicity is a practice, not a destination. You never arrive at simple. You just keep asking: is this necessary? Could this be clearer? Is there a way to solve this problem by removing something instead of adding something? The answer is yes more often than you'd expect."
+								}
+							]
+						}
+					]
+				},
+				"taxonomies": {
+					"category": ["notes"],
+					"tag": ["opinion"]
+				}
+			},
+			{
+				"id": "post-draft",
+				"slug": "work-in-progress",
+				"status": "draft",
+				"data": {
+					"title": "Work in Progress",
+					"excerpt": "This post is still being written.",
+					"content": [
+						{
+							"_type": "block",
+							"style": "normal",
+							"children": [
+								{
+									"_type": "span",
+									"text": "This is a draft post that won't appear in the public listing."
+								}
+							]
+						}
+					]
+				}
+			}
+		]
+	}
+}

templates/blog/src/components/PostCard.astro

@@ -0,0 +1,279 @@
+---
+import type { MediaValue, ContentBylineCredit } from "emdash";
+import { Image } from "emdash/ui";
+
+interface Props {
+	title: string;
+	excerpt?: string;
+	featuredImage?: MediaValue | string;
+	href: string;
+	date?: Date;
+	readingTime?: number;
+	tags?: Array<{ slug: string; label: string }>;
+	bylines?: ContentBylineCredit[];
+}
+
+const {
+	title,
+	excerpt,
+	featuredImage,
+	href,
+	date,
+	readingTime,
+	tags,
+	bylines,
+} = Astro.props;
+
+const formattedDate = date
+	? date.toLocaleDateString("en-US", {
+			year: "numeric",
+			month: "short",
+			day: "numeric",
+		})
+	: null;
+---
+
+<article class="post-card">
+	<a href={href} class="card-link">
+		{
+			featuredImage ? (
+				<div class="card-image">
+					<Image image={featuredImage} />
+				</div>
+			) : (
+				<div class="card-placeholder" />
+			)
+		}
+		<div class="card-body">
+			<div class="card-meta">
+				{
+					bylines && bylines.length > 0 && (
+						<>
+							<div class="card-bylines">
+								{bylines.slice(0, 1).map((credit) => (
+									<span class="card-byline">
+										{credit.byline.avatarMediaId && (
+											<img
+												src={`/_emdash/api/media/file/${credit.byline.avatarMediaId}`}
+												alt={credit.byline.displayName}
+												class="card-byline-avatar"
+											/>
+										)}
+										<span class="card-byline-name">
+											{credit.byline.displayName}
+										</span>
+									</span>
+								))}
+								{bylines.length > 1 && (
+									<span
+										class="byline-more"
+										data-tooltip={bylines
+											.slice(1)
+											.map((c) => c.byline.displayName)
+											.join(", ")}
+										title={bylines
+											.slice(1)
+											.map((c) => c.byline.displayName)
+											.join(", ")}
+										tabindex="0"
+									>
+										+{bylines.length - 1}
+									</span>
+								)}
+							</div>
+							{(formattedDate || readingTime) && <span class="meta-dot" />}
+						</>
+					)
+				}
+				{formattedDate && <time>{formattedDate}</time>}
+				{formattedDate && readingTime && <span class="meta-dot" />}
+				{readingTime && <span>{readingTime} min</span>}
+			</div>
+			<h2 class="card-title">{title}</h2>
+			{excerpt && <p class="card-excerpt">{excerpt}</p>}
+		</div>
+	</a>
+	{
+		tags && tags.length > 0 && (
+			<div class="card-tags">
+				{tags.slice(0, 2).map((tag) => (
+					<a href={`/tag/${tag.slug}`} class="card-tag">
+						{tag.label}
+					</a>
+				))}
+			</div>
+		)
+	}
+</article>
+
+<style>
+	.post-card {
+		display: flex;
+		flex-direction: column;
+	}
+
+	.card-link {
+		display: block;
+		text-decoration: none;
+		color: inherit;
+	}
+
+	.card-image {
+		aspect-ratio: 16 / 10;
+		overflow: hidden;
+		border-radius: var(--radius-lg);
+		background: var(--color-surface);
+		margin-bottom: var(--spacing-4);
+	}
+
+	.card-image img {
+		width: 100%;
+		height: 100%;
+		object-fit: cover;
+		transition: transform 0.3s ease;
+	}
+
+	.card-link:hover .card-image img {
+		transform: scale(1.03);
+	}
+
+	.card-placeholder {
+		aspect-ratio: 16 / 10;
+		border-radius: var(--radius-lg);
+		background: var(--color-surface);
+		margin-bottom: var(--spacing-4);
+	}
+
+	.card-body {
+		flex: 1;
+	}
+
+	.card-meta {
+		display: flex;
+		align-items: center;
+		flex-wrap: wrap;
+		column-gap: var(--spacing-2);
+		row-gap: 0;
+		font-size: var(--font-size-sm);
+		color: var(--color-muted);
+		margin-bottom: var(--spacing-2);
+	}
+
+	.card-meta time,
+	.card-meta span:not(.meta-dot) {
+		white-space: nowrap;
+	}
+
+	.meta-dot {
+		width: 3px;
+		height: 3px;
+		border-radius: 50%;
+		background: var(--color-muted);
+	}
+
+	.card-title {
+		font-size: var(--font-size-xl);
+		font-weight: 600;
+		line-height: var(--leading-snug);
+		letter-spacing: var(--tracking-snug);
+		margin-bottom: var(--spacing-2);
+		transition: color var(--transition-fast);
+	}
+
+	.card-link:hover .card-title {
+		color: var(--color-accent);
+	}
+
+	.card-excerpt {
+		font-size: var(--font-size-base);
+		line-height: var(--leading-relaxed);
+		color: var(--color-text-secondary);
+		display: -webkit-box;
+		-webkit-line-clamp: 2;
+		-webkit-box-orient: vertical;
+		overflow: hidden;
+	}
+
+	.card-tags {
+		display: flex;
+		flex-wrap: wrap;
+		gap: var(--spacing-2);
+		margin-top: var(--spacing-3);
+	}
+
+	.card-tag {
+		display: inline-block;
+		padding: var(--tag-padding-y) var(--spacing-2);
+		font-size: var(--font-size-xs);
+		color: var(--color-muted);
+		background: var(--color-surface);
+		border-radius: var(--radius);
+		text-decoration: none;
+		transition:
+			color var(--transition-fast),
+			background var(--transition-fast);
+	}
+
+	.card-tag:hover {
+		color: var(--color-text);
+		background: var(--color-border);
+	}
+
+	/* Byline styles */
+	.card-bylines {
+		display: flex;
+		align-items: center;
+		gap: 2px;
+		white-space: nowrap;
+	}
+
+	.card-byline {
+		display: inline-flex;
+		align-items: center;
+		gap: var(--spacing-1);
+	}
+
+	.card-byline-avatar {
+		width: var(--avatar-size-xs);
+		height: var(--avatar-size-xs);
+		border-radius: 50%;
+		object-fit: cover;
+	}
+
+	.card-byline-name {
+		font-weight: 500;
+		color: var(--color-text-secondary);
+	}
+
+	.byline-more {
+		position: relative;
+		font-size: var(--font-size-xs);
+		color: var(--color-muted);
+		margin-left: 2px;
+		cursor: default;
+		border-radius: var(--radius);
+		outline-offset: 2px;
+	}
+
+	.byline-more:focus-visible {
+		outline: 2px solid var(--color-accent);
+	}
+
+	.byline-more[data-tooltip]:hover::after,
+	.byline-more[data-tooltip]:focus-visible::after {
+		content: attr(data-tooltip);
+		position: absolute;
+		bottom: calc(100% + 6px);
+		left: 50%;
+		transform: translateX(-50%);
+		white-space: nowrap;
+		background: var(--color-text);
+		color: var(--color-bg);
+		font-size: var(--font-size-xs);
+		font-weight: 400;
+		padding: var(--spacing-1) var(--spacing-2);
+		border-radius: var(--radius);
+		pointer-events: none;
+		z-index: 10;
+	}
+</style>

templates/blog/src/components/TagList.astro

@@ -0,0 +1,45 @@
+---
+interface Props {
+  tags: Array<{ slug: string; label: string }>;
+  class?: string;
+}
+
+const { tags, class: className } = Astro.props;
+---
+
+{tags.length > 0 && (
+  <ul class:list={["tag-list", className]}>
+    {tags.map((tag) => (
+      <li>
+        <a href={`/tag/${tag.slug}`} class="tag">{tag.label}</a>
+      </li>
+    ))}
+  </ul>
+)}
+
+<style>
+  .tag-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--spacing-2);
+    list-style: none;
+    padding: 0;
+    margin: 0;
+  }
+
+  .tag {
+    display: inline-block;
+    padding: var(--tag-padding-y) var(--spacing-3);
+    font-size: var(--font-size-sm);
+    color: var(--color-text-secondary);
+    background: var(--color-surface);
+    border-radius: var(--radius);
+    text-decoration: none;
+    transition: color var(--transition-fast), background var(--transition-fast);
+  }
+
+  .tag:hover {
+    color: var(--color-text);
+    background: var(--color-border);
+  }
+</style>

templates/blog/src/layouts/Base.astro

@@ -0,0 +1,985 @@
+---
+import { getMenu, getEmDashCollection } from "emdash";
+import {
+	WidgetArea,
+	EmDashHead,
+	EmDashBodyStart,
+	EmDashBodyEnd,
+} from "emdash/ui";
+import { createPublicPageContext } from "emdash/page";
+import LiveSearch from "emdash/ui/search";
+import "../styles/theme.css";
+
+interface Props {
+	title: string;
+	description?: string | null;
+	image?: string | null;
+	canonical?: string | null;
+	robots?: string | null;
+	type?: "website" | "article";
+	publishedTime?: string | null;
+	modifiedTime?: string | null;
+	author?: string | null;
+	/** Pass content reference for plugin page contributions on content pages */
+	content?: { collection: string; id: string; slug?: string | null };
+}
+
+const {
+	title,
+	description,
+	image,
+	canonical,
+	robots,
+	type = "website",
+	publishedTime,
+	modifiedTime,
+	author,
+	content,
+} = Astro.props;
+const siteTitle = "My Blog";
+// If title already includes site title (from getSeoMeta), use as-is
+const fullTitle = title.includes(siteTitle) ? title : `${title} — ${siteTitle}`;
+
+// Fetch primary menu defined in seed
+const menu = await getMenu("primary");
+
+// Fetch pages for footer
+const { entries: pages } = await getEmDashCollection("pages");
+
+// Build public page context for plugin contributions
+// SEO data is passed here and rendered securely by EmDashHead
+const pageCtx = createPublicPageContext({
+	Astro,
+	kind: content ? "content" : "custom",
+	pageType: type,
+	title: fullTitle,
+	description,
+	canonical,
+	image,
+	content,
+	seo: { ogImage: image, robots },
+	articleMeta: { publishedTime, modifiedTime, author },
+	siteName: siteTitle,
+});
+
+// Check if user is logged in (for showing admin link)
+const isLoggedIn = !!Astro.locals.user;
+---
+
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<link rel="preconnect" href="https://fonts.googleapis.com" />
+		<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+		<link
+			href="https://fonts.googleapis.com/css2?family=Inter:opsz,wght@14..32,400;14..32,500;14..32,600;14..32,700&family=JetBrains+Mono:wght@400;500&display=swap"
+			rel="stylesheet"
+		/>
+		<title>{fullTitle}</title>
+		<EmDashHead page={pageCtx} />
+		<script is:inline>
+			// Apply theme immediately to prevent flash
+			(function () {
+				var c = document.cookie;
+				var i = c.indexOf("theme=");
+				var theme = i >= 0 ? c.slice(i + 6).split(";")[0] : null;
+				if (theme === "dark" || theme === "light") {
+					document.documentElement.classList.add(theme);
+				} else if (window.matchMedia("(prefers-color-scheme: dark)").matches) {
+					document.documentElement.classList.add("dark");
+				}
+			})();
+		</script>
+	</head>
+	<body>
+		<EmDashBodyStart page={pageCtx} />
+		<header class="site-header">
+			<nav class="nav">
+				<a href="/" class="site-title">{siteTitle}</a>
+				<div class="nav-right">
+					<LiveSearch
+						placeholder="Search..."
+						class="site-search"
+						inputClass="site-search-input"
+						resultsClass="site-search-results"
+						resultClass="site-search-result"
+						collections={["posts", "pages"]}
+					/>
+					<div class="nav-links">
+						{
+							menu?.items.map((item) => (
+								<a href={item.url} target={item.target}>
+									{item.label}
+								</a>
+							))
+						}
+					</div>
+					{
+						isLoggedIn && (
+							<a href="/_emdash/admin" class="nav-admin">
+								Admin
+							</a>
+						)
+					}
+				</div>
+			</nav>
+		</header>
+
+		<main>
+			<slot />
+		</main>
+
+		<footer class="site-footer">
+			<div class="footer-inner">
+				<div class="footer-grid">
+					<div class="footer-brand">
+						<a href="/" class="footer-logo">{siteTitle}</a>
+						<p class="footer-tagline">Thoughts, stories, and ideas.</p>
+					</div>
+					<div class="footer-nav">
+						<h4 class="footer-heading">Navigate</h4>
+						<ul class="footer-links">
+							<li><a href="/">Home</a></li>
+							<li><a href="/posts">All Posts</a></li>
+							{
+								pages.slice(0, 3).map((page) => (
+									<li>
+										<a href={`/pages/${page.data.slug || page.id}`}>
+											{page.data.title}
+										</a>
+									</li>
+								))
+							}
+						</ul>
+					</div>
+					<div class="footer-nav">
+						<h4 class="footer-heading">Connect</h4>
+						<ul class="footer-links">
+							{
+								menu?.items.map((item) => (
+									<li>
+										<a
+											href={item.url}
+											target={item.target}
+											rel={
+												item.target === "_blank"
+													? "noopener noreferrer"
+													: undefined
+											}
+										>
+											{item.label}
+										</a>
+									</li>
+								))
+							}
+							<li><a href="/rss.xml">RSS Feed</a></li>
+						</ul>
+					</div>
+					<div class="footer-widgets-section">
+						<WidgetArea name="footer" />
+					</div>
+				</div>
+				<div class="footer-bottom">
+					<p class="footer-copyright">
+						Powered by <a href="https://emdashcms.com">EmDash</a>
+					</p>
+					<div class="theme-switcher">
+						<button
+							type="button"
+							class="theme-btn"
+							data-theme="light"
+							aria-label="Light mode"
+						>
+							<svg
+								width="16"
+								height="16"
+								viewBox="0 0 24 24"
+								fill="none"
+								stroke="currentColor"
+								stroke-width="2"
+								stroke-linecap="round"
+								stroke-linejoin="round"
+								><circle cx="12" cy="12" r="5"></circle><line
+									x1="12"
+									y1="1"
+									x2="12"
+									y2="3"></line><line x1="12" y1="21" x2="12" y2="23"
+								></line><line x1="4.22" y1="4.22" x2="5.64" y2="5.64"
+								></line><line x1="18.36" y1="18.36" x2="19.78" y2="19.78"
+								></line><line x1="1" y1="12" x2="3" y2="12"></line><line
+									x1="21"
+									y1="12"
+									x2="23"
+									y2="12"></line><line x1="4.22" y1="19.78" x2="5.64" y2="18.36"
+								></line><line x1="18.36" y1="5.64" x2="19.78" y2="4.22"
+								></line></svg
+							>
+						</button>
+						<button
+							type="button"
+							class="theme-btn"
+							data-theme="dark"
+							aria-label="Dark mode"
+						>
+							<svg
+								width="16"
+								height="16"
+								viewBox="0 0 24 24"
+								fill="none"
+								stroke="currentColor"
+								stroke-width="2"
+								stroke-linecap="round"
+								stroke-linejoin="round"
+								><path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z"
+								></path></svg
+							>
+						</button>
+						<button
+							type="button"
+							class="theme-btn"
+							data-theme="system"
+							aria-label="System theme"
+						>
+							<svg
+								width="16"
+								height="16"
+								viewBox="0 0 24 24"
+								fill="none"
+								stroke="currentColor"
+								stroke-width="2"
+								stroke-linecap="round"
+								stroke-linejoin="round"
+								><rect x="2" y="3" width="20" height="14" rx="2" ry="2"
+								></rect><line x1="8" y1="21" x2="16" y2="21"></line><line
+									x1="12"
+									y1="17"
+									x2="12"
+									y2="21"></line></svg
+							>
+						</button>
+					</div>
+				</div>
+			</div>
+		</footer>
+
+		<script>
+			// Theme switcher
+			const THEME_REGEX = /theme=([^;]+)/;
+			const themeBtns =
+				document.querySelectorAll<HTMLButtonElement>(".theme-btn");
+			const root = document.documentElement;
+
+			function setCookie(
+				name: string,
+				value: string,
+				maxAge: number = 31536000
+			) {
+				const secure = location.protocol === "https:" ? "; Secure" : "";
+				if (value === "") {
+					document.cookie = `${name}=; path=/; max-age=0; SameSite=Lax${secure}`;
+				} else {
+					document.cookie = `${name}=${value}; path=/; max-age=${maxAge}; SameSite=Lax${secure}`;
+				}
+			}
+
+			function setTheme(theme: string) {
+				if (theme === "system") {
+					setCookie("theme", "");
+					root.classList.remove("light", "dark");
+					if (window.matchMedia("(prefers-color-scheme: dark)").matches) {
+						root.classList.add("dark");
+					}
+				} else {
+					setCookie("theme", theme);
+					root.classList.remove("light", "dark");
+					root.classList.add(theme);
+				}
+				updateActiveBtn(theme);
+			}
+
+			function updateActiveBtn(theme: string) {
+				themeBtns.forEach((btn) => {
+					btn.classList.toggle("active", btn.dataset.theme === theme);
+				});
+			}
+
+			function getStoredTheme(): string {
+				const match = document.cookie.match(THEME_REGEX);
+				return match ? match[1] : "system";
+			}
+
+			// Initialize
+			const storedTheme = getStoredTheme();
+			setTheme(storedTheme);
+
+			themeBtns.forEach((btn) => {
+				btn.addEventListener("click", () => {
+					setTheme(btn.dataset.theme || "system");
+				});
+			});
+
+			// Listen for system preference changes
+			window
+				.matchMedia("(prefers-color-scheme: dark)")
+				.addEventListener("change", (e) => {
+					if (getStoredTheme() === "system") {
+						root.classList.toggle("dark", e.matches);
+					}
+				});
+		</script>
+
+		<style is:global>
+			*:where(:not([class*="emdash"]):not([class*="ec-"])),
+			*:where(:not([class*="emdash"]):not([class*="ec-"]))::before,
+			*:where(:not([class*="emdash"]):not([class*="ec-"]))::after {
+				box-sizing: border-box;
+			}
+
+			body,
+			h1,
+			h2,
+			h3,
+			h4,
+			h5,
+			h6,
+			p,
+			ul,
+			ol,
+			figure,
+			blockquote,
+			dl,
+			dd {
+				margin: 0;
+			}
+
+			ul,
+			ol {
+				padding: 0;
+			}
+
+			:root {
+				/* Colors - Light mode (default) */
+				--color-bg: #ffffff;
+				--color-bg-subtle: #fafafa;
+				--color-text: #1a1a1a;
+				--color-text-secondary: #525252;
+				--color-muted: #8b8b8b;
+				--color-border: #e5e5e5;
+				--color-border-subtle: #f0f0f0;
+				--color-surface: #f7f7f7;
+				--color-accent: #0066cc;
+				--color-accent-hover: #0052a3;
+				--color-on-accent: white;
+				--color-accent-ring: color-mix(
+					in srgb,
+					var(--color-accent) 25%,
+					transparent
+				);
+
+				/* EmDash search theming */
+				--emdash-search-bg: var(--color-bg);
+				--emdash-search-text: var(--color-text);
+				--emdash-search-muted: var(--color-muted);
+				--emdash-search-border: var(--color-border);
+				--emdash-search-hover: var(--color-surface);
+				--emdash-search-highlight: var(--color-text);
+
+				/* Typography */
+				--font-sans:
+					"Inter", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,
+					sans-serif;
+				--font-mono:
+					"JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, monospace;
+
+				/* Type scale - more refined */
+				--font-size-xs: 0.8125rem;
+				--font-size-sm: 0.875rem;
+				--font-size-base: 1rem;
+				--font-size-lg: 1.125rem;
+				--font-size-xl: 1.25rem;
+				--font-size-2xl: 1.5rem;
+				--font-size-3xl: 2rem;
+				--font-size-4xl: 2.5rem;
+				--font-size-5xl: 3.5rem;
+
+				/* Line heights */
+				--leading-tight: 1.15;
+				--leading-snug: 1.3;
+				--leading-normal: 1.5;
+				--leading-relaxed: 1.7;
+
+				/* Spacing - more generous */
+				--spacing-1: 0.25rem;
+				--spacing-2: 0.5rem;
+				--spacing-3: 0.75rem;
+				--spacing-4: 1rem;
+				--spacing-5: 1.25rem;
+				--spacing-6: 1.5rem;
+				--spacing-8: 2rem;
+				--spacing-10: 2.5rem;
+				--spacing-12: 3rem;
+				--spacing-16: 4rem;
+				--spacing-20: 5rem;
+				--spacing-24: 6rem;
+
+				/* Legacy spacing aliases */
+				--spacing-xs: var(--spacing-1);
+				--spacing-sm: var(--spacing-2);
+				--spacing-md: var(--spacing-4);
+				--spacing-lg: var(--spacing-6);
+				--spacing-xl: var(--spacing-8);
+				--spacing-2xl: var(--spacing-12);
+				--spacing-3xl: var(--spacing-16);
+
+				/* Layout - wider for three-column */
+				--content-width: 680px;
+				--wide-width: 1200px;
+				--max-width: var(--content-width);
+				--gutter-width: 200px;
+				--radius: 4px;
+				--radius-lg: 8px;
+
+				/* Transitions */
+				--transition-fast: 120ms ease;
+				--transition-base: 180ms ease;
+
+				/* Nav */
+				--nav-height: 64px;
+
+				/* Search */
+				--search-input-width: 180px;
+
+				/* Article layout */
+				--meta-col-width: 180px;
+
+				/* Avatar sizes */
+				--avatar-size-xs: 18px;
+				--avatar-size-sm: 20px;
+				--avatar-size-md: 24px;
+				--avatar-size-lg: 32px;
+
+				/* Letter spacing */
+				--tracking-tight: -0.03em;
+				--tracking-snug: -0.02em;
+				--tracking-wide: 0.06em;
+				--tracking-wider: 0.08em;
+
+				/* Tag pill */
+				--tag-padding-y: 2px;
+
+				/* Shadows */
+				--shadow-dropdown: 0 8px 30px rgba(0, 0, 0, 0.12);
+				--shadow-btn-active: 0 1px 2px rgba(0, 0, 0, 0.05);
+			}
+
+			/* Dark mode via system preference (when no explicit class) */
+			@media (prefers-color-scheme: dark) {
+				:root:not(.light) {
+					--color-bg: #0d0d0d;
+					--color-bg-subtle: #141414;
+					--color-text: #ededed;
+					--color-text-secondary: #a0a0a0;
+					--color-muted: #6b6b6b;
+					--color-border: #2a2a2a;
+					--color-border-subtle: #1f1f1f;
+					--color-surface: #181818;
+					--color-accent: #4d9fff;
+					--color-accent-hover: #6eb0ff;
+				}
+			}
+
+			/* Explicit dark mode */
+			:root.dark {
+				--color-bg: #0d0d0d;
+				--color-bg-subtle: #141414;
+				--color-text: #ededed;
+				--color-text-secondary: #a0a0a0;
+				--color-muted: #6b6b6b;
+				--color-border: #2a2a2a;
+				--color-border-subtle: #1f1f1f;
+				--color-surface: #181818;
+				--color-accent: #4d9fff;
+				--color-accent-hover: #6eb0ff;
+			}
+
+			html {
+				scroll-behavior: smooth;
+			}
+
+			body {
+				font-family: var(--font-sans);
+				font-size: var(--font-size-base);
+				line-height: var(--leading-relaxed);
+				color: var(--color-text);
+				background: var(--color-bg);
+				-webkit-font-smoothing: antialiased;
+				-moz-osx-font-smoothing: grayscale;
+				min-height: 100vh;
+			}
+
+			a:where(:not([class*="emdash"]):not([class*="ec-"])) {
+				color: var(--color-accent);
+				text-decoration: none;
+				transition: color var(--transition-fast);
+			}
+
+			a:where(:not([class*="emdash"]):not([class*="ec-"])):hover {
+				color: var(--color-accent-hover);
+			}
+
+			img {
+				max-width: 100%;
+				height: auto;
+				display: block;
+			}
+
+			h1,
+			h2,
+			h3,
+			h4,
+			h5,
+			h6 {
+				font-family: var(--font-sans);
+				line-height: var(--leading-tight);
+				font-weight: 600;
+				letter-spacing: var(--tracking-snug);
+			}
+
+			h1 {
+				font-weight: 700;
+				letter-spacing: var(--tracking-tight);
+			}
+
+			::selection {
+				background: var(--color-accent);
+				color: white;
+			}
+		</style>
+
+		<style>
+			.site-header {
+				position: sticky;
+				top: 0;
+				z-index: 100;
+				background: color-mix(in srgb, var(--color-bg) 65%, transparent);
+				backdrop-filter: blur(12px);
+				-webkit-backdrop-filter: blur(12px);
+				border-bottom: 1px solid var(--color-border-subtle);
+			}
+
+			.nav {
+				display: flex;
+				justify-content: space-between;
+				align-items: center;
+				max-width: var(--wide-width);
+				margin: 0 auto;
+				padding: var(--spacing-4) var(--spacing-6);
+				height: var(--nav-height);
+			}
+
+			.site-title {
+				font-size: var(--font-size-lg);
+				font-weight: 600;
+				color: var(--color-text);
+				text-decoration: none;
+				letter-spacing: var(--tracking-snug);
+			}
+
+			.site-title:hover {
+				color: var(--color-accent);
+			}
+
+			.nav-right {
+				display: flex;
+				align-items: center;
+				gap: var(--spacing-6);
+			}
+
+			.nav-links {
+				display: flex;
+				gap: var(--spacing-5);
+				font-size: var(--font-size-sm);
+			}
+
+			.nav-links a {
+				text-decoration: none;
+				color: var(--color-text);
+				transition: color var(--transition-fast);
+			}
+
+			.nav-links a:hover {
+				color: var(--color-accent);
+			}
+
+			.nav-admin {
+				font-size: var(--font-size-sm);
+				color: var(--color-muted);
+				text-decoration: none;
+				opacity: 0.5;
+				transition: opacity var(--transition-fast);
+			}
+
+			.nav-admin:hover {
+				opacity: 1;
+			}
+
+			/* Search styling */
+			.site-search {
+				position: relative;
+				width: var(--search-input-width);
+				--emdash-search-border-focus: var(--color-accent);
+			}
+
+			:global(.site-search-input) {
+				width: var(--search-input-width);
+				padding: var(--spacing-2) var(--spacing-3);
+				font-family: var(--font-sans);
+				font-size: var(--font-size-sm);
+				border: 1px solid var(--color-border);
+				border-radius: var(--radius);
+				background: var(--color-bg);
+				color: var(--color-text);
+				transition:
+					border-color var(--transition-fast),
+					box-shadow var(--transition-fast);
+			}
+
+			:global(.site-search-input)::placeholder {
+				color: var(--color-muted);
+			}
+
+			:global(.site-search-input):focus,
+			:global(.site-search-input):focus-visible {
+				outline: none;
+				border-color: var(--color-accent) !important;
+				box-shadow: 0 0 0 3px var(--color-accent-ring);
+			}
+
+			:global(.site-search-results) {
+				position: absolute;
+				top: 100%;
+				left: 0;
+				right: 0;
+				margin-top: var(--spacing-2);
+				background: var(--color-bg);
+				border: 1px solid var(--color-border);
+				border-radius: var(--radius-lg);
+				box-shadow: var(--shadow-dropdown);
+				max-height: 400px;
+				overflow-y: auto;
+				z-index: 1000;
+			}
+
+			:global(.site-search-results .emdash-live-search-loading),
+			:global(.site-search-results .emdash-live-search-no-results) {
+				padding: var(--spacing-4);
+				text-align: center;
+				color: var(--color-muted);
+				font-size: var(--font-size-sm);
+			}
+
+			:global(.site-search-result) {
+				display: block;
+				padding: var(--spacing-3) var(--spacing-4);
+				text-decoration: none;
+				color: var(--color-text);
+				border-bottom: 1px solid var(--color-border-subtle);
+				transition: background var(--transition-fast);
+			}
+
+			:global(.site-search-result):last-child {
+				border-bottom: none;
+			}
+
+			:global(.site-search-result):hover,
+			:global(.site-search-result):focus,
+			:global(.site-search-result.focused) {
+				background: var(--color-surface);
+				outline: none;
+			}
+
+			:global(.site-search-result .emdash-live-search-result-title) {
+				display: block;
+				font-weight: 500;
+				font-size: var(--font-size-sm);
+			}
+
+			:global(.site-search-result .emdash-live-search-result-collection) {
+				display: block;
+				font-size: var(--font-size-xs);
+				color: var(--color-muted);
+				text-transform: uppercase;
+				letter-spacing: var(--tracking-wide);
+				margin-top: 2px;
+			}
+
+			:global(.site-search-result .emdash-live-search-result-snippet) {
+				display: block;
+				font-size: var(--font-size-sm);
+				color: var(--color-muted);
+				margin-top: var(--spacing-1);
+				line-height: var(--leading-snug);
+			}
+
+			:global(.site-search-result .emdash-live-search-result-snippet mark) {
+				font-weight: 600;
+				color: var(--color-text);
+			}
+
+			main {
+				min-height: calc(100vh - var(--nav-height) - 300px);
+			}
+
+			/* Footer */
+			.site-footer {
+				background: var(--color-bg-subtle);
+				border-top: 1px solid var(--color-border-subtle);
+			}
+
+			.footer-inner {
+				max-width: var(--wide-width);
+				margin: 0 auto;
+				padding: var(--spacing-16) var(--spacing-6) var(--spacing-8);
+			}
+
+			.footer-grid {
+				display: grid;
+				grid-template-columns: 2fr 1fr 1fr 1fr;
+				gap: var(--spacing-12);
+				margin-bottom: var(--spacing-12);
+			}
+
+			.footer-brand {
+				max-width: 280px;
+			}
+
+			.footer-logo {
+				font-size: var(--font-size-lg);
+				font-weight: 600;
+				color: var(--color-text);
+				text-decoration: none;
+				letter-spacing: var(--tracking-snug);
+			}
+
+			.footer-tagline {
+				margin-top: var(--spacing-3);
+				font-size: var(--font-size-sm);
+				color: var(--color-muted);
+				line-height: var(--leading-relaxed);
+			}
+
+			.footer-nav {
+				min-width: 0;
+			}
+
+			.footer-heading {
+				font-size: var(--font-size-xs);
+				font-weight: 500;
+				text-transform: uppercase;
+				letter-spacing: var(--tracking-wider);
+				color: var(--color-muted);
+				margin-bottom: var(--spacing-4);
+			}
+
+			.footer-links {
+				list-style: none;
+			}
+
+			.footer-links li {
+				margin-bottom: var(--spacing-2);
+			}
+
+			.footer-links a {
+				color: var(--color-text-secondary);
+				text-decoration: none;
+				font-size: var(--font-size-sm);
+				transition: color var(--transition-fast);
+			}
+
+			.footer-links a:hover {
+				color: var(--color-text);
+			}
+
+			.footer-widgets-section :global(.widget-area) {
+				display: block;
+			}
+
+			.footer-widgets-section :global(.widget) {
+				color: var(--color-text-secondary);
+			}
+
+			.footer-widgets-section :global(.widget__title) {
+				font-size: var(--font-size-xs);
+				font-weight: 500;
+				text-transform: uppercase;
+				letter-spacing: var(--tracking-wider);
+				color: var(--color-muted);
+				margin-bottom: var(--spacing-4);
+			}
+
+			.footer-widgets-section :global(.widget__content) {
+				color: var(--color-text-secondary);
+				font-size: var(--font-size-sm);
+				line-height: var(--leading-relaxed);
+			}
+
+			.footer-bottom {
+				display: flex;
+				justify-content: space-between;
+				align-items: center;
+				padding-top: var(--spacing-6);
+				border-top: 1px solid var(--color-border);
+			}
+
+			.footer-copyright {
+				font-size: var(--font-size-sm);
+				color: var(--color-muted);
+			}
+
+			.footer-copyright a {
+				color: var(--color-text-secondary);
+			}
+
+			/* Theme switcher */
+			.theme-switcher {
+				display: flex;
+				gap: var(--spacing-1);
+				padding: var(--spacing-1);
+				background: var(--color-surface);
+				border-radius: var(--radius);
+			}
+
+			.theme-btn {
+				display: flex;
+				align-items: center;
+				justify-content: center;
+				width: 32px;
+				height: 28px;
+				background: transparent;
+				border: none;
+				color: var(--color-muted);
+				border-radius: var(--radius);
+				cursor: pointer;
+				transition: all var(--transition-fast);
+			}
+
+			.theme-btn:hover {
+				color: var(--color-text-secondary);
+			}
+
+			.theme-btn.active {
+				background: var(--color-bg);
+				color: var(--color-text);
+				box-shadow: var(--shadow-btn-active);
+			}
+
+			.theme-btn svg {
+				width: 16px;
+				height: 16px;
+			}
+
+			@media (max-width: 900px) {
+				.footer-grid {
+					grid-template-columns: 1fr 1fr;
+					gap: var(--spacing-8);
+				}
+
+				.footer-brand {
+					grid-column: span 2;
+					max-width: none;
+				}
+			}
+
+			@media (max-width: 640px) {
+				.site-header {
+					position: relative;
+					border-bottom: none;
+				}
+
+				.nav {
+					flex-direction: row;
+					flex-wrap: wrap;
+					justify-content: space-between;
+					align-items: center;
+					height: auto;
+					gap: var(--spacing-2);
+					padding: var(--spacing-3) var(--spacing-4);
+				}
+
+				.site-title {
+					font-size: var(--font-size-base);
+				}
+
+				.nav-right {
+					display: contents;
+				}
+
+				.site-search {
+					order: 0;
+					max-width: 140px;
+				}
+
+				:global(.site-search-input) {
+					width: 140px !important;
+					padding: var(--spacing-1) var(--spacing-2) !important;
+					font-size: var(--font-size-sm) !important;
+				}
+
+				.nav-links {
+					order: 1;
+					width: 100%;
+					display: flex;
+					column-gap: var(--spacing-3);
+					row-gap: var(--spacing-1);
+					flex-wrap: wrap;
+					justify-content: flex-start;
+				}
+
+				.nav-admin {
+					order: 2;
+					position: absolute;
+					right: var(--spacing-4);
+					top: var(--spacing-3);
+					font-size: var(--font-size-xs);
+				}
+
+				.footer-grid {
+					grid-template-columns: 1fr;
+				}
+
+				.footer-brand {
+					grid-column: span 1;
+				}
+
+				.footer-bottom {
+					flex-direction: column;
+					gap: var(--spacing-4);
+					text-align: center;
+				}
+
+				.footer-controls {
+					flex-wrap: wrap;
+					justify-content: center;
+				}
+			}
+		</style>
+
+		<script>
+			// ⌘K / Ctrl+K to focus search
+			document.addEventListener("keydown", (e) => {
+				if ((e.metaKey || e.ctrlKey) && e.key === "k") {
+					e.preventDefault();
+					const searchInput = document.querySelector(
+						".site-search-input"
+					) as HTMLInputElement;
+					if (searchInput) {
+						searchInput.focus();
+					}
+				}
+			});
+		</script>
+		<EmDashBodyEnd page={pageCtx} />
+	</body>
+</html>

templates/blog/src/live.config.ts

@@ -0,0 +1,13 @@
+/**
+ * EmDash Live Content Collections
+ *
+ * Defines the _emdash collection that handles all content types from the database.
+ * Query specific types using getEmDashCollection() and getEmDashEntry().
+ */
+
+import { defineLiveCollection } from "astro:content";
+import { emdashLoader } from "emdash/runtime";
+
+export const collections = {
+	_emdash: defineLiveCollection({ loader: emdashLoader() }),
+};

templates/blog/src/pages/404.astro

@@ -0,0 +1,33 @@
+---
+import Base from "../layouts/Base.astro";
+---
+
+<Base title="Page not found">
+	<div class="not-found">
+		<h1>404</h1>
+		<p>The page you're looking for doesn't exist.</p>
+		<a href="/">Go back home</a>
+	</div>
+</Base>
+
+<style>
+	.not-found {
+		text-align: center;
+		padding: var(--spacing-24) var(--spacing-6);
+	}
+
+	.not-found h1 {
+		font-size: var(--font-size-5xl);
+		margin-bottom: var(--spacing-2);
+		color: var(--color-border);
+	}
+
+	.not-found p {
+		color: var(--color-muted);
+		margin-bottom: var(--spacing-6);
+	}
+
+	.not-found a {
+		color: var(--color-text);
+	}
+</style>

templates/blog/src/pages/category/[slug].astro

@@ -0,0 +1,117 @@
+---
+import { getTerm, getEmDashCollection, getEntryTerms } from "emdash";
+import Base from "../../layouts/Base.astro";
+import PostCard from "../../components/PostCard.astro";
+import { getReadingTime } from "../../utils/reading-time";
+
+const { slug } = Astro.params;
+const term = slug ? await getTerm("category", slug) : null;
+
+if (!term) {
+	return Astro.redirect("/404");
+}
+
+const { entries: posts } = await getEmDashCollection("posts", {
+	where: { category: term.slug },
+	orderBy: { published_at: "desc" },
+});
+
+// Fetch tags for display on each post card
+const filteredPosts = await Promise.all(
+	posts.map(async (post) => {
+		const tags = await getEntryTerms("posts", post.data.id, "tag");
+		return { post, tags };
+	})
+);
+---
+
+<Base title={`${term.label} posts`} description={`All posts in ${term.label}`}>
+	<section class="archive-section">
+		<header class="archive-header">
+			<span class="archive-label">Category</span>
+			<h1 class="archive-title">{term.label}</h1>
+			<p class="archive-count">
+				{filteredPosts.length}
+				{filteredPosts.length === 1 ? "post" : "posts"}
+			</p>
+		</header>
+
+		{
+			filteredPosts.length === 0 ? (
+				<p class="no-posts">No posts in this category yet.</p>
+			) : (
+				<div class="posts-grid">
+					{filteredPosts.map(({ post, tags }) => (
+						<PostCard
+							title={post.data.title}
+							excerpt={post.data.excerpt}
+							featuredImage={post.data.featured_image}
+							href={`/posts/${post.id}`}
+							date={post.data.publishedAt ?? undefined}
+							readingTime={getReadingTime(post.data.content)}
+							tags={tags.map((t) => ({ slug: t.slug, label: t.label }))}
+						/>
+					))}
+				</div>
+			)
+		}
+	</section>
+</Base>
+
+<style>
+	.archive-section {
+		max-width: var(--wide-width);
+		margin: 0 auto;
+		padding: var(--spacing-12) var(--spacing-6);
+	}
+
+	.archive-header {
+		margin-bottom: var(--spacing-12);
+		padding-bottom: var(--spacing-8);
+		border-bottom: 1px solid var(--color-border-subtle);
+	}
+
+	.archive-label {
+		display: block;
+		font-size: var(--font-size-xs);
+		font-weight: 500;
+		color: var(--color-accent);
+		text-transform: uppercase;
+		letter-spacing: var(--tracking-wider);
+		margin-bottom: var(--spacing-2);
+	}
+
+	.archive-title {
+		font-size: var(--font-size-4xl);
+		font-weight: 700;
+		letter-spacing: var(--tracking-tight);
+		margin-bottom: var(--spacing-2);
+	}
+
+	.archive-count {
+		font-size: var(--font-size-sm);
+		color: var(--color-muted);
+	}
+
+	.posts-grid {
+		display: grid;
+		grid-template-columns: repeat(3, 1fr);
+		gap: var(--spacing-12) var(--spacing-8);
+	}
+
+	.no-posts {
+		color: var(--color-muted);
+	}
+
+	@media (max-width: 900px) {
+		.posts-grid {
+			grid-template-columns: repeat(2, 1fr);
+		}
+	}
+
+	@media (max-width: 600px) {
+		.posts-grid {
+			grid-template-columns: 1fr;
+		}
+	}
+</style>

templates/blog/src/pages/index.astro

@@ -0,0 +1,448 @@
+---
+import { getEmDashCollection, getEntryTerms } from "emdash";
+import { Image } from "emdash/ui";
+import Base from "../layouts/Base.astro";
+import PostCard from "../components/PostCard.astro";
+import { getReadingTime } from "../utils/reading-time";
+
+const { entries: posts, cacheHint } = await getEmDashCollection("posts");
+
+Astro.cache.set(cacheHint);
+
+const sortedPosts = posts.toSorted((a, b) => {
+	const dateA = a.data.publishedAt?.getTime() ?? 0;
+	const dateB = b.data.publishedAt?.getTime() ?? 0;
+	return dateB - dateA;
+});
+
+// Find the first post with a featured image for the hero
+const featuredPost = sortedPosts.find((p) => p.data.featured_image);
+const featuredIndex = featuredPost ? sortedPosts.indexOf(featuredPost) : -1;
+
+// Get remaining posts (exclude featured if found, limit to 6 for grid)
+const gridPosts = sortedPosts.filter((_, i) => i !== featuredIndex).slice(0, 6);
+
+// Total posts shown = featured (if any) + grid posts
+const totalShown = (featuredPost ? 1 : 0) + gridPosts.length;
+const hasMorePosts = sortedPosts.length > totalShown;
+
+// Fetch tags for featured post (bylines are already hydrated by getEmDashCollection)
+let featuredTags: Array<{ slug: string; label: string }> = [];
+const featuredBylines = featuredPost?.data.bylines ?? [];
+if (featuredPost) {
+	const tags = await getEntryTerms("posts", featuredPost.data.id, "tag");
+	featuredTags = tags.map((t) => ({ slug: t.slug, label: t.label }));
+}
+
+// Fetch tags for grid posts (bylines are already hydrated by getEmDashCollection)
+const gridPostsWithTags = await Promise.all(
+	gridPosts.map(async (post) => {
+		const tags = await getEntryTerms("posts", post.data.id, "tag");
+		const bylines = post.data.bylines ?? [];
+		return {
+			post,
+			tags: tags.map((t) => ({ slug: t.slug, label: t.label })),
+			bylines,
+		};
+	})
+);
+
+// Format date helper
+function formatDate(date: Date | null | undefined) {
+	if (!date) return null;
+	return date.toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "long",
+		day: "numeric",
+	});
+}
+---
+
+<Base title="My Blog" description="Welcome to my blog">
+	{
+		posts.length === 0 ? (
+			<section class="empty-state">
+				<h2>No posts yet</h2>
+				<p>Create your first post in the admin panel.</p>
+				<a href="/_emdash/admin/content/posts/new" class="btn">
+					Create a post
+				</a>
+			</section>
+		) : (
+			<div class="home-content">
+				{/* Featured Post - Side by side */}
+				{featuredPost && (
+					<section class="featured-section">
+						<div class="featured-grid">
+							<a href={`/posts/${featuredPost.id}`} class="featured-image-link">
+								<div class="featured-image">
+									<Image image={featuredPost.data.featured_image} />
+								</div>
+							</a>
+							<div class="featured-content">
+								<div class="featured-meta">
+									{featuredBylines.length > 0 && (
+										<>
+											<div class="featured-bylines">
+												{featuredBylines.slice(0, 2).map((credit, index) => (
+													<>
+														{index > 0 && <span class="byline-sep">,</span>}
+														<span class="featured-byline">
+															{credit.byline.avatarMediaId && (
+																<img
+																	src={`/_emdash/api/media/file/${credit.byline.avatarMediaId}`}
+																	alt={credit.byline.displayName}
+																	class="featured-byline-avatar"
+																/>
+															)}
+															<span class="featured-byline-name">
+																{credit.byline.displayName}
+															</span>
+														</span>
+													</>
+												))}
+												{featuredBylines.length > 2 && (
+													<span class="byline-more">
+														+{featuredBylines.length - 2}
+													</span>
+												)}
+											</div>
+											<span class="meta-dot" />
+										</>
+									)}
+									{formatDate(featuredPost.data.publishedAt) && (
+										<time>{formatDate(featuredPost.data.publishedAt)}</time>
+									)}
+									<span class="meta-dot" />
+									<span>
+										{getReadingTime(featuredPost.data.content)} min read
+									</span>
+								</div>
+								<a
+									href={`/posts/${featuredPost.id}`}
+									class="featured-title-link"
+								>
+									<h1 class="featured-title">{featuredPost.data.title}</h1>
+								</a>
+								{featuredPost.data.excerpt && (
+									<p class="featured-excerpt">{featuredPost.data.excerpt}</p>
+								)}
+								{featuredTags.length > 0 && (
+									<div class="featured-tags">
+										{featuredTags.map((tag) => (
+											<a href={`/tag/${tag.slug}`} class="featured-tag">
+												{tag.label}
+											</a>
+										))}
+									</div>
+								)}
+							</div>
+						</div>
+					</section>
+				)}
+
+				{/* Latest Posts */}
+				{gridPostsWithTags.length > 0 && (
+					<section class="posts-section">
+						<header class="section-header">
+							<h2 class="section-title">Latest</h2>
+							{hasMorePosts && (
+								<a href="/posts" class="section-link">
+									View all
+								</a>
+							)}
+						</header>
+						<div class="posts-grid">
+							{gridPostsWithTags.map(({ post, tags, bylines }) => (
+								<PostCard
+									title={post.data.title ?? "Untitled"}
+									excerpt={post.data.excerpt}
+									featuredImage={post.data.featured_image}
+									href={`/posts/${post.id}`}
+									date={post.data.publishedAt ?? undefined}
+									readingTime={getReadingTime(post.data.content)}
+									tags={tags}
+									bylines={bylines}
+								/>
+							))}
+						</div>
+					</section>
+				)}
+			</div>
+		)
+	}
+</Base>
+
+<style>
+	.home-content {
+		max-width: var(--wide-width);
+		margin: 0 auto;
+		padding: var(--spacing-16) var(--spacing-6);
+	}
+
+	/* Featured Section - Side by side */
+	.featured-section {
+		margin-bottom: var(--spacing-16);
+	}
+
+	.featured-grid {
+		display: grid;
+		grid-template-columns: repeat(3, 1fr);
+		gap: var(--spacing-8);
+		align-items: center;
+	}
+
+	.featured-image-link {
+		grid-column: 1 / 3;
+		display: block;
+		/* Extend to viewport edge, but cap at -6rem minimum extension */
+		margin-left: min(
+			-6rem,
+			calc(-1 * (var(--spacing-6) + (100vw - var(--wide-width)) / 2))
+		);
+	}
+
+	.featured-image {
+		overflow: hidden;
+		border-radius: 0 var(--radius-lg) var(--radius-lg) 0;
+		background: var(--color-surface);
+	}
+
+	.featured-image img {
+		width: 100%;
+		height: auto;
+		aspect-ratio: 4 / 3;
+		object-fit: cover;
+		transition: transform 0.4s ease;
+	}
+
+	.featured-image-link:hover .featured-image img,
+	.featured-grid:has(.featured-title-link:hover) .featured-image img {
+		transform: scale(1.02);
+	}
+
+	.featured-content {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-4);
+	}
+
+	.featured-meta {
+		display: flex;
+		align-items: center;
+		flex-wrap: wrap;
+		column-gap: var(--spacing-3);
+		row-gap: var(--spacing-1);
+		font-size: var(--font-size-sm);
+		color: var(--color-muted);
+	}
+
+	.meta-dot {
+		width: 3px;
+		height: 3px;
+		border-radius: 50%;
+		background: var(--color-muted);
+	}
+
+	/* Featured bylines */
+	.featured-bylines {
+		display: flex;
+		align-items: center;
+		gap: 2px;
+	}
+
+	.featured-byline {
+		display: inline-flex;
+		align-items: center;
+		gap: var(--spacing-2);
+	}
+
+	.featured-byline-avatar {
+		width: var(--avatar-size-md);
+		height: var(--avatar-size-md);
+		border-radius: 50%;
+		object-fit: cover;
+	}
+
+	.featured-byline-name {
+		font-weight: 500;
+		color: var(--color-text-secondary);
+	}
+
+	.byline-sep {
+		color: var(--color-muted);
+		margin-right: 2px;
+	}
+
+	.byline-more {
+		font-size: var(--font-size-xs);
+		color: var(--color-muted);
+		margin-left: 2px;
+	}
+
+	.featured-title-link {
+		text-decoration: none;
+		color: inherit;
+	}
+
+	.featured-title {
+		font-size: clamp(var(--font-size-2xl), 4vw, var(--font-size-4xl));
+		font-weight: 700;
+		line-height: var(--leading-tight);
+		letter-spacing: var(--tracking-tight);
+		transition: color var(--transition-fast);
+	}
+
+	.featured-title-link:hover .featured-title,
+	.featured-grid:has(.featured-image-link:hover) .featured-title {
+		color: var(--color-accent);
+	}
+
+	.featured-excerpt {
+		font-size: var(--font-size-lg);
+		line-height: var(--leading-relaxed);
+		color: var(--color-text-secondary);
+	}
+
+	.featured-tags {
+		display: flex;
+		flex-wrap: wrap;
+		gap: var(--spacing-2);
+		margin-top: var(--spacing-2);
+	}
+
+	.featured-tag {
+		display: inline-block;
+		padding: var(--spacing-1) var(--spacing-3);
+		font-size: var(--font-size-sm);
+		color: var(--color-text-secondary);
+		background: var(--color-surface);
+		border-radius: var(--radius);
+		text-decoration: none;
+		transition:
+			color var(--transition-fast),
+			background var(--transition-fast);
+	}
+
+	.featured-tag:hover {
+		color: var(--color-text);
+		background: var(--color-border);
+	}
+
+	/* Section header */
+	.section-header {
+		display: flex;
+		justify-content: space-between;
+		align-items: baseline;
+		margin-bottom: var(--spacing-8);
+		padding-bottom: var(--spacing-4);
+		border-bottom: 1px solid var(--color-border-subtle);
+	}
+
+	.section-title {
+		font-size: var(--font-size-sm);
+		font-weight: 500;
+		text-transform: uppercase;
+		letter-spacing: var(--tracking-wider);
+		color: var(--color-muted);
+	}
+
+	.section-link {
+		font-size: var(--font-size-sm);
+		color: var(--color-accent);
+		text-decoration: none;
+		transition: color var(--transition-fast);
+	}
+
+	.section-link:hover {
+		color: var(--color-accent-hover);
+	}
+
+	/* Posts Grid */
+	.posts-section {
+	}
+
+	.posts-grid {
+		display: grid;
+		grid-template-columns: repeat(3, 1fr);
+		gap: var(--spacing-12) var(--spacing-8);
+	}
+
+	/* Empty State */
+	.empty-state {
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		gap: var(--spacing-3);
+		text-align: center;
+		padding: var(--spacing-20) var(--spacing-6);
+		max-width: 400px;
+		margin: 0 auto;
+	}
+
+	.empty-state h2 {
+		font-size: var(--font-size-2xl);
+		font-weight: 600;
+	}
+
+	.empty-state p {
+		color: var(--color-muted);
+	}
+
+	.btn {
+		display: inline-block;
+		margin-top: var(--spacing-4);
+		padding: var(--spacing-3) var(--spacing-6);
+		background: var(--color-accent);
+		color: var(--color-on-accent);
+		text-decoration: none;
+		border-radius: var(--radius);
+		font-size: var(--font-size-sm);
+		font-weight: 500;
+		transition: background var(--transition-fast);
+	}
+
+	.btn:hover {
+		background: var(--color-accent-hover);
+	}
+
+	/* Responsive */
+	@media (max-width: 900px) {
+		.home-content {
+			padding: var(--spacing-6) var(--spacing-4) var(--spacing-12);
+		}
+
+		.featured-image-link {
+			margin-left: 0;
+		}
+
+		.featured-grid {
+			grid-template-columns: 1fr;
+			gap: var(--spacing-6);
+		}
+
+		.featured-image {
+			border-radius: var(--radius-lg);
+		}
+
+		.featured-image img {
+			aspect-ratio: 16 / 9;
+		}
+
+		.posts-grid {
+			grid-template-columns: repeat(2, 1fr);
+			gap: var(--spacing-8) var(--spacing-6);
+		}
+	}
+
+	@media (max-width: 600px) {
+		.featured-title {
+			font-size: var(--font-size-2xl);
+		}
+
+		.posts-grid {
+			grid-template-columns: 1fr;
+			gap: var(--spacing-8);
+		}
+	}
+</style>

templates/blog/src/pages/pages/[slug].astro

@@ -0,0 +1,108 @@
+---
+import { getEmDashEntry } from "emdash";
+import { PortableText } from "emdash/ui";
+import Base from "../../layouts/Base.astro";
+
+const { slug } = Astro.params;
+
+if (!slug) {
+	return Astro.redirect("/404");
+}
+
+const { entry: page, cacheHint } = await getEmDashEntry("pages", slug);
+
+if (!page) {
+	return Astro.redirect("/404");
+}
+
+Astro.cache.set(cacheHint);
+---
+
+<Base
+	title={page.data.title}
+	content={{ collection: "pages", id: page.data.id, slug }}
+>
+	<article class="page-article">
+		<header class="page-header">
+			<h1 class="page-title" {...page.edit.title}>{page.data.title}</h1>
+		</header>
+
+		<div class="page-content">
+			<PortableText value={page.data.content} />
+		</div>
+	</article>
+</Base>
+
+<style>
+	.page-article {
+		max-width: var(--max-width);
+		margin: 0 auto;
+		padding: var(--spacing-16) var(--spacing-6) var(--spacing-16);
+	}
+
+	.page-header {
+		margin-bottom: var(--spacing-8);
+	}
+
+	.page-title {
+		font-size: clamp(var(--font-size-2xl), 4vw, var(--font-size-4xl));
+		font-weight: 700;
+		line-height: var(--leading-tight);
+	}
+
+	.page-content :global(p) {
+		margin-bottom: 1.5em;
+	}
+
+	.page-content :global(h2) {
+		font-size: var(--font-size-2xl);
+		margin-top: 2em;
+		margin-bottom: 0.75em;
+	}
+
+	.page-content :global(h3) {
+		font-size: var(--font-size-xl);
+		margin-top: 1.75em;
+		margin-bottom: 0.5em;
+	}
+
+	.page-content :global(blockquote) {
+		margin: 1.5em 0;
+		padding-left: var(--spacing-6);
+		border-left: 3px solid var(--color-border);
+		color: var(--color-muted);
+	}
+
+	.page-content :global(pre) {
+		margin: 1.5em 0;
+		padding: var(--spacing-4);
+		background: var(--color-surface);
+		border-radius: var(--radius);
+		overflow-x: auto;
+		font-family: var(--font-mono);
+		font-size: var(--font-size-sm);
+	}
+
+	.page-content :global(code) {
+		font-family: var(--font-mono);
+		font-size: 0.9em;
+		background: var(--color-surface);
+		padding: 0.15em 0.3em;
+		border-radius: var(--radius);
+	}
+
+	.page-content :global(pre code) {
+		background: none;
+		padding: 0;
+	}
+
+	.page-content :global(ul),
+	.page-content :global(ol) {
+		margin-bottom: 1.5em;
+		padding-left: var(--spacing-5);
+	}
+
+	.page-content :global(li) {
+		margin-bottom: 0.5em;
+	}
+</style>

templates/blog/src/pages/posts/[slug].astro

@@ -0,0 +1,958 @@
+---
+import {
+	getEmDashEntry,
+	getEmDashCollection,
+	getEntryTerms,
+	getSeoMeta,
+} from "emdash";
+import {
+	Image,
+	PortableText,
+	Comments,
+	CommentForm,
+	WidgetArea,
+} from "emdash/ui";
+import Base from "../../layouts/Base.astro";
+import PostCard from "../../components/PostCard.astro";
+import { getReadingTime } from "../../utils/reading-time";
+
+const { slug } = Astro.params;
+
+if (!slug) {
+	return Astro.redirect("/404");
+}
+
+const { entry: post, cacheHint } = await getEmDashEntry("posts", slug);
+
+if (!post) {
+	return Astro.redirect("/404");
+}
+
+Astro.cache.set(cacheHint);
+
+// Get featured image URL for OG fallback
+// The image may have src (external) or meta.storageKey (local)
+function getImageUrl(img: unknown): string | undefined {
+	if (!img || typeof img !== "object") return undefined;
+	const image = img as Record<string, unknown>;
+	// Check for direct src
+	if (typeof image.src === "string" && image.src) {
+		return image.src.startsWith("http")
+			? image.src
+			: `${Astro.url.origin}${image.src}`;
+	}
+	// Build from storageKey for local images
+	const meta = image.meta as Record<string, unknown> | undefined;
+	const storageKey =
+		(typeof meta?.storageKey === "string" ? meta.storageKey : undefined) ||
+		(typeof image.id === "string" ? image.id : undefined);
+	if (storageKey) {
+		return `${Astro.url.origin}/_emdash/api/media/file/${storageKey}`;
+	}
+	return undefined;
+}
+const featuredImageUrl = getImageUrl(post.data.featured_image);
+
+// Generate SEO meta from content
+const seo = getSeoMeta(post, {
+	siteTitle: "My Blog",
+	siteUrl: Astro.url.origin,
+	path: `/posts/${slug}`,
+	defaultOgImage: featuredImageUrl,
+});
+
+// Get tags for this post
+// Note: post.id is the slug, post.data.id is the database ULID
+const tags = await getEntryTerms("posts", post.data.id, "tag");
+
+// Bylines are already hydrated by getEmDashEntry
+const bylines = post.data.bylines ?? [];
+
+// Get reading time
+const readingTime = getReadingTime(post.data.content);
+
+// Get other posts for "More posts" section, with their tags
+// Fetch a few extra in case the current post is among them
+const { entries: recentPosts } = await getEmDashCollection("posts", {
+	orderBy: { published_at: "desc" },
+	limit: 4,
+});
+const otherPosts = recentPosts.filter((p) => p.id !== post.id).slice(0, 3);
+
+// Fetch tags for related posts (bylines are already hydrated by getEmDashCollection)
+const otherPostsWithTags = await Promise.all(
+	otherPosts.map(async (p) => {
+		const postTags = await getEntryTerms("posts", p.data.id, "tag");
+		const postBylines = p.data.bylines ?? [];
+		return { post: p, tags: postTags, bylines: postBylines };
+	})
+);
+
+const publishDate =
+	post.data.publishedAt?.toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "long",
+		day: "numeric",
+	}) ?? null;
+---
+
+<Base
+	title={seo.title}
+	description={seo.description}
+	image={seo.ogImage}
+	canonical={seo.canonical}
+	robots={seo.robots}
+	type="article"
+	publishedTime={post.data.publishedAt?.toISOString() ?? null}
+	modifiedTime={post.data.updatedAt.toISOString()}
+	content={{ collection: "posts", id: post.data.id, slug }}
+>
+	<article class="article">
+		{/* Hero: Full-width featured image */}
+		{
+			post.data.featured_image && (
+				<div class="article-hero" {...post.edit.featured_image}>
+					<Image image={post.data.featured_image} />
+				</div>
+			)
+		}
+
+		{/* Three-column layout */}
+		<div class="article-grid">
+			{/* Left gutter: Meta information */}
+			<aside class="article-meta-col">
+				<div class="meta-sticky">
+					{
+						bylines.length > 0 && (
+							<div class="meta-block byline-block">
+								<span class="meta-label">
+									{bylines.length === 1 ? "Author" : "Authors"}
+								</span>
+								<div class="bylines">
+									{bylines.map((credit) => (
+										<div class="byline">
+											{credit.byline.avatarMediaId && (
+												<img
+													src={`/_emdash/api/media/file/${credit.byline.avatarMediaId}`}
+													alt={credit.byline.displayName}
+													class="byline-avatar"
+												/>
+											)}
+											<div class="byline-info">
+												<span class="byline-name">
+													{credit.byline.displayName}
+												</span>
+												{credit.roleLabel && (
+													<span class="byline-role">{credit.roleLabel}</span>
+												)}
+											</div>
+										</div>
+									))}
+								</div>
+							</div>
+						)
+					}
+					{
+						publishDate && (
+							<div class="meta-block">
+								<span class="meta-label">Published</span>
+								<time class="meta-value">{publishDate}</time>
+							</div>
+						)
+					}
+					<div class="meta-block">
+						<span class="meta-label">Reading time</span>
+						<span class="meta-value">{readingTime} min</span>
+					</div>
+					{
+						tags.length > 0 && (
+							<div class="meta-block">
+								<span class="meta-label">Tags</span>
+								<div class="meta-tags">
+									{tags.map((t) => (
+										<a href={`/tag/${t.slug}`} class="meta-tag">
+											{t.label}
+										</a>
+									))}
+								</div>
+							</div>
+						)
+					}
+				</div>
+			</aside>
+
+			{/* Main content */}
+			<div class="article-main">
+				<header class="article-header">
+					<div class="article-meta">
+						{
+							bylines.length > 0 && (
+								<>
+									<span class="article-meta-byline">
+										{bylines.map((credit, i) => (
+											<>
+												{i > 0 && ", "}
+												{credit.byline.displayName}
+											</>
+										))}
+									</span>
+									<span class="meta-dot" />
+								</>
+							)
+						}
+						{
+							publishDate && (
+								<>
+									<time>{publishDate}</time>
+									<span class="meta-dot" />
+								</>
+							)
+						}
+						<span>{readingTime} min read</span>
+					</div>
+					<h1 class="article-title" {...post.edit.title}>{post.data.title}</h1>
+					{
+						post.data.excerpt && (
+							<p class="article-excerpt">{post.data.excerpt}</p>
+						)
+					}
+				</header>
+
+				<div class="article-content">
+					<PortableText value={post.data.content} />
+				</div>
+
+				<div class="article-comments">
+					<Comments collection="posts" contentId={post.data.id} threaded />
+					<CommentForm collection="posts" contentId={post.data.id} />
+				</div>
+			</div>
+
+			{/* Right gutter: TOC + Sidebar widgets */}
+			<aside class="article-sidebar">
+				<div class="sidebar-sticky">
+					<nav class="toc" aria-label="Table of contents">
+						<h4 class="toc-title">On this page</h4>
+						<div class="toc-content" id="toc-content">
+							<!-- Populated by JS -->
+						</div>
+					</nav>
+					<div class="sidebar-widgets">
+						<WidgetArea name="sidebar" />
+					</div>
+				</div>
+			</aside>
+		</div>
+	</article>
+
+	{
+		otherPostsWithTags.length > 0 && (
+			<section class="more-posts">
+				<div class="more-inner">
+					<h2 class="more-title">Continue reading</h2>
+					<div class="more-grid">
+						{otherPostsWithTags.map(
+							({ post: p, tags: postTags, bylines: postBylines }) => (
+								<PostCard
+									title={p.data.title}
+									excerpt={p.data.excerpt}
+									featuredImage={p.data.featured_image}
+									href={`/posts/${p.id}`}
+									date={p.data.publishedAt ?? undefined}
+									readingTime={getReadingTime(p.data.content)}
+									tags={postTags.map((t) => ({ slug: t.slug, label: t.label }))}
+									bylines={postBylines}
+								/>
+							)
+						)}
+					</div>
+				</div>
+			</section>
+		)
+	}
+
+	<script>
+		// Build table of contents from h2/h3 headings
+		function buildToc() {
+			const content = document.querySelector(".article-content");
+			const tocContainer = document.getElementById("toc-content");
+			if (!content || !tocContainer) return;
+
+			const headings = content.querySelectorAll("h2, h3");
+			if (headings.length === 0) {
+				// Hide TOC if no headings
+				const toc = document.querySelector(".toc") as HTMLElement | null;
+				if (toc) toc.style.display = "none";
+				return;
+			}
+
+			const list = document.createElement("ul");
+			list.className = "toc-list";
+
+			headings.forEach((heading, index) => {
+				// Add ID if missing
+				if (!heading.id) {
+					heading.id = `heading-${index}`;
+				}
+
+				const li = document.createElement("li");
+				li.className =
+					heading.tagName === "H3" ? "toc-item toc-item--nested" : "toc-item";
+
+				const link = document.createElement("a");
+				link.href = `#${heading.id}`;
+				link.className = "toc-link";
+				link.textContent = heading.textContent;
+
+				li.appendChild(link);
+				list.appendChild(li);
+			});
+
+			tocContainer.appendChild(list);
+
+			// Highlight current section on scroll
+			const observer = new IntersectionObserver(
+				(entries) => {
+					entries.forEach((entry) => {
+						const id = entry.target.id;
+						const link = tocContainer.querySelector(`a[href="#${id}"]`);
+						if (link) {
+							if (entry.isIntersecting) {
+								tocContainer
+									.querySelectorAll(".toc-link")
+									.forEach((l) => l.classList.remove("active"));
+								link.classList.add("active");
+							}
+						}
+					});
+				},
+				{ rootMargin: "-80px 0px -80% 0px" }
+			);
+
+			headings.forEach((heading) => observer.observe(heading));
+		}
+
+		buildToc();
+	</script>
+</Base>
+
+<style>
+	/* Article container */
+	.article {
+		max-width: var(--wide-width);
+		margin: 0 auto;
+	}
+
+	/* Hero image - full width within container */
+	.article-hero {
+		margin: var(--spacing-16) var(--spacing-6);
+		border-radius: var(--radius-lg);
+		overflow: hidden;
+	}
+
+	.article-hero img {
+		width: 100%;
+		height: auto;
+		max-height: 500px;
+		object-fit: cover;
+	}
+
+	/* Three-column grid */
+	.article-grid {
+		display: grid;
+		grid-template-columns:
+			var(--meta-col-width) minmax(0, var(--content-width))
+			var(--gutter-width);
+		gap: var(--spacing-10);
+		justify-content: center;
+		padding: 0 var(--spacing-6);
+		margin: var(--spacing-16) 0;
+	}
+
+	/* Left column: Meta */
+	.article-meta-col {
+		display: block;
+	}
+
+	.meta-sticky {
+		position: sticky;
+		top: calc(var(--nav-height) + var(--spacing-8));
+	}
+
+	.meta-block {
+		margin-bottom: var(--spacing-6);
+	}
+
+	.meta-label {
+		display: block;
+		font-size: var(--font-size-xs);
+		font-weight: 500;
+		text-transform: uppercase;
+		letter-spacing: var(--tracking-wide);
+		color: var(--color-muted);
+		margin-bottom: var(--spacing-1);
+	}
+
+	.meta-value {
+		display: block;
+		font-size: var(--font-size-sm);
+		color: var(--color-text-secondary);
+	}
+
+	.meta-tags {
+		display: flex;
+		flex-wrap: wrap;
+		gap: var(--spacing-1);
+	}
+
+	.meta-tag {
+		display: inline-block;
+		padding: var(--tag-padding-y) var(--spacing-2);
+		font-size: var(--font-size-xs);
+		color: var(--color-text-secondary);
+		background: var(--color-surface);
+		border-radius: var(--radius);
+		text-decoration: none;
+		transition:
+			color var(--transition-fast),
+			background var(--transition-fast);
+	}
+
+	.meta-tag:hover {
+		color: var(--color-text);
+		background: var(--color-border);
+	}
+
+	/* Byline styles */
+	.bylines {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-1);
+	}
+
+	.byline {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-2);
+	}
+
+	.byline-avatar {
+		width: var(--avatar-size-lg);
+		height: var(--avatar-size-lg);
+		border-radius: 50%;
+		object-fit: cover;
+	}
+
+	.byline-info {
+		display: flex;
+		flex-direction: column;
+	}
+
+	.byline-name {
+		font-size: var(--font-size-sm);
+		font-weight: 500;
+		color: var(--color-text);
+	}
+
+	.byline-role {
+		font-size: var(--font-size-xs);
+		color: var(--color-muted);
+	}
+
+	/* Main content column */
+	.article-main {
+		min-width: 0;
+	}
+
+	.article-header {
+		margin-bottom: var(--spacing-10);
+	}
+
+	.article-header .article-meta {
+		display: none;
+		align-items: center;
+		flex-wrap: wrap;
+		column-gap: var(--spacing-3);
+		row-gap: var(--spacing-1);
+		font-size: var(--font-size-sm);
+		color: var(--color-muted);
+		margin-bottom: var(--spacing-4);
+	}
+
+	.article-meta-byline {
+		font-weight: 500;
+		color: var(--color-text-secondary);
+	}
+
+	.article-title {
+		font-size: clamp(2rem, 5vw, var(--font-size-5xl));
+		font-weight: 700;
+		line-height: var(--leading-tight);
+		letter-spacing: var(--tracking-tight);
+		margin-bottom: var(--spacing-4);
+	}
+
+	.article-excerpt {
+		font-size: var(--font-size-xl);
+		line-height: var(--leading-relaxed);
+		color: var(--color-text-secondary);
+	}
+
+	/* Article content typography */
+	.article-content {
+		font-size: var(--font-size-lg);
+		line-height: var(--leading-relaxed);
+	}
+
+	.article-content :global(p) {
+		margin-bottom: 1.5em;
+	}
+
+	.article-content :global(h2) {
+		font-size: var(--font-size-2xl);
+		margin-top: 2.5em;
+		margin-bottom: 0.75em;
+		scroll-margin-top: calc(var(--nav-height) + var(--spacing-4));
+	}
+
+	.article-content :global(h3) {
+		font-size: var(--font-size-xl);
+		margin-top: 2em;
+		margin-bottom: 0.5em;
+		scroll-margin-top: calc(var(--nav-height) + var(--spacing-4));
+	}
+
+	.article-content :global(blockquote) {
+		margin: 2em 0;
+		padding: var(--spacing-4) var(--spacing-6);
+		border-left: 3px solid var(--color-border);
+		background: var(--color-bg-subtle);
+		border-radius: 0 var(--radius) var(--radius) 0;
+		color: var(--color-text-secondary);
+		font-style: italic;
+	}
+
+	.article-content :global(pre) {
+		margin: 2em 0;
+		padding: var(--spacing-5);
+		background: var(--color-surface);
+		border: 1px solid var(--color-border);
+		border-radius: var(--radius-lg);
+		overflow-x: auto;
+		font-family: var(--font-mono);
+		font-size: var(--font-size-sm);
+		line-height: 1.6;
+	}
+
+	.article-content :global(code) {
+		font-family: var(--font-mono);
+		font-size: 0.9em;
+		background: var(--color-surface);
+		padding: 0.2em 0.4em;
+		border-radius: var(--radius);
+	}
+
+	.article-content :global(pre code) {
+		background: none;
+		padding: 0;
+	}
+
+	.article-content :global(ul),
+	.article-content :global(ol) {
+		margin-bottom: 1.5em;
+		padding-left: 1.5em;
+	}
+
+	.article-content :global(li) {
+		margin-bottom: 0.5em;
+	}
+
+	.article-content :global(img) {
+		margin: 2em 0;
+		border-radius: var(--radius-lg);
+	}
+
+	.article-content :global(hr) {
+		margin: 3em 0;
+		border: none;
+		border-top: 1px solid var(--color-border);
+	}
+
+	.article-content :global(a) {
+		color: var(--color-accent);
+		text-decoration: underline;
+		text-underline-offset: 3px;
+		text-decoration-thickness: 1px;
+	}
+
+	.article-content :global(a:hover) {
+		text-decoration-thickness: 2px;
+	}
+
+	/* Right column: TOC + Sidebar */
+	.article-sidebar {
+		display: block;
+	}
+
+	.sidebar-sticky {
+		position: sticky;
+		top: calc(var(--nav-height) + var(--spacing-8));
+	}
+
+	.toc {
+		margin-bottom: var(--spacing-8);
+		padding-bottom: var(--spacing-6);
+		border-bottom: 1px solid var(--color-border-subtle);
+	}
+
+	.toc-title {
+		font-size: var(--font-size-xs);
+		font-weight: 500;
+		text-transform: uppercase;
+		letter-spacing: var(--tracking-wide);
+		color: var(--color-muted);
+		margin-bottom: var(--spacing-3);
+	}
+
+	.toc-content :global(.toc-list) {
+		list-style: none;
+		padding: 0;
+		margin: 0;
+	}
+
+	.toc-content :global(.toc-item) {
+		margin-bottom: var(--spacing-1);
+	}
+
+	.toc-content :global(.toc-item--nested) {
+		padding-left: var(--spacing-3);
+	}
+
+	.toc-content :global(.toc-link) {
+		display: block;
+		font-size: var(--font-size-sm);
+		color: var(--color-muted);
+		text-decoration: none;
+		padding: var(--spacing-1) 0;
+		transition: color var(--transition-fast);
+		line-height: var(--leading-snug);
+	}
+
+	.toc-content :global(.toc-link:hover),
+	.toc-content :global(.toc-link.active) {
+		color: var(--color-text);
+	}
+
+	/* Sidebar widgets */
+	.sidebar-widgets :global(.widget-area) {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-6);
+	}
+
+	.sidebar-widgets :global(.widget) {
+		font-size: var(--font-size-sm);
+	}
+
+	.sidebar-widgets :global(.widget__title) {
+		font-size: var(--font-size-xs);
+		font-weight: 500;
+		text-transform: uppercase;
+		letter-spacing: var(--tracking-wide);
+		color: var(--color-muted);
+		margin-bottom: var(--spacing-3);
+	}
+
+	.sidebar-widgets :global(.widget__content) {
+		color: var(--color-text-secondary);
+		line-height: var(--leading-relaxed);
+	}
+
+	/* Sidebar search widget */
+	.sidebar-widgets :global(.widget-search) {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-2);
+	}
+
+	.sidebar-widgets :global(.widget-search__input) {
+		width: 100%;
+		padding: var(--spacing-2) var(--spacing-3);
+		font-family: var(--font-sans);
+		font-size: var(--font-size-sm);
+		border: 1px solid var(--color-border);
+		border-radius: var(--radius);
+		background: var(--color-bg);
+		color: var(--color-text);
+		transition:
+			border-color var(--transition-fast),
+			box-shadow var(--transition-fast);
+	}
+
+	.sidebar-widgets :global(.widget-search__input)::placeholder {
+		color: var(--color-muted);
+	}
+
+	.sidebar-widgets :global(.widget-search__input):focus,
+	.sidebar-widgets :global(.widget-search__input):focus-visible {
+		outline: none;
+		border-color: var(--color-accent);
+		box-shadow: 0 0 0 3px var(--color-accent-ring);
+	}
+
+	.sidebar-widgets :global(.widget-search__button) {
+		display: none;
+	}
+
+	/* Sidebar categories widget */
+	.sidebar-widgets :global(.widget-categories) {
+		list-style: none;
+		padding: 0;
+		margin: 0;
+	}
+
+	.sidebar-widgets :global(.widget-categories li) {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		padding: var(--spacing-2) 0;
+		border-bottom: 1px solid var(--color-border-subtle);
+	}
+
+	.sidebar-widgets :global(.widget-categories li:last-child) {
+		border-bottom: none;
+	}
+
+	.sidebar-widgets :global(.widget-categories__link) {
+		color: var(--color-text-secondary);
+		text-decoration: none;
+		transition: color var(--transition-fast);
+	}
+
+	.sidebar-widgets :global(.widget-categories__link:hover) {
+		color: var(--color-text);
+	}
+
+	.sidebar-widgets :global(.widget-categories__count) {
+		font-size: var(--font-size-xs);
+		color: var(--color-muted);
+		background: var(--color-surface);
+		padding: var(--tag-padding-y) var(--spacing-2);
+		border-radius: var(--radius);
+	}
+
+	/* Sidebar tags widget - pill style */
+	.sidebar-widgets :global(.widget-tags__cloud) {
+		list-style: none;
+		padding: 0;
+		margin: 0;
+		display: flex;
+		flex-wrap: wrap;
+		gap: var(--spacing-2);
+	}
+
+	.sidebar-widgets :global(.widget-tags__cloud li) {
+		margin: 0;
+	}
+
+	.sidebar-widgets :global(.widget-tags__link) {
+		display: inline-block;
+		padding: var(--spacing-1) var(--spacing-3);
+		font-size: var(--font-size-sm);
+		color: var(--color-text-secondary);
+		background: var(--color-surface);
+		border-radius: var(--radius);
+		text-decoration: none;
+		transition:
+			color var(--transition-fast),
+			background var(--transition-fast);
+	}
+
+	.sidebar-widgets :global(.widget-tags__link:hover) {
+		color: var(--color-text);
+		background: var(--color-border);
+	}
+
+	.sidebar-widgets :global(.widget-tags__count) {
+		display: none;
+	}
+
+	/* Sidebar recent posts widget */
+	.sidebar-widgets :global(.widget-recent-posts) {
+		list-style: none;
+		padding: 0;
+		margin: 0;
+	}
+
+	.sidebar-widgets :global(.widget-recent-posts li) {
+		padding: var(--spacing-2) 0;
+		border-bottom: 1px solid var(--color-border-subtle);
+	}
+
+	.sidebar-widgets :global(.widget-recent-posts li:last-child) {
+		border-bottom: none;
+	}
+
+	.sidebar-widgets :global(.widget-recent-posts a) {
+		color: var(--color-text-secondary);
+		text-decoration: none;
+		transition: color var(--transition-fast);
+		line-height: var(--leading-snug);
+	}
+
+	.sidebar-widgets :global(.widget-recent-posts a:hover) {
+		color: var(--color-text);
+	}
+
+	/* Sidebar archives widget */
+	.sidebar-widgets :global(.widget-archives) {
+		list-style: none;
+		padding: 0;
+		margin: 0;
+	}
+
+	.sidebar-widgets :global(.widget-archives li) {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		padding: var(--spacing-2) 0;
+		border-bottom: 1px solid var(--color-border-subtle);
+	}
+
+	.sidebar-widgets :global(.widget-archives li:last-child) {
+		border-bottom: none;
+	}
+
+	.sidebar-widgets :global(.widget-archives__link) {
+		color: var(--color-text-secondary);
+		text-decoration: none;
+		transition: color var(--transition-fast);
+	}
+
+	.sidebar-widgets :global(.widget-archives__link:hover) {
+		color: var(--color-text);
+	}
+
+	.sidebar-widgets :global(.widget-archives__count) {
+		font-size: var(--font-size-xs);
+		color: var(--color-muted);
+		background: var(--color-surface);
+		padding: var(--tag-padding-y) var(--spacing-2);
+		border-radius: var(--radius);
+	}
+
+	/* Comments section */
+	.article-comments {
+		margin-top: var(--spacing-16);
+		padding-top: var(--spacing-10);
+		border-top: 1px solid var(--color-border);
+	}
+
+	.article-comments :global(.ec-comments) {
+		--ec-comment-border: 1px solid var(--color-border);
+	}
+
+	.article-comments :global(.ec-comments-heading) {
+		font-size: var(--font-size-2xl);
+		font-weight: 600;
+		margin-bottom: var(--spacing-8);
+	}
+
+	.article-comments :global(.ec-comment-author) {
+		color: var(--color-text);
+	}
+
+	.article-comments :global(.ec-comment-date) {
+		font-family: var(--font-mono);
+		color: var(--color-muted);
+	}
+
+	.article-comments :global(.ec-comment-body) {
+		color: var(--color-text);
+	}
+
+	.article-comments :global(.ec-comment-form-field input),
+	.article-comments :global(.ec-comment-form-field textarea) {
+		background: var(--color-surface) !important;
+		border-color: var(--color-border) !important;
+		color: var(--color-text) !important;
+	}
+
+	.article-comments :global(.ec-comment-user-info) {
+		background: var(--color-surface) !important;
+		border-color: var(--color-border) !important;
+	}
+
+	.article-comments :global(.ec-comment-form-submit) {
+		background: var(--color-accent) !important;
+		color: var(--color-on-accent) !important;
+	}
+
+	/* More posts section */
+	.more-posts {
+		background: var(--color-bg-subtle);
+		padding: var(--spacing-16) 0;
+		margin-top: var(--spacing-16);
+	}
+
+	.more-inner {
+		max-width: var(--wide-width);
+		margin: 0 auto;
+		padding: 0 var(--spacing-6);
+	}
+
+	.more-title {
+		font-size: var(--font-size-2xl);
+		font-weight: 600;
+		margin-bottom: var(--spacing-10);
+	}
+
+	.more-grid {
+		display: grid;
+		grid-template-columns: repeat(3, 1fr);
+		grid-template-rows: repeat(5, auto);
+		gap: var(--spacing-8);
+	}
+
+	/* Responsive */
+	@media (max-width: 1100px) {
+		.article-grid {
+			grid-template-columns: minmax(0, var(--content-width));
+			gap: 0;
+		}
+
+		.article-meta-col,
+		.article-sidebar {
+			display: none;
+		}
+
+		.article-header .article-meta {
+			display: flex;
+		}
+	}
+
+	@media (max-width: 900px) {
+		.article-hero {
+			margin: var(--spacing-4) var(--spacing-4) var(--spacing-8);
+			border-radius: var(--radius);
+		}
+
+		.article-grid {
+			padding: 0 var(--spacing-4);
+		}
+
+		.more-grid {
+			grid-template-columns: repeat(2, 1fr);
+		}
+	}
+
+	@media (max-width: 600px) {
+		.article-title {
+			font-size: var(--font-size-3xl);
+		}
+
+		.more-grid {
+			grid-template-columns: 1fr;
+		}
+	}
+</style>

templates/blog/src/pages/posts/index.astro

@@ -0,0 +1,268 @@
+---
+import { getEmDashCollection, getEntryTerms } from "emdash";
+import Base from "../../layouts/Base.astro";
+import { getReadingTime } from "../../utils/reading-time";
+
+const { entries: posts, cacheHint } = await getEmDashCollection("posts");
+
+Astro.cache.set(cacheHint);
+
+const sortedPosts = posts.toSorted((a, b) => {
+	const dateA = a.data.publishedAt?.getTime() ?? 0;
+	const dateB = b.data.publishedAt?.getTime() ?? 0;
+	return dateB - dateA;
+});
+
+// Fetch tags for each post (bylines are already hydrated by getEmDashCollection)
+const postsWithTags = await Promise.all(
+	sortedPosts.map(async (post) => {
+		const tags = await getEntryTerms("posts", post.data.id, "tag");
+		const bylines = post.data.bylines ?? [];
+		return { post, tags, bylines };
+	})
+);
+
+const formatDate = (date: Date) =>
+	date.toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "long",
+		day: "numeric",
+	});
+---
+
+<Base title="All Posts" description="Browse all blog posts">
+	<div class="posts-page">
+		<header class="page-header">
+			<h1 class="page-title">All Posts</h1>
+			<p class="page-description">
+				{posts.length}
+				{posts.length === 1 ? "article" : "articles"}
+			</p>
+		</header>
+
+		{
+			sortedPosts.length === 0 ? (
+				<p class="empty">No posts yet.</p>
+			) : (
+				<div class="posts-list">
+					{postsWithTags.map(({ post, tags, bylines }) => (
+						<article class="post-item">
+							<a href={`/posts/${post.id}`} class="post-link">
+								<div class="post-meta">
+									{bylines.length > 0 && (
+										<>
+											<div class="post-bylines">
+												{bylines.slice(0, 2).map((credit, index) => (
+													<>
+														{index > 0 && <span class="byline-sep">,</span>}
+														<span class="post-byline">
+															{credit.byline.avatarMediaId && (
+																<img
+																	src={`/_emdash/api/media/file/${credit.byline.avatarMediaId}`}
+																	alt={credit.byline.displayName}
+																	class="post-byline-avatar"
+																/>
+															)}
+															<span class="post-byline-name">
+																{credit.byline.displayName}
+															</span>
+														</span>
+													</>
+												))}
+												{bylines.length > 2 && (
+													<span class="byline-more">+{bylines.length - 2}</span>
+												)}
+											</div>
+											<span class="meta-dot" />
+										</>
+									)}
+									{post.data.publishedAt && (
+										<time>{formatDate(post.data.publishedAt)}</time>
+									)}
+									{post.data.publishedAt && <span class="meta-dot" />}
+									<span>{getReadingTime(post.data.content)} min read</span>
+								</div>
+								<h2 class="post-title">{post.data.title}</h2>
+								{post.data.excerpt && (
+									<p class="post-excerpt">{post.data.excerpt}</p>
+								)}
+							</a>
+							{tags.length > 0 && (
+								<div class="post-tags">
+									{tags.slice(0, 3).map((t) => (
+										<a href={`/tag/${t.slug}`} class="post-tag">
+											{t.label}
+										</a>
+									))}
+								</div>
+							)}
+						</article>
+					))}
+				</div>
+			)
+		}
+	</div>
+</Base>
+
+<style>
+	.posts-page {
+		max-width: var(--content-width);
+		margin: 0 auto;
+		padding: var(--spacing-8) var(--spacing-6) var(--spacing-16);
+	}
+
+	.page-header {
+		margin-bottom: var(--spacing-12);
+	}
+
+	.page-title {
+		font-size: var(--font-size-4xl);
+		font-weight: 700;
+		letter-spacing: var(--tracking-tight);
+		margin-bottom: var(--spacing-2);
+	}
+
+	.page-description {
+		font-size: var(--font-size-lg);
+		color: var(--color-muted);
+	}
+
+	.empty {
+		color: var(--color-muted);
+		font-size: var(--font-size-lg);
+	}
+
+	.posts-list {
+		display: flex;
+		flex-direction: column;
+	}
+
+	.post-item {
+		padding: var(--spacing-8) 0;
+		border-bottom: 1px solid var(--color-border-subtle);
+	}
+
+	.post-item:first-child {
+		padding-top: 0;
+	}
+
+	.post-item:last-child {
+		border-bottom: none;
+	}
+
+	.post-link {
+		display: block;
+		text-decoration: none;
+		color: inherit;
+	}
+
+	.post-meta {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-3);
+		font-size: var(--font-size-sm);
+		color: var(--color-muted);
+		margin-bottom: var(--spacing-2);
+	}
+
+	.meta-dot {
+		width: 3px;
+		height: 3px;
+		border-radius: 50%;
+		background: var(--color-muted);
+	}
+
+	/* Post bylines */
+	.post-bylines {
+		display: flex;
+		align-items: center;
+		gap: 2px;
+	}
+
+	.post-byline {
+		display: inline-flex;
+		align-items: center;
+		gap: var(--spacing-1);
+	}
+
+	.post-byline-avatar {
+		width: var(--avatar-size-sm);
+		height: var(--avatar-size-sm);
+		border-radius: 50%;
+		object-fit: cover;
+	}
+
+	.post-byline-name {
+		font-weight: 500;
+		color: var(--color-text-secondary);
+	}
+
+	.byline-sep {
+		color: var(--color-muted);
+		margin-right: 2px;
+	}
+
+	.byline-more {
+		font-size: var(--font-size-xs);
+		color: var(--color-muted);
+		margin-left: 2px;
+	}
+
+	.post-title {
+		font-size: var(--font-size-2xl);
+		font-weight: 600;
+		line-height: var(--leading-snug);
+		letter-spacing: var(--tracking-snug);
+		margin-bottom: var(--spacing-2);
+		transition: color var(--transition-fast);
+	}
+
+	.post-link:hover .post-title {
+		color: var(--color-accent);
+	}
+
+	.post-excerpt {
+		font-size: var(--font-size-lg);
+		line-height: var(--leading-relaxed);
+		color: var(--color-text-secondary);
+	}
+
+	.post-tags {
+		display: flex;
+		flex-wrap: wrap;
+		gap: var(--spacing-2);
+		margin-top: var(--spacing-4);
+	}
+
+	.post-tag {
+		display: inline-block;
+		padding: var(--tag-padding-y) var(--spacing-3);
+		font-size: var(--font-size-sm);
+		color: var(--color-text-secondary);
+		background: var(--color-surface);
+		border-radius: var(--radius);
+		text-decoration: none;
+		transition:
+			color var(--transition-fast),
+			background var(--transition-fast);
+	}
+
+	.post-tag:hover {
+		color: var(--color-text);
+		background: var(--color-border);
+	}
+
+	@media (max-width: 600px) {
+		.posts-page {
+			padding: var(--spacing-6) var(--spacing-4) var(--spacing-12);
+		}
+
+		.page-title {
+			font-size: var(--font-size-3xl);
+		}
+
+		.post-title {
+			font-size: var(--font-size-xl);
+		}
+	}
+</style>

templates/blog/src/pages/rss.xml.ts

@@ -0,0 +1,70 @@
+import type { APIRoute } from "astro";
+import { getEmDashCollection } from "emdash";
+
+const siteTitle = "My Blog";
+const siteDescription = "A blog about software, design, and the occasional stray thought.";
+
+export const GET: APIRoute = async ({ site, url }) => {
+	const siteUrl = site?.toString() || url.origin;
+
+	const { entries: posts } = await getEmDashCollection("posts", {
+		orderBy: { published_at: "desc" },
+		limit: 20,
+	});
+
+	const items = posts
+		.map((post) => {
+			if (!post.data.publishedAt) return null;
+			const pubDate = post.data.publishedAt.toUTCString();
+
+			const postUrl = `${siteUrl}/posts/${post.id}`;
+			const title = escapeXml(post.data.title || "Untitled");
+			const description = escapeXml(post.data.excerpt || "");
+
+			return `    <item>
+      <title>${title}</title>
+      <link>${postUrl}</link>
+      <guid isPermaLink="true">${postUrl}</guid>
+      <pubDate>${pubDate}</pubDate>
+      <description>${description}</description>
+    </item>`;
+		})
+		.filter(Boolean)
+		.join("\n");
+
+	const rss = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${escapeXml(siteTitle)}</title>
+    <description>${escapeXml(siteDescription)}</description>
+    <link>${siteUrl}</link>
+    <atom:link href="${siteUrl}/rss.xml" rel="self" type="application/rss+xml"/>
+    <language>en-us</language>
+    <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>
+${items}
+  </channel>
+</rss>`;
+
+	return new Response(rss, {
+		headers: {
+			"Content-Type": "application/rss+xml; charset=utf-8",
+			"Cache-Control": "public, max-age=3600",
+		},
+	});
+};
+
+const XML_ESCAPE_PATTERNS = [
+	[/&/g, "&amp;"],
+	[/</g, "&lt;"],
+	[/>/g, "&gt;"],
+	[/"/g, "&quot;"],
+	[/'/g, "&apos;"],
+] as const;
+
+function escapeXml(str: string): string {
+	let result = str;
+	for (const [pattern, replacement] of XML_ESCAPE_PATTERNS) {
+		result = result.replace(pattern, replacement);
+	}
+	return result;
+}

templates/blog/src/pages/search.astro

@@ -0,0 +1,141 @@
+---
+export const prerender = false;
+
+import { getEmDashCollection } from "emdash";
+import Base from "../layouts/Base.astro";
+import PostCard from "../components/PostCard.astro";
+import { getReadingTime, extractText } from "../utils/reading-time";
+
+const query = Astro.url.searchParams.get("q")?.trim() || "";
+
+const { entries: allPosts } = await getEmDashCollection("posts");
+
+// Simple search: match query against title, excerpt, and content
+function matchesQuery(post: (typeof allPosts)[0], q: string): boolean {
+	if (!q) return false;
+	const lower = q.toLowerCase();
+	const title = (post.data.title || "").toLowerCase();
+	const excerpt = (post.data.excerpt || "").toLowerCase();
+	// Extract plain text from portable text blocks (avoids matching on _type, _key, etc.)
+	const content = extractText(post.data.content).toLowerCase();
+	return (
+		title.includes(lower) || excerpt.includes(lower) || content.includes(lower)
+	);
+}
+
+const results = query ? allPosts.filter((p) => matchesQuery(p, query)) : [];
+---
+
+<Base
+	title={query ? `Search: ${query}` : "Search"}
+	description="Search blog posts"
+>
+	<section class="search-page">
+		<h1 class="search-title">Search</h1>
+
+		<form method="get" action="/search" class="search-form">
+			<input
+				type="search"
+				name="q"
+				value={query}
+				placeholder="Search posts..."
+				class="search-input"
+				autofocus
+			/>
+			<button type="submit" class="search-button">Search</button>
+		</form>
+
+		{
+			query && (
+				<p class="search-summary">
+					{results.length === 0
+						? `No results for "${query}"`
+						: `${results.length} result${results.length === 1 ? "" : "s"} for "${query}"`}
+				</p>
+			)
+		}
+
+		{
+			results.length > 0 && (
+				<div class="search-results">
+					{results.map((post) => (
+						<PostCard
+							title={post.data.title}
+							excerpt={post.data.excerpt}
+							featuredImage={post.data.featured_image}
+							href={`/posts/${post.id}`}
+							date={post.data.publishedAt ?? undefined}
+							readingTime={getReadingTime(post.data.content)}
+						/>
+					))}
+				</div>
+			)
+		}
+
+		{!query && <p class="search-hint">Enter a search term to find posts.</p>}
+	</section>
+</Base>
+
+<style>
+	.search-page {
+		max-width: var(--max-width);
+		margin: 0 auto;
+		padding: var(--spacing-8) var(--spacing-6) var(--spacing-16);
+	}
+
+	.search-title {
+		font-size: var(--font-size-2xl);
+		margin-bottom: var(--spacing-6);
+	}
+
+	.search-form {
+		display: flex;
+		gap: var(--spacing-2);
+		margin-bottom: var(--spacing-8);
+	}
+
+	.search-input {
+		flex: 1;
+		padding: var(--spacing-2) var(--spacing-4);
+		font-size: var(--font-size-base);
+		border: 1px solid var(--color-border);
+		border-radius: var(--radius);
+		background: var(--color-bg);
+		color: var(--color-text);
+	}
+
+	.search-input:focus {
+		outline: none;
+		border-color: var(--color-accent);
+	}
+
+	.search-button {
+		padding: var(--spacing-2) var(--spacing-6);
+		font-size: var(--font-size-base);
+		background: var(--color-accent);
+		color: var(--color-on-accent);
+		border: none;
+		border-radius: var(--radius);
+		cursor: pointer;
+		font-weight: 500;
+	}
+
+	.search-button:hover {
+		opacity: 0.9;
+	}
+
+	.search-summary {
+		color: var(--color-muted);
+		margin-bottom: var(--spacing-6);
+	}
+
+	.search-hint {
+		color: var(--color-muted);
+	}
+
+	.search-results {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-8);
+	}
+</style>

templates/blog/src/pages/tag/[slug].astro

@@ -0,0 +1,120 @@
+---
+import { getTerm, getEmDashCollection, getEntryTerms } from "emdash";
+import Base from "../../layouts/Base.astro";
+import PostCard from "../../components/PostCard.astro";
+import { getReadingTime } from "../../utils/reading-time";
+
+const { slug } = Astro.params;
+const term = slug ? await getTerm("tag", slug) : null;
+
+if (!term) {
+	return Astro.redirect("/404");
+}
+
+const { entries: posts } = await getEmDashCollection("posts", {
+	where: { tag: term.slug },
+	orderBy: { published_at: "desc" },
+});
+
+// Fetch tags for display on each post card
+const filteredPosts = await Promise.all(
+	posts.map(async (post) => {
+		const tags = await getEntryTerms("posts", post.data.id, "tag");
+		return { post, tags };
+	})
+);
+---
+
+<Base
+	title={`Posts tagged "${term.label}"`}
+	description={`All posts tagged with ${term.label}`}
+>
+	<section class="archive-section">
+		<header class="archive-header">
+			<span class="archive-label">Tag</span>
+			<h1 class="archive-title">{term.label}</h1>
+			<p class="archive-count">
+				{filteredPosts.length}
+				{filteredPosts.length === 1 ? "post" : "posts"}
+			</p>
+		</header>
+
+		{
+			filteredPosts.length === 0 ? (
+				<p class="no-posts">No posts with this tag yet.</p>
+			) : (
+				<div class="posts-grid">
+					{filteredPosts.map(({ post, tags }) => (
+						<PostCard
+							title={post.data.title}
+							excerpt={post.data.excerpt}
+							featuredImage={post.data.featured_image}
+							href={`/posts/${post.id}`}
+							date={post.data.publishedAt ?? undefined}
+							readingTime={getReadingTime(post.data.content)}
+							tags={tags.map((t) => ({ slug: t.slug, label: t.label }))}
+						/>
+					))}
+				</div>
+			)
+		}
+	</section>
+</Base>
+
+<style>
+	.archive-section {
+		max-width: var(--wide-width);
+		margin: 0 auto;
+		padding: var(--spacing-12) var(--spacing-6);
+	}
+
+	.archive-header {
+		margin-bottom: var(--spacing-12);
+		padding-bottom: var(--spacing-8);
+		border-bottom: 1px solid var(--color-border-subtle);
+	}
+
+	.archive-label {
+		display: block;
+		font-size: var(--font-size-xs);
+		font-weight: 500;
+		color: var(--color-accent);
+		text-transform: uppercase;
+		letter-spacing: var(--tracking-wider);
+		margin-bottom: var(--spacing-2);
+	}
+
+	.archive-title {
+		font-size: var(--font-size-4xl);
+		font-weight: 700;
+		letter-spacing: var(--tracking-tight);
+		margin-bottom: var(--spacing-2);
+	}
+
+	.archive-count {
+		font-size: var(--font-size-sm);
+		color: var(--color-muted);
+	}
+
+	.posts-grid {
+		display: grid;
+		grid-template-columns: repeat(3, 1fr);
+		gap: var(--spacing-12) var(--spacing-8);
+	}
+
+	.no-posts {
+		color: var(--color-muted);
+	}
+
+	@media (max-width: 900px) {
+		.posts-grid {
+			grid-template-columns: repeat(2, 1fr);
+		}
+	}
+
+	@media (max-width: 600px) {
+		.posts-grid {
+			grid-template-columns: 1fr;
+		}
+	}
+</style>

templates/blog/src/styles/theme.css

@@ -0,0 +1,110 @@
+/*
+  theme.css — override any :root variable here to retheme the blog.
+
+  This is the only file you need to edit to customize the site's visual
+  appearance. All defaults are listed below as comments. Uncomment and
+  change any value to override it.
+
+  Note: this template defines explicit dark mode colors in Base.astro.
+  Overriding light-mode --color-* variables here won't affect dark mode.
+  To customize dark mode, also override --color-* variables inside a
+  @media (prefers-color-scheme: dark) block and/or in the :root.dark rule.
+*/
+
+:root {
+	/* --- Colors ---
+	--color-bg: #ffffff;
+	--color-bg-subtle: #fafafa;
+	--color-text: #1a1a1a;
+	--color-text-secondary: #525252;
+	--color-muted: #8b8b8b;
+	--color-border: #e5e5e5;
+	--color-border-subtle: #f0f0f0;
+	--color-surface: #f7f7f7;
+	--color-accent: #0066cc;
+	--color-accent-hover: #0052a3;
+	--color-on-accent: white;
+	--color-accent-ring: color-mix(in srgb, var(--color-accent) 25%, transparent);
+	*/
+
+	/* --- Fonts ---
+	--font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+	--font-mono: 'JetBrains Mono', ui-monospace, SFMono-Regular, Menlo, monospace;
+	*/
+
+	/* --- Type scale ---
+	--font-size-xs: 0.8125rem;
+	--font-size-sm: 0.875rem;
+	--font-size-base: 1rem;
+	--font-size-lg: 1.125rem;
+	--font-size-xl: 1.25rem;
+	--font-size-2xl: 1.5rem;
+	--font-size-3xl: 2rem;
+	--font-size-4xl: 2.5rem;
+	--font-size-5xl: 3.5rem;
+	*/
+
+	/* --- Line heights ---
+	--leading-tight: 1.15;
+	--leading-snug: 1.3;
+	--leading-normal: 1.5;
+	--leading-relaxed: 1.7;
+	*/
+
+	/* --- Letter spacing ---
+	--tracking-tight: -0.03em;    used on h1 and large titles
+	--tracking-snug: -0.02em;     used on h2–h6, site/card titles
+	--tracking-wide: 0.06em;      used on meta labels, TOC/widget titles
+	--tracking-wider: 0.08em;     used on footer headings, section labels
+	*/
+
+	/* --- Spacing ---
+	--spacing-1: 0.25rem;
+	--spacing-2: 0.5rem;
+	--spacing-3: 0.75rem;
+	--spacing-4: 1rem;
+	--spacing-5: 1.25rem;
+	--spacing-6: 1.5rem;
+	--spacing-8: 2rem;
+	--spacing-10: 2.5rem;
+	--spacing-12: 3rem;
+	--spacing-16: 4rem;
+	--spacing-20: 5rem;
+	--spacing-24: 6rem;
+	*/
+
+	/* --- Layout ---
+	--content-width: 680px;       article/page body column width
+	--wide-width: 1200px;         max container width (home, archives)
+	--gutter-width: 200px;        right sidebar column (TOC) on article pages
+	--meta-col-width: 180px;      left meta column on article pages
+	--nav-height: 64px;           sticky header height
+	--search-input-width: 180px;  nav search box width
+	*/
+
+	/* --- Borders & radius ---
+	--radius: 4px;
+	--radius-lg: 8px;
+	*/
+
+	/* --- Transitions ---
+	--transition-fast: 120ms ease;
+	--transition-base: 180ms ease;
+	*/
+
+	/* --- Avatars ---
+	--avatar-size-xs: 18px;    card byline avatars
+	--avatar-size-sm: 20px;    post list byline avatars
+	--avatar-size-md: 24px;    featured post byline avatars
+	--avatar-size-lg: 32px;    single post byline avatars
+	*/
+
+	/* --- Shadows ---
+	--shadow-dropdown: 0 8px 30px rgba(0, 0, 0, 0.12);
+	--shadow-btn-active: 0 1px 2px rgba(0, 0, 0, 0.05);
+	*/
+
+	/* --- Misc ---
+	--tag-padding-y: 2px;    vertical padding on tag pills
+	*/
+}

templates/blog/src/utils/reading-time.ts

@@ -0,0 +1,44 @@
+import type { PortableTextBlock } from "emdash";
+
+const WORDS_PER_MINUTE = 200;
+const WHITESPACE_REGEX = /\s+/;
+
+/**
+ * Extract plain text from Portable Text blocks
+ */
+export function extractText(blocks: PortableTextBlock[] | undefined): string {
+	if (!blocks || !Array.isArray(blocks)) return "";
+
+	return blocks
+		.filter(
+			(
+				block,
+			): block is PortableTextBlock & {
+				children: Array<{ _type: string; text?: string }>;
+			} => block._type === "block" && Array.isArray(block.children),
+		)
+		.map((block) =>
+			block.children
+				.filter((child) => child._type === "span" && typeof child.text === "string")
+				.map((span) => span.text)
+				.join(""),
+		)
+		.join(" ");
+}
+
+/**
+ * Calculate reading time in minutes from Portable Text content
+ */
+export function getReadingTime(content: PortableTextBlock[] | undefined): number {
+	const text = extractText(content);
+	const wordCount = text.split(WHITESPACE_REGEX).filter(Boolean).length;
+	const minutes = Math.ceil(wordCount / WORDS_PER_MINUTE);
+	return Math.max(1, minutes);
+}
+
+/**
+ * Format reading time for display
+ */
+export function formatReadingTime(minutes: number): string {
+	return `${minutes} min read`;
+}

templates/blog/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"extends": "astro/tsconfigs/base",
+	"compilerOptions": {
+		"types": [
+			"node"
+		]
+	},
+	"include": [
+		"src",
+		".astro/types.d.ts",
+		"emdash-env.d.ts"
+	]
+}