@acms-subir/core 0.0.1

package/src/pages/admin/users.astro

@@ -0,0 +1,149 @@
+---
+import Admin from '../../layouts/Admin.astro';
+import Modal from '../../components/Modal.astro';
+import { getRepo } from '../../lib/repo';
+import { hashPassword, verifySessionToken, OWNER_ENV, SESSION_COOKIE } from '../../lib/auth';
+import { slugify, authorSlug } from '../../lib/schema';
+
+const repo = await getRepo(Astro.locals);
+
+// Only owners manage users. The env-password session is always owner.
+const sessionUserId = verifySessionToken(Astro.cookies.get(SESSION_COOKIE)?.value);
+const sessionUser = sessionUserId && sessionUserId !== OWNER_ENV ? await repo.getUser(sessionUserId) : null;
+const isOwner = sessionUserId === OWNER_ENV || sessionUser?.role === 'owner';
+
+let error = '';
+let failedOp = '';
+if (Astro.request.method === 'POST' && isOwner) {
+  const form = await Astro.request.formData();
+  const op = String(form.get('op'));
+  failedOp = op;
+  try {
+    if (op === 'create') {
+      const password = String(form.get('password') ?? '');
+      if (password.length < 8) throw new Error('Password must be at least 8 characters.');
+      await repo.createUser({
+        name: String(form.get('name') || '').trim() || 'Unnamed',
+        email: String(form.get('email') || '').trim(),
+        role: form.get('role') === 'owner' ? 'owner' : 'editor',
+        passHash: await hashPassword(password),
+      });
+    }
+    if (op === 'update') {
+      const id = String(form.get('id'));
+      const password = String(form.get('password') ?? '');
+      await repo.updateUser(id, {
+        name: String(form.get('name') ?? '').trim() || undefined,
+        role: form.get('role') === 'owner' ? 'owner' : 'editor',
+        bio: String(form.get('bio') ?? ''),
+        avatar: String(form.get('avatar') ?? '').trim(),
+        slug: String(form.get('slug') ?? '').trim() ? slugify(String(form.get('slug'))) : '',
+        ...(password ? { passHash: await hashPassword(password) } : {}),
+      });
+    }
+    if (op === 'delete') await repo.deleteUser(String(form.get('id')));
+    if (!error) return Astro.redirect('/admin/users');
+  } catch (e) {
+    error = e instanceof Error ? e.message : 'Something went wrong (duplicate email?).';
+  }
+}
+
+const users = await repo.listUsers();
+---
+
+<Admin title="Users" section="users">
+  <div class="page-head">
+    <h1>Users</h1>
+    {isOwner && <button class="btn primary" type="button" data-modal="invite-user">Invite user</button>}
+  </div>
+
+  {!isOwner && (
+    <div class="flash error">Only owners can manage users. Ask an owner (or sign in with the owner password) to make changes.</div>
+  )}
+  {error && <div class="flash error">{error}</div>}
+
+  {isOwner && (
+    <Modal id="invite-user" title="Invite user" open={!!error && failedOp === 'create'}>
+      <form method="post">
+        <input type="hidden" name="op" value="create" />
+        <div class="field-row">
+          <label class="field">
+            <span>Name</span>
+            <input type="text" name="name" placeholder="Name" required autofocus />
+          </label>
+          <label class="field">
+            <span>Role</span>
+            <select name="role">
+              <option value="editor">Editor</option>
+              <option value="owner">Owner</option>
+            </select>
+          </label>
+        </div>
+        <label class="field">
+          <span>Email</span>
+          <input type="email" name="email" placeholder="email@example.com" required />
+        </label>
+        <label class="field">
+          <span>Password</span>
+          <input type="password" name="password" placeholder="Min 8 characters" required minlength="8" />
+        </label>
+        <div class="modal-foot">
+          <button class="btn ghost" type="button" data-close>Cancel</button>
+          <button class="btn primary" type="submit">Add user</button>
+        </div>
+        <p class="hint" style="margin:12px 0 0">They sign in at <code>/admin/login</code> with email + password. Editors manage content; owners also manage users.</p>
+      </form>
+    </Modal>
+  )}
+
+  <div class="card">
+    <table class="list">
+      <thead><tr><th>User</th><th>Role</th><th></th></tr></thead>
+      <tbody>
+        {users.map((u) => (
+          <tr>
+            <td>
+              {isOwner ? (
+                <form method="post" style="display:flex;gap:8px;align-items:center;flex-wrap:wrap">
+                  <input type="hidden" name="op" value="update" />
+                  <input type="hidden" name="id" value={u.id} />
+                  <input type="text" name="name" value={u.name} style="width:150px" />
+                  <span class="t-sub" style="min-width:180px">{u.email}</span>
+                  <select name="role" style="width:100px">
+                    <option value="editor" selected={u.role === 'editor'}>Editor</option>
+                    <option value="owner" selected={u.role === 'owner'}>Owner</option>
+                  </select>
+                  <input type="password" name="password" placeholder="New password (optional)" style="width:180px" />
+                  <div style="display:flex;gap:8px;flex-wrap:wrap;width:100%;align-items:center">
+                    <span class="t-sub">/author/</span>
+                    <input type="text" name="slug" value={u.slug} placeholder={authorSlug(u)} style="width:140px" />
+                    <input type="url" name="avatar" value={u.avatar} placeholder="Avatar URL (media library or https://…)" style="flex:1;min-width:220px" />
+                  </div>
+                  <textarea name="bio" rows="2" placeholder="Short bio — shown on the author card under posts and on the author page" style="width:100%">{u.bio}</textarea>
+                  <button class="btn sm" type="submit">Save</button>
+                  <a class="btn sm ghost" href={`/author/${authorSlug(u)}`} target="_blank" rel="noopener">View profile ↗</a>
+                </form>
+              ) : (
+                <>
+                  <span class="t-title">{u.name}</span>
+                  <div class="t-sub">{u.email}</div>
+                </>
+              )}
+            </td>
+            <td><span class={`pill ${u.role === 'owner' ? 'home' : 'published'}`}>{u.role}</span></td>
+            <td style="text-align:right;width:80px">
+              {isOwner && (
+                <form class="inline-form" method="post" onsubmit="return confirm('Delete this user? Their posts stay, attributed to no one.')">
+                  <input type="hidden" name="op" value="delete" />
+                  <input type="hidden" name="id" value={u.id} />
+                  <button class="btn sm ghost danger" type="submit">Delete</button>
+                </form>
+              )}
+            </td>
+          </tr>
+        ))}
+        {users.length === 0 && <tr><td colspan="3" class="hint">No user accounts yet — the owner password from <code>.env</code> is the only login. Add accounts above to give posts real author bylines.</td></tr>}
+      </tbody>
+    </table>
+  </div>
+</Admin>

package/src/pages/api/backup.ts

@@ -0,0 +1,63 @@
+import type { APIRoute } from 'astro';
+import { verifySessionToken, OWNER_ENV, SESSION_COOKIE } from '../../lib/auth';
+import { getRepo } from '../../lib/repo';
+import { getMediaStore } from '../../lib/media/store';
+import { zipStream, type ZipEntry } from '../../lib/backup/zip';
+
+// Full-site backup as one ZIP download: content.json with every table,
+// fetched through the repo so sqlite and D1 both export the same shape,
+// plus the media binaries (originals + variants) under media/<key>.
+// Password hashes never leave the repo layer, so user accounts export
+// without them — after a restore, sign in with ADMIN_PASSWORD and reset.
+export const GET: APIRoute = async ({ cookies, locals }) => {
+  const sessionUserId = verifySessionToken(cookies.get(SESSION_COOKIE)?.value);
+  if (!sessionUserId) {
+    return Response.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+  const repo = await getRepo(locals);
+  // a backup holds everything, including the user list — owners only
+  const sessionUser = sessionUserId !== OWNER_ENV ? await repo.getUser(sessionUserId) : null;
+  if (sessionUserId !== OWNER_ENV && sessionUser?.role !== 'owner') {
+    return Response.json({ error: 'Only owners can download backups' }, { status: 403 });
+  }
+
+  const [settings, pages, posts, media, links, tags, navItems, users, redirects] = await Promise.all([
+    repo.getSettings(),
+    repo.listPages(),
+    repo.listPosts(),
+    repo.listMedia(),
+    repo.listLinks(),
+    repo.listTags(),
+    repo.listNavItems(),
+    repo.listUsers(),
+    repo.listRedirects(),
+  ]);
+
+  const now = Date.now();
+  const content = {
+    format: 'acms-backup',
+    version: 2,
+    exportedAt: new Date(now).toISOString(),
+    settings, pages, posts, media, links, tags, navItems, users, redirects,
+  };
+
+  const store = getMediaStore(locals);
+  async function* entries(): AsyncGenerator<ZipEntry> {
+    yield { name: 'content.json', data: new TextEncoder().encode(JSON.stringify(content, null, 2)) };
+    for (const m of media) {
+      for (const key of [m.key, ...m.variants.map((v) => v.key)]) {
+        const obj = await store.get(key);
+        if (!obj) continue; // a missing binary shouldn't abort the archive
+        yield { name: `media/${key}`, data: new Uint8Array(await new Response(obj.body).arrayBuffer()) };
+      }
+    }
+  }
+
+  const stamp = new Date(now).toISOString().slice(0, 10);
+  return new Response(zipStream(entries(), now), {
+    headers: {
+      'Content-Type': 'application/zip',
+      'Content-Disposition': `attachment; filename="acms-backup-${stamp}.zip"`,
+    },
+  });
+};

package/src/pages/api/drafts.ts

@@ -0,0 +1,106 @@
+import type { APIRoute } from 'astro';
+import { timingSafeEqual } from 'node:crypto';
+import { z } from 'zod';
+import { getRepo } from '../../lib/repo';
+import { renderMarkdown } from '../../lib/markdown';
+import { slugify } from '../../lib/schema';
+
+// External drafts API: a trusted outside app (e.g. a drafts editor) pushes
+// markdown here and it lands as a draft post, ready to refine in the admin.
+// Create-only by design — the key can never publish, edit, or delete, so a
+// leaked key costs at most junk drafts. Key + allowed browser origins are
+// managed in /admin/settings; an empty key keeps the endpoint off.
+
+const MAX_BODY_BYTES = 1_000_000;
+
+const DraftInput = z.object({
+  title: z.string().trim().min(1, 'title is required'),
+  content: z.string().default(''), // markdown
+  excerpt: z.string().default(''),
+  tags: z.array(z.string().trim().min(1)).default([]),
+  slug: z.string().default(''),
+  cover: z.string().default(''),
+});
+
+// Allowlist entries: exact origins, '<scheme>://<host>:*' (any port), or '*'.
+function originAllowed(origin: string, list: string[]): boolean {
+  return list.some((entry) => {
+    if (entry === '*') return true;
+    if (entry.endsWith(':*')) return origin === entry.slice(0, -2) || origin.startsWith(entry.slice(0, -1));
+    return origin === entry;
+  });
+}
+
+function corsHeaders(origin: string): Record<string, string> {
+  return {
+    'Access-Control-Allow-Origin': origin,
+    'Access-Control-Allow-Methods': 'POST',
+    'Access-Control-Allow-Headers': 'Authorization, Content-Type',
+    'Access-Control-Max-Age': '86400',
+    Vary: 'Origin',
+  };
+}
+
+function keyEqual(a: string, b: string): boolean {
+  return a.length === b.length && timingSafeEqual(Buffer.from(a), Buffer.from(b));
+}
+
+export const OPTIONS: APIRoute = async ({ request, locals }) => {
+  const origin = request.headers.get('Origin');
+  if (!origin) return new Response(null, { status: 204 });
+  const settings = await (await getRepo(locals)).getSettings();
+  if (!originAllowed(origin, settings.draftsAllowedOrigins)) {
+    return new Response(null, { status: 403 });
+  }
+  return new Response(null, { status: 204, headers: corsHeaders(origin) });
+};
+
+export const POST: APIRoute = async ({ request, locals }) => {
+  const repo = await getRepo(locals);
+  const settings = await repo.getSettings();
+
+  // browser callers must be on the allowlist; non-browser clients (curl,
+  // scripts) send no Origin and are gated by the key alone
+  const origin = request.headers.get('Origin');
+  const cors = origin ? corsHeaders(origin) : undefined;
+  const respond = (body: unknown, status: number) => Response.json(body, { status, headers: cors });
+  if (origin && !originAllowed(origin, settings.draftsAllowedOrigins)) {
+    return Response.json({ error: 'Origin not allowed' }, { status: 403 });
+  }
+
+  if (!settings.draftsApiKey) {
+    return respond({ error: 'Drafts API is not enabled — generate a key in Settings.' }, 503);
+  }
+  const auth = request.headers.get('Authorization') ?? '';
+  const key = auth.startsWith('Bearer ') ? auth.slice(7) : '';
+  if (!key || !keyEqual(key, settings.draftsApiKey)) {
+    return respond({ error: 'Invalid API key' }, 401);
+  }
+
+  const raw = await request.text();
+  if (raw.length > MAX_BODY_BYTES) return respond({ error: 'Body too large' }, 413);
+  let input: z.infer<typeof DraftInput>;
+  try {
+    input = DraftInput.parse(JSON.parse(raw));
+  } catch (e) {
+    if (e instanceof z.ZodError) return respond({ error: 'Invalid payload', issues: e.issues }, 400);
+    return respond({ error: 'Body must be valid JSON' }, 400);
+  }
+
+  const base = slugify(input.slug || input.title);
+  let slug = base;
+  for (let n = 2; await repo.getPostBySlug(slug); n++) slug = `${base}-${n}`;
+
+  const post = await repo.createPost({ title: input.title, slug });
+  await repo.updatePost(post.id, {
+    body: input.content,
+    bodyHtml: input.content ? renderMarkdown(input.content) : '',
+    excerpt: input.excerpt,
+    tags: input.tags,
+    cover: input.cover,
+  });
+  if (input.tags.length) await repo.ensureTags(input.tags);
+
+  const editUrl = new URL(`/admin/posts/${post.id}`, request.url).toString();
+  return respond({ id: post.id, slug, status: 'draft', editUrl }, 201);
+};

package/src/pages/api/media/upload.ts

@@ -0,0 +1,89 @@
+import type { APIRoute } from 'astro';
+import { verifySessionToken, SESSION_COOKIE } from '../../../lib/auth';
+import { getRepo } from '../../../lib/repo';
+import { getMediaStore } from '../../../lib/media/store';
+
+// Multipart upload from the admin. For images the client has already done
+// the heavy lifting (EXIF rotation, downscale to max 1080px, WebP re-encode,
+// variant generation); this route just stores the optimized file + variants
+// and records the media row. SVG/GIF arrive untouched. Documents (for the
+// file/download card) are stored as-is. Video/audio is deliberately rejected
+// — embeds cover video until a streaming upload + Range-serving pipeline
+// exists.
+//
+// Fields: file (primary), width, height, alt?, variant_<w> (File, webp)…
+const DOCUMENT_TYPES = new Set([
+  'application/pdf',
+  'application/zip',
+  'application/x-zip-compressed',
+  'application/json',
+  'text/plain',
+  'text/csv',
+  'text/markdown',
+  'application/msword',
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  'application/vnd.ms-excel',
+  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  'application/vnd.ms-powerpoint',
+  'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  'application/epub+zip',
+]);
+const MAX_IMAGE = 30 * 1024 * 1024;
+const MAX_DOCUMENT = 25 * 1024 * 1024;
+
+export const POST: APIRoute = async ({ request, cookies, locals }) => {
+  if (!verifySessionToken(cookies.get(SESSION_COOKIE)?.value)) {
+    return Response.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  const form = await request.formData();
+  const file = form.get('file');
+  if (!(file instanceof File) || file.size === 0) {
+    return Response.json({ error: 'Missing file' }, { status: 400 });
+  }
+  const isImage = file.type.startsWith('image/');
+  const isDocument = DOCUMENT_TYPES.has(file.type);
+  if (!isImage && !isDocument) {
+    const hint = file.type.startsWith('video/') || file.type.startsWith('audio/')
+      ? 'Video and audio uploads aren’t supported yet — use an embed card instead.'
+      : 'Unsupported file type.';
+    return Response.json({ error: hint }, { status: 415 });
+  }
+  const cap = isImage ? MAX_IMAGE : MAX_DOCUMENT;
+  if (file.size > cap) {
+    return Response.json({ error: `File too large (max ${Math.round(cap / 1024 / 1024)} MB)` }, { status: 413 });
+  }
+
+  const id = crypto.randomUUID();
+  const ext = (file.name.split('.').pop() || 'bin').toLowerCase().replace(/[^a-z0-9]/g, '') || 'bin';
+  const key = `${id}/original.${ext}`;
+  const store = getMediaStore(locals);
+  await store.put(key, await file.arrayBuffer(), file.type);
+
+  const variants: { w: number; key: string }[] = [];
+  for (const [field, value] of form.entries()) {
+    const m = field.match(/^variant_(\d+)$/);
+    if (m && value instanceof File && value.size > 0) {
+      const w = Number(m[1]);
+      const vkey = `${id}/w${w}.webp`;
+      await store.put(vkey, await value.arrayBuffer(), 'image/webp');
+      variants.push({ w, key: vkey });
+    }
+  }
+  variants.sort((a, b) => a.w - b.w);
+
+  const repo = await getRepo(locals);
+  const media = await repo.createMedia({
+    id,
+    key,
+    filename: file.name,
+    mime: file.type,
+    width: Number(form.get('width') ?? 0),
+    height: Number(form.get('height') ?? 0),
+    size: file.size,
+    alt: String(form.get('alt') ?? ''),
+    variants,
+  });
+
+  return Response.json({ media });
+};

package/src/pages/api/restore.ts

@@ -0,0 +1,102 @@
+import type { APIRoute } from 'astro';
+import { verifySessionToken, OWNER_ENV, SESSION_COOKIE } from '../../lib/auth';
+import { getRepo } from '../../lib/repo';
+import { getMediaStore } from '../../lib/media/store';
+import { unzip } from '../../lib/backup/unzip';
+import { Page, Post, Media, Link, Tag, User, NavItem, Redirect, Settings } from '../../lib/schema';
+import { z } from 'zod';
+
+// Restore a backup ZIP produced by /api/backup. Two modes:
+//   POST /api/restore?dry=1  — parse + validate, return a report, change nothing
+//   POST /api/restore        — REPLACE all content with the backup's
+// Owner-only, like the backup download. Restored user accounts have no
+// passwords (backups never include hashes) — sign in with ADMIN_PASSWORD.
+
+const BackupContent = z.object({
+  format: z.literal('acms-backup'),
+  version: z.number(),
+  settings: Settings.partial(),
+  pages: z.array(Page),
+  posts: z.array(Post),
+  media: z.array(Media),
+  links: z.array(Link),
+  tags: z.array(Tag),
+  navItems: z.array(NavItem),
+  users: z.array(User),
+  // added in backup version 2; older backups restore with none
+  redirects: z.array(Redirect).default([]),
+});
+
+export const POST: APIRoute = async ({ request, cookies, locals, url }) => {
+  const sessionUserId = verifySessionToken(cookies.get(SESSION_COOKIE)?.value);
+  if (!sessionUserId) return Response.json({ error: 'Unauthorized' }, { status: 401 });
+  const repo = await getRepo(locals);
+  const sessionUser = sessionUserId !== OWNER_ENV ? await repo.getUser(sessionUserId) : null;
+  if (sessionUserId !== OWNER_ENV && sessionUser?.role !== 'owner') {
+    return Response.json({ error: 'Only owners can restore backups' }, { status: 403 });
+  }
+
+  const form = await request.formData();
+  const file = form.get('file');
+  if (!(file instanceof File) || file.size === 0) {
+    return Response.json({ error: 'Missing backup file' }, { status: 400 });
+  }
+  if (file.size > 200 * 1024 * 1024) {
+    return Response.json({ error: 'Backup too large (max 200 MB)' }, { status: 413 });
+  }
+
+  let entries: Map<string, Uint8Array>;
+  try {
+    entries = unzip(await file.arrayBuffer());
+  } catch (e) {
+    return Response.json({ error: e instanceof Error ? e.message : 'Unreadable ZIP' }, { status: 400 });
+  }
+  const contentRaw = entries.get('content.json');
+  if (!contentRaw) return Response.json({ error: 'content.json missing — not an acms backup' }, { status: 400 });
+
+  const parsed = BackupContent.safeParse(JSON.parse(new TextDecoder().decode(contentRaw)));
+  if (!parsed.success) {
+    return Response.json({ error: 'content.json failed validation — is this from a newer acms?' }, { status: 400 });
+  }
+  const content = parsed.data;
+
+  // an incomplete archive must not restore media rows whose binary is gone —
+  // that would publish permanently-404ing /media/ URLs. Rows missing their
+  // primary binary are dropped; rows missing only variants lose the variants.
+  const mediaKeys = content.media.flatMap((m) => [m.key, ...m.variants.map((v) => v.key)]);
+  const missingBinaries = mediaKeys.filter((k) => !entries.has(`media/${k}`));
+  content.media = content.media
+    .filter((m) => entries.has(`media/${m.key}`))
+    .map((m) => ({ ...m, variants: m.variants.filter((v) => entries.has(`media/${v.key}`)) }));
+
+  if (url.searchParams.get('dry')) {
+    return Response.json({
+      report: {
+        exportedAt: (JSON.parse(new TextDecoder().decode(contentRaw)) as { exportedAt?: string }).exportedAt ?? null,
+        posts: content.posts.length,
+        pages: content.pages.length,
+        media: content.media.length,
+        links: content.links.length,
+        tags: content.tags.length,
+        navItems: content.navItems.length,
+        users: content.users.length,
+        missingBinaries: missingBinaries.length,
+      },
+    });
+  }
+
+  // media binaries first, so content never references a missing object
+  const store = getMediaStore(locals);
+  for (const m of content.media) {
+    for (const key of [m.key, ...m.variants.map((v) => v.key)]) {
+      const data = entries.get(`media/${key}`);
+      if (!data) continue;
+      const buf = new ArrayBuffer(data.byteLength);
+      new Uint8Array(buf).set(data);
+      await store.put(key, buf, m.mime);
+    }
+  }
+  await repo.restoreAll(content);
+
+  return Response.json({ ok: true, restored: { posts: content.posts.length, pages: content.pages.length, media: content.media.length } });
+};

package/src/pages/author/[slug].astro

@@ -0,0 +1,66 @@
+---
+import Site from '../../layouts/Site.astro';
+import { getRepo } from '../../lib/repo';
+import { authorSlug } from '../../lib/schema';
+import { formatDate } from '../../lib/dates';
+import { CONTENT, collectionUrl } from '../../lib/content';
+
+const PAGE_SIZE = 10;
+const { slug } = Astro.params;
+const repo = await getRepo(Astro.locals);
+const [users, settings] = await Promise.all([repo.listUsers(), repo.getSettings()]);
+// stored slug wins; slugified name is the fallback so profiles work untouched
+const author = users.find((u) => authorSlug(u) === slug);
+if (!author) return new Response(null, { status: 404, statusText: 'Not found' });
+
+// includes co-authored posts (authorIds), not just primary authorship
+const allPosts = (await repo.listPublishedPosts()).filter(
+  (p) => p.authorId === author.id || p.authorIds.includes(author.id)
+);
+const pageCount = Math.max(1, Math.ceil(allPosts.length / PAGE_SIZE));
+const pageNum = Math.min(pageCount, Math.max(1, Number(Astro.url.searchParams.get('page')) || 1));
+const posts = allPosts.slice((pageNum - 1) * PAGE_SIZE, pageNum * PAGE_SIZE);
+const base = `/author/${authorSlug(author)}`;
+
+const fmt = (ts: number | null) =>
+  formatDate(ts, settings, 'short');
+const readMins = (p: (typeof posts)[number]) =>
+  Math.max(1, Math.round((p.bodyHtml || p.body).replace(/<[^>]+>/g, ' ').split(/\s+/).filter(Boolean).length / 220));
+---
+
+<Site title={author.name} description={author.bio || `${CONTENT.posts.plural} by ${author.name}`}>
+  <header class="author-hero">
+    {author.avatar ? (
+      <img class="author-avatar" src={author.avatar} alt={author.name} />
+    ) : (
+      <span class="author-avatar author-initial" aria-hidden="true">{author.name.slice(0, 1)}</span>
+    )}
+    <div>
+      <p class="tag-kicker">Author · {allPosts.length} {(allPosts.length === 1 ? CONTENT.posts.singular : CONTENT.posts.plural).toLowerCase()}</p>
+      <h1>{author.name}</h1>
+      {author.bio && <p class="tag-desc">{author.bio}</p>}
+    </div>
+  </header>
+  {posts.length === 0 && <p>No published {CONTENT.posts.plural.toLowerCase()} yet.</p>}
+  <ul class="post-list">
+    {posts.map((p) => (
+      <li class="post-item">
+        {p.cover && (
+          <a class="post-thumb" href={collectionUrl(p.collection, p.slug)}><img src={p.cover} alt={p.coverAlt} loading="lazy" /></a>
+        )}
+        <div>
+          <a href={collectionUrl(p.collection, p.slug)}>{p.title}</a>
+          <div class="post-meta">{fmt(p.publishedAt)} · {readMins(p)} min read</div>
+          {p.excerpt && <p class="post-excerpt">{p.excerpt}</p>}
+        </div>
+      </li>
+    ))}
+  </ul>
+  {pageCount > 1 && (
+    <nav class="pager" aria-label="Pagination">
+      {pageNum > 1 ? <a href={pageNum === 2 ? base : `${base}?page=${pageNum - 1}`}>← Newer</a> : <span />}
+      <span class="pager-status">Page {pageNum} of {pageCount}</span>
+      {pageNum < pageCount ? <a href={`${base}?page=${pageNum + 1}`}>Older →</a> : <span />}
+    </nav>
+  )}
+</Site>