@rmdes/indiekit-endpoint-site-config 1.0.0-alpha.7 → 1.0.0-beta.2

package/index.js

@@ -2,21 +2,31 @@ import express from "express";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { identityRouter } from "./lib/controllers/identity.js";
-import { brandingRouter } from "./lib/controllers/branding.js";
-import { layoutRouter } from "./lib/controllers/layout.js";
-import { featuresRouter } from "./lib/controllers/features.js";
-import { apiRouter } from "./lib/controllers/api.js";
-import { getSiteConfig } from "./lib/storage/get-site-config.js";
-import { maybeSeedFromEnv } from "./lib/storage/seed-from-env.js";
-import { writeThemeCss } from "./lib/render/write-theme-css.js";
+import { identityRouter   } from "./lib/controllers/identity.js";
+import { brandingRouter   } from "./lib/controllers/branding.js";
+import { homepageRouter   } from "./lib/controllers/homepage.js";
+import { blogRouter       } from "./lib/controllers/blog.js";
+import { navigationRouter } from "./lib/controllers/navigation.js";
+import { featuresRouter   } from "./lib/controllers/features.js";
+import { apiRouter        } from "./lib/controllers/api.js";
+
+import { getSiteConfig     } from "./lib/storage/get-site-config.js";
+import { getHomepageConfig } from "./lib/storage/get-homepage-config.js";
+import { maybeSeedFromEnv  } from "./lib/storage/seed-from-env.js";
+import { maybeBackfillIdentity } from "./lib/storage/backfill-identity.js";
+
+import { writeThemeCss    } from "./lib/render/write-theme-css.js";
 import { writeCriticalCss } from "./lib/render/write-critical-css.js";
-import { writeSiteJson } from "./lib/render/write-site-json.js";
+import { writeSiteJson    } from "./lib/render/write-site-json.js";
+import { writeHomepageJson } from "./lib/render/write-homepage-json.js";
+
+import { scanPlugins } from "./lib/discovery/scan-plugins.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const defaults = {
   mountPath: "/site-config",
+  contentDir: "/app/data/content",
 };
 
 export default class SiteConfigEndpoint {
@@ -54,27 +64,47 @@ export default class SiteConfigEndpoint {
 
   async init(Indiekit) {
     Indiekit.addEndpoint(this);
+    Indiekit.addCollection("siteConfig");
+    Indiekit.addCollection("homepageConfig");
+
+    Indiekit.config.application.contentDir = this.options.contentDir;
+
     this._apiRouter = apiRouter(Indiekit);
 
     const protectedRouter = express.Router();
     protectedRouter.get("/", (req, res) => res.redirect(`${this.mountPath}/identity`));
-    protectedRouter.use("/identity", identityRouter(Indiekit));
-    protectedRouter.use("/branding", brandingRouter(Indiekit));
-    protectedRouter.use("/layout",   layoutRouter(Indiekit));
-    protectedRouter.use("/features", featuresRouter(Indiekit));
+    protectedRouter.use("/identity",   identityRouter(Indiekit));
+    protectedRouter.use("/branding",   brandingRouter(Indiekit));
+    protectedRouter.use("/homepage",   homepageRouter(Indiekit));
+    protectedRouter.use("/blog",       blogRouter(Indiekit));
+    protectedRouter.use("/navigation", navigationRouter(Indiekit));
+    protectedRouter.use("/features",   featuresRouter(Indiekit));
 
     this.routes = protectedRouter;
 
-    // Ensure files exist on first boot — synchronously regenerate.
+    // First-boot seed + initial file write
     try {
       await maybeSeedFromEnv(Indiekit);
-      const config = await getSiteConfig(Indiekit);
+      await maybeBackfillIdentity(Indiekit);
+      const config   = await getSiteConfig(Indiekit);
+      const homepage = await getHomepageConfig(Indiekit);
       await writeThemeCss(config);
       await writeCriticalCss(config);
       await writeSiteJson(config);
+      await writeHomepageJson(homepage);
     } catch (error) {
       console.warn("[site-config] initial render skipped:", error.message);
     }
+
+    // Plugin discovery — defer until all plugins' init() has returned
+    const self = this;
+    process.nextTick(() => {
+      try {
+        scanPlugins(Indiekit, self);
+      } catch (error) {
+        console.warn("[site-config] plugin discovery failed:", error.message);
+      }
+    });
   }
 
   get routesPublic() {

package/lib/controllers/api.js

@@ -1,5 +1,6 @@
 import express from "express";
 import { getSiteConfig, mergeWithDefaults } from "../storage/get-site-config.js";
+import { getHomepageConfig } from "../storage/get-homepage-config.js";
 import { renderThemeCss } from "../render/write-theme-css.js";
 import { parseBrandingForm } from "./branding.js";
 import { validateBranding } from "../validators/contrast.js";
@@ -111,6 +112,72 @@ export function apiRouter(Indiekit) {
     }
   });
 
+  /**
+   * GET /site-config/api/sections
+   *
+   * Discovery endpoint — returns the list of sections discovered from all
+   * registered plugins via the `homepageSections` collector. Consumed by the
+   * admin UI views (homepage composer) to populate the available-sections
+   * picker. Auth is enforced by the parent router mount (admin-only).
+   */
+  router.get("/sections", (req, res) => {
+    res.setHeader("Cache-Control", "no-store");
+    res.json(Indiekit.config?.application?.discoveredSections || []);
+  });
+
+  /**
+   * GET /site-config/api/widgets
+   *
+   * Discovery endpoint — returns the list of widgets discovered from all
+   * registered plugins via the `homepageWidgets` collector. Consumed by the
+   * admin UI views (sidebar composer). Auth is enforced by the parent
+   * router mount (admin-only).
+   */
+  router.get("/widgets", (req, res) => {
+    res.setHeader("Cache-Control", "no-store");
+    res.json(Indiekit.config?.application?.discoveredWidgets || []);
+  });
+
+  /**
+   * GET /site-config/api/blog-widgets
+   *
+   * Discovery endpoint — returns the list of blog-post-specific widgets
+   * discovered from all registered plugins via the `blogPostWidgets`
+   * collector. Consumed by the admin UI views (blog post sidebar composer).
+   * Auth is enforced by the parent router mount (admin-only).
+   */
+  router.get("/blog-widgets", (req, res) => {
+    res.setHeader("Cache-Control", "no-store");
+    res.json(Indiekit.config?.application?.discoveredBlogPostWidgets || []);
+  });
+
+  /**
+   * GET /site-config/api/homepage.json (PUBLIC)
+   *
+   * Public read-only view of the homepage config. Intended for external
+   * theme/SSG consumers (Eleventy, Hugo, Astro, etc.) that need to render
+   * the same layout shape Indiekit's own theme renders.
+   *
+   * Mounted under `routesPublic` (no auth). To avoid leaking PII, the
+   * `updatedBy` field (admin user URL) is stripped before sending.
+   *
+   * Security headers:
+   *   - `Cache-Control: no-store` — operators flip layouts frequently
+   *   - `X-Content-Type-Options: nosniff` — defense-in-depth against MIME
+   *     confusion for a JSON endpoint that could be embedded in pages
+   */
+  router.get("/homepage.json", async (req, res, next) => {
+    try {
+      const homepage = await getHomepageConfig(Indiekit);
+      const { updatedBy, ...publicShape } = homepage;
+      res.setHeader("Cache-Control", "no-store");
+      res.setHeader("X-Content-Type-Options", "nosniff");
+      res.json(publicShape);
+    } catch (error) {
+      next(error);
+    }
+  });
+
   return router;
 }
 

package/lib/controllers/blog.js

@@ -0,0 +1,44 @@
+import express from "express";
+import { getHomepageConfig } from "../storage/get-homepage-config.js";
+import { saveHomepageConfig } from "../storage/save-homepage-config.js";
+import { writeHomepageJson } from "../render/write-homepage-json.js";
+import { parseEntryArray } from "./homepage.js";
+
+export function parseBlogBody(body) {
+  return {
+    blogListingSidebar: parseEntryArray(body.blogListingSidebar),
+    blogPostSidebar:    parseEntryArray(body.blogPostSidebar),
+  };
+}
+
+export function blogRouter(Indiekit) {
+  const router = express.Router();
+
+  router.get("/", async (req, res, next) => {
+    try {
+      const homepage = await getHomepageConfig(Indiekit);
+      res.render("site-config-blog", {
+        homepage,
+        activeTab: "blog",
+        availableWidgets:         Indiekit.config?.application?.discoveredWidgets         || [],
+        availableBlogPostWidgets: Indiekit.config?.application?.discoveredBlogPostWidgets || [],
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post("/", async (req, res, next) => {
+    try {
+      const patch = parseBlogBody(req.body);
+      const userIdent = Indiekit.config?.publication?.me || "unknown";
+      const updated = await saveHomepageConfig(Indiekit, patch, userIdent);
+      await writeHomepageJson(updated);
+      res.redirect("/site-config/blog?saved=1");
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  return router;
+}

package/lib/controllers/branding.js

@@ -17,7 +17,7 @@ import {
   derivePaletteFromBase,
 } from "../render/derive-palette.js";
 import { resolveTier2Defaults } from "../render/resolve-tier2.js";
-import { ROLE_KEYS, DEFAULTS, emptyRoles } from "../storage/defaults.js";
+import { ROLE_KEYS, DEFAULTS, emptyRoles } from "../storage/defaults-site.js";
 import {
   validateBranding,
   partitionContrastResults,

package/lib/controllers/homepage.js

@@ -0,0 +1,121 @@
+import express from "express";
+import { getSiteConfig } from "../storage/get-site-config.js";
+import { getHomepageConfig } from "../storage/get-homepage-config.js";
+import { saveHomepageConfig } from "../storage/save-homepage-config.js";
+import { writeHomepageJson } from "../render/write-homepage-json.js";
+import { LAYOUT_PRESETS } from "../presets/layout-presets.js";
+
+const VALID_LAYOUTS = new Set(["single-column", "two-column", "full-width-hero"]);
+
+export function parseEntryArray(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value);
+  }
+  return [];
+}
+
+function validLayout(raw) {
+  return VALID_LAYOUTS.has(raw) ? raw : "two-column";
+}
+
+export function parseHomepageBody(body) {
+  return {
+    layout: validLayout(body.layout),
+    hero: {
+      enabled:    body.heroEnabled    === "on" || body.heroEnabled    === true,
+      showSocial: body.heroShowSocial === "on" || body.heroShowSocial === true,
+    },
+    sections: parseEntryArray(body.sections),
+    sidebar:  parseEntryArray(body.sidebar),
+    footer:   parseEntryArray(body.footer),
+  };
+}
+
+export function detectActivePreset(homepage, presets) {
+  for (const preset of presets) {
+    if (homepage.layout !== preset.layout) continue;
+    const configTypes = (homepage.sections || []).map((s) => s.type).join(",");
+    const presetTypes = preset.sections.map((s) => s.type).join(",");
+    if (configTypes !== presetTypes) continue;
+    const configWidgets = (homepage.sidebar || []).map((w) => w.type).join(",");
+    const presetWidgets = preset.sidebar.map((w) => w.type).join(",");
+    if (configWidgets !== presetWidgets) continue;
+    return preset.id;
+  }
+  return null;
+}
+
+export function homepageRouter(Indiekit) {
+  const router = express.Router();
+
+  router.get("/", async (req, res, next) => {
+    try {
+      const config = await getSiteConfig(Indiekit);
+      const homepage = await getHomepageConfig(Indiekit);
+      const activePresetId = detectActivePreset(homepage, LAYOUT_PRESETS);
+      res.render("site-config-homepage", {
+        config,
+        homepage,
+        activeTab: "homepage",
+        layouts: [
+          { id: "single-column",   label: "Single Column" },
+          { id: "two-column",      label: "Two Column with Sidebar" },
+          { id: "full-width-hero", label: "Full-width Hero + Grid" },
+        ],
+        layoutPresets: LAYOUT_PRESETS,
+        availableSections: Indiekit.config?.application?.discoveredSections || [],
+        availableWidgets:  Indiekit.config?.application?.discoveredWidgets  || [],
+        activePresetId,
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post("/", async (req, res, next) => {
+    try {
+      const patch = parseHomepageBody(req.body);
+      const userIdent = Indiekit.config?.publication?.me || "unknown";
+      const updated = await saveHomepageConfig(Indiekit, patch, userIdent);
+      await writeHomepageJson(updated);
+      res.redirect("/site-config/homepage?saved=1");
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post("/apply-preset", async (req, res, next) => {
+    try {
+      const presetId = req.body.presetId;
+      const preset = LAYOUT_PRESETS.find((p) => p.id === presetId);
+      if (!preset) {
+        res.status(400).redirect("/site-config/homepage?error=preset");
+        return;
+      }
+      const patch = {
+        layout:   preset.layout,
+        hero:     preset.hero,
+        sections: preset.sections,
+        sidebar:  preset.sidebar,
+        footer:   preset.footer,
+      };
+      const userIdent = Indiekit.config?.publication?.me || "unknown";
+      const updated = await saveHomepageConfig(Indiekit, patch, userIdent);
+      await writeHomepageJson(updated);
+      res.redirect("/site-config/homepage?saved=1");
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  return router;
+}

package/lib/controllers/identity.js

@@ -2,22 +2,68 @@ import express from "express";
 import { getSiteConfig } from "../storage/get-site-config.js";
 import { saveSiteConfig } from "../storage/save-site-config.js";
 import { writeSiteJson } from "../render/write-site-json.js";
+import {
+  isValidUrl, isValidEmail, isValidLocale,
+  normalizeCategoriesInput,
+} from "../validators/identity.js";
+import { sanitizeSocialList } from "../validators/social.js";
 
-const LOCALE_RE = /^[a-z]{2}(-[A-Z]{2})?$/;
 const TIMEZONE_RE = /^[A-Za-z]+\/[A-Za-z_\/]+$/;
 
 function validLocale(raw) {
-  const v = raw?.trim() || "en";
-  return LOCALE_RE.test(v) ? v : "en";
+  const v = (raw || "").trim();
+  return isValidLocale(v) ? v : "en";
 }
 
 function validTimezone(raw) {
-  const v = raw?.trim() || "UTC";
-  // "UTC" is a special-case valid timezone that doesn't match the region/city pattern
+  const v = (raw || "").trim();
   if (v === "UTC") return v;
   return TIMEZONE_RE.test(v) ? v : "UTC";
 }
 
+function safeString(raw) {
+  return typeof raw === "string" ? raw.trim() : "";
+}
+
+function safeUrlOrEmpty(raw) {
+  const v = safeString(raw);
+  return isValidUrl(v, { allowEmpty: true }) ? v : "";
+}
+
+function safeEmailOrEmpty(raw) {
+  const v = safeString(raw);
+  return isValidEmail(v, { allowEmpty: true }) ? v : "";
+}
+
+function parseSocialFromBody(body) {
+  if (!body.social) return [];
+  const raw = Array.isArray(body.social) ? body.social : Object.values(body.social);
+  return sanitizeSocialList(raw);
+}
+
+export function parseIdentityBody(body) {
+  return {
+    name:           safeString(body.name),
+    avatar:         safeUrlOrEmpty(body.avatar),
+    title:          safeString(body.title),
+    pronoun:        safeString(body.pronoun),
+    bio:            safeString(body.bio),
+    description:    safeString(body.description),
+    locality:       safeString(body.locality),
+    country:        safeString(body.country),
+    org:            safeString(body.org),
+    url:            safeUrlOrEmpty(body.url),
+    email:          safeEmailOrEmpty(body.email),
+    keyUrl:         safeUrlOrEmpty(body.keyUrl),
+    categories:     normalizeCategoriesInput(body.categories),
+    social:         parseSocialFromBody(body),
+    locale:         validLocale(body.locale),
+    timezone:       validTimezone(body.timezone),
+    defaultOgImage: safeUrlOrEmpty(body.defaultOgImage),
+    tagline:        safeString(body.tagline),
+  };
+}
+
 export function identityRouter(Indiekit) {
   const router = express.Router();
 
@@ -35,19 +81,9 @@ export function identityRouter(Indiekit) {
 
   router.post("/", async (req, res, next) => {
     try {
-      const patch = {
-        identity: {
-          name: req.body.name?.trim() || "",
-          description: req.body.description?.trim() || "",
-          tagline: req.body.tagline?.trim() || "",
-          defaultAuthor: req.body.defaultAuthor?.trim() || "",
-          defaultOgImage: req.body.defaultOgImage?.trim() || "",
-          locale: validLocale(req.body.locale),
-          timezone: validTimezone(req.body.timezone),
-        },
-      };
+      const identity = parseIdentityBody(req.body);
       const userIdent = Indiekit.config?.publication?.me || "unknown";
-      const updated = await saveSiteConfig(Indiekit, patch, userIdent);
+      const updated = await saveSiteConfig(Indiekit, { identity }, userIdent);
       await writeSiteJson(updated);
       res.redirect("/site-config/identity?saved=1");
     } catch (error) {

package/lib/controllers/navigation.js

@@ -0,0 +1,63 @@
+import express from "express";
+import { getSiteConfig } from "../storage/get-site-config.js";
+import { saveSiteConfig } from "../storage/save-site-config.js";
+import { writeSiteJson } from "../render/write-site-json.js";
+
+function toArray(value) {
+  if (Array.isArray(value)) return value;
+  if (value === undefined || value === null) return [];
+  return [value];
+}
+
+function isExternal(url) {
+  try {
+    const u = new URL(url);
+    return u.protocol === "http:" || u.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+export function parseNavigationBody(body) {
+  const labels = toArray(body.navLabel).map((s) => (s || "").trim());
+  const urls   = toArray(body.navUrl).map((s) => (s || "").trim());
+  const max = Math.max(labels.length, urls.length);
+  const items = [];
+  for (let i = 0; i < max; i++) {
+    const label = labels[i] || "";
+    const url   = urls[i]   || "";
+    if (label === "" && url === "") continue;
+    items.push({ label, url, external: isExternal(url) });
+  }
+  return { items };
+}
+
+export function navigationRouter(Indiekit) {
+  const router = express.Router();
+
+  router.get("/", async (req, res, next) => {
+    try {
+      const config = await getSiteConfig(Indiekit);
+      res.render("site-config-navigation", {
+        config,
+        activeTab: "navigation",
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post("/", async (req, res, next) => {
+    try {
+      const navigation = parseNavigationBody(req.body);
+      const userIdent = Indiekit.config?.publication?.me || "unknown";
+      const updated = await saveSiteConfig(Indiekit, { navigation }, userIdent);
+      await writeSiteJson(updated);
+      res.redirect("/site-config/navigation?saved=1");
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  return router;
+}

package/lib/discovery/scan-plugins.js

@@ -0,0 +1,63 @@
+/**
+ * Plugin discovery — scan Indiekit.endpoints for homepageSections / homepageWidgets / blogPostWidgets.
+ * Merges with built-in presets, stores on Indiekit.config.application.
+ * @module discovery/scan-plugins
+ */
+
+import { BUILTIN_SECTIONS } from "../presets/builtin-sections.js";
+import { BUILTIN_WIDGETS } from "../presets/builtin-widgets.js";
+import { BUILTIN_BLOG_POST_WIDGETS } from "../presets/builtin-blog-post-widgets.js";
+
+function validEntry(entry) {
+  return entry && typeof entry.id === "string" && entry.id !== ""
+                && typeof entry.label === "string" && entry.label !== "";
+}
+
+export function scanPlugins(Indiekit, ownEndpoint) {
+  const sections        = [...BUILTIN_SECTIONS];
+  const widgets         = [...BUILTIN_WIDGETS];
+  const blogPostWidgets = [...BUILTIN_BLOG_POST_WIDGETS];
+
+  for (const endpoint of Indiekit.endpoints || []) {
+    if (endpoint === ownEndpoint) continue;
+    try {
+      const ep = endpoint;
+      if (ep.homepageSections) {
+        for (const s of ep.homepageSections) {
+          if (!validEntry(s)) {
+            console.warn(`[site-config] skipping malformed section from ${ep.name}`);
+            continue;
+          }
+          sections.push({ ...s, sourcePlugin: ep.name });
+        }
+      }
+      if (ep.homepageWidgets) {
+        for (const w of ep.homepageWidgets) {
+          if (!validEntry(w)) {
+            console.warn(`[site-config] skipping malformed widget from ${ep.name}`);
+            continue;
+          }
+          widgets.push({ ...w, sourcePlugin: ep.name });
+        }
+      }
+      if (ep.blogPostWidgets) {
+        for (const w of ep.blogPostWidgets) {
+          if (!validEntry(w)) continue;
+          blogPostWidgets.push({ ...w, sourcePlugin: ep.name });
+        }
+      }
+    } catch (error) {
+      console.warn(`[site-config] failed to read discovery getters from ${endpoint.name}: ${error.message}`);
+    }
+  }
+
+  Indiekit.config.application.discoveredSections        = sections;
+  Indiekit.config.application.discoveredWidgets         = widgets;
+  Indiekit.config.application.discoveredBlogPostWidgets = [...blogPostWidgets, ...widgets];
+
+  console.log(
+    `[site-config] discovered ${sections.length} sections, ` +
+    `${widgets.length} widgets, ` +
+    `${Indiekit.config.application.discoveredBlogPostWidgets.length} blog-post widgets`
+  );
+}

package/lib/presets/builtin-blog-post-widgets.js

@@ -0,0 +1,14 @@
+/**
+ * Built-in blog-post-specific sidebar widgets absorbed from @rmdes/indiekit-endpoint-homepage.
+ * Universal sidebar widgets (from builtin-widgets.js) are merged in at scan time.
+ * @module presets/builtin-blog-post-widgets
+ */
+
+export const BUILTIN_BLOG_POST_WIDGETS = Object.freeze([
+  { id: "author-card-compact", label: "Author Card (Compact)", description: "Compact h-card with avatar and name", icon: "user", defaultConfig: {}, configSchema: {} },
+  { id: "toc", label: "Table of Contents", description: "Auto-generated from headings", icon: "list", defaultConfig: {}, configSchema: {} },
+  { id: "post-categories", label: "Post Categories", description: "Categories for the current post", icon: "tag", defaultConfig: {}, configSchema: {} },
+  { id: "share", label: "Share", description: "Share on Bluesky and Mastodon", icon: "share", defaultConfig: {}, configSchema: {} },
+  { id: "subscribe", label: "Subscribe", description: "RSS and JSON feed links", icon: "rss", defaultConfig: {}, configSchema: {} },
+  { id: "recent-comments", label: "Recent Comments", description: "Latest IndieAuth comments", icon: "message-square", defaultConfig: {}, configSchema: {} },
+]);

package/lib/presets/builtin-sections.js

@@ -0,0 +1,80 @@
+/**
+ * Built-in section types absorbed from @rmdes/indiekit-endpoint-homepage.
+ * Pure data export — no logic.
+ * @module presets/builtin-sections
+ */
+
+export const BUILTIN_SECTIONS = Object.freeze([
+  {
+    id: "hero",
+    label: "Hero Section",
+    description: "Author intro with avatar, name, title, and bio",
+    icon: "user",
+    dataEndpoint: null,
+    defaultConfig: { showAvatar: true, showSocialLinks: true },
+    configSchema: {
+      showAvatar: { type: "boolean", label: "Show avatar" },
+      showSocialLinks: { type: "boolean", label: "Show social links" },
+    },
+  },
+  {
+    id: "featured-posts",
+    label: "Featured Posts",
+    description: "Curated posts pinned as featured",
+    icon: "star",
+    dataEndpoint: null,
+    defaultConfig: { maxItems: 6, showSummary: true },
+    configSchema: {
+      maxItems: { type: "number", label: "Max items", min: 1, max: 20 },
+      showSummary: { type: "boolean", label: "Show post summary" },
+    },
+  },
+  {
+    id: "recent-posts",
+    label: "Recent Posts",
+    description: "Latest posts from your blog",
+    icon: "file-text",
+    dataEndpoint: null,
+    defaultConfig: { maxItems: 10, postTypes: ["note", "article", "photo", "bookmark"] },
+    configSchema: {
+      maxItems: { type: "number", label: "Max items", min: 1, max: 50 },
+      postTypes: { type: "array", label: "Post types to include" },
+    },
+  },
+  {
+    id: "custom-html",
+    label: "Custom Content",
+    description: "Freeform HTML or Markdown block",
+    icon: "code",
+    dataEndpoint: null,
+    defaultConfig: { content: "" },
+    configSchema: {
+      content: { type: "textarea", label: "Content (HTML/Markdown)" },
+    },
+  },
+  {
+    id: "posting-activity",
+    label: "Posting Activity",
+    description: "GitHub-style contribution graph showing posting frequency",
+    icon: "activity",
+    dataEndpoint: null,
+    defaultConfig: { title: "Posting Activity", limit: 1 },
+    configSchema: {
+      title: { type: "text", label: "Section title" },
+      years: { type: "text", label: "Years to show (comma-separated, e.g. 2026,2025)" },
+      limit: { type: "number", label: "Number of years (ignored if specific years set)", min: 0, max: 10 },
+    },
+  },
+  {
+    id: "ai-usage",
+    label: "AI Transparency",
+    description: "AI usage stats, level breakdown, and contribution graph",
+    icon: "zap",
+    dataEndpoint: null,
+    defaultConfig: { title: "AI Transparency", limit: 1 },
+    configSchema: {
+      title: { type: "text", label: "Section title" },
+      limit: { type: "number", label: "Years to show in graph", min: 1, max: 10 },
+    },
+  },
+]);