@palate/cli 0.0.0-stage → 0.0.1

package/src/catalog/classify.mjs

@@ -0,0 +1,96 @@
+// Turns raw font names and colours into the facets the ranker compares. Plain lookups and maths, no model.
+
+const FONT_CLASSES = {
+  "geometric-sans": ["geist", "inter display", "manrope", "plus jakarta sans", "poppins", "montserrat", "futura", "avenir", "circular", "satoshi", "general sans", "outfit", "urbanist", "sora", "lexend", "dm sans", "figtree", "gilroy", "product sans", "nunito", "cal sans", "geomanist", "aeonik", "clash display", "cabinet grotesk", "switzer", "space grotesk", "instrument sans"],
+  grotesk: ["inter", "helvetica", "neue haas", "suisse", "söhne", "sohne", "akkurat", "graphik", "untitled sans", "roboto", "arial", "sf pro", "system-ui", "-apple-system", "segoe ui", "ibm plex sans", "work sans", "archivo", "schibsted grotesk", "public sans", "geist sans", "abc diatype", "neue montreal", "pp neue montreal", "basis grotesque", "favorit", "atkinson hyperlegible"],
+  "humanist-sans": ["source sans", "open sans", "lato", "fira sans", "gill sans", "frutiger", "myriad", "noto sans", "segoe", "avenir next", "proxima nova", "nunito sans"],
+  serif: ["georgia", "times", "garamond", "eb garamond", "cormorant", "playfair", "lora", "merriweather", "newsreader", "fraunces", "instrument serif", "tiempos", "gt sectra", "domaine", "spectral", "crimson", "libre baskerville", "source serif", "pp editorial", "editorial new", "iowan", "palatino", "canela", "gambarino", "recoleta", "ogg", "noe display", "dm serif", "reckless"],
+  mono: ["mono", "jetbrains", "fira code", "ibm plex mono", "sf mono", "menlo", "consolas", "courier", "space mono", "geist mono", "berkeley mono", "roboto mono", "commit mono"],
+  display: ["bebas", "anton", "druk", "monument", "pp mori", "migra", "tan pearl", "zodiak", "gloock"],
+};
+
+export function fontClass(name) {
+  const n = String(name ?? "").toLowerCase().replace(/["']/g, "").trim();
+  if (!n) return undefined;
+  // Longest match wins, so "inter display" beats "inter" and "geist mono" beats "geist".
+  let best;
+  for (const [cls, names] of Object.entries(FONT_CLASSES)) {
+    for (const f of names) if (n.includes(f) && (!best || f.length > best.len)) best = { cls, len: f.length };
+  }
+  if (best) return best.cls;
+  if (/mono|code/.test(n)) return "mono";
+  if (/serif/.test(n) && !/sans/.test(n)) return "serif";
+  if (/grotesk|grotesque|sans/.test(n)) return "grotesk";
+  return undefined;
+}
+
+export function hexToRgb(hex) {
+  const m = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(String(hex ?? "").trim());
+  if (!m) return undefined;
+  let h = m[1];
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  return [0, 2, 4].map((o) => parseInt(h.slice(o, o + 2), 16));
+}
+
+// Accepts hex, rgb() and oklch() strings (the formats found in tokens and catalogues).
+export function parseColor(s) {
+  const str = String(s ?? "").trim();
+  const rgb = hexToRgb(str);
+  if (rgb) return rgb;
+  const r = /rgba?\(\s*([\d.]+)[ ,]+([\d.]+)[ ,]+([\d.]+)/i.exec(str);
+  if (r) return [Number(r[1]), Number(r[2]), Number(r[3])];
+  const ok = /oklch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+)/i.exec(str);
+  if (ok) {
+    // Approximate: OKLCH lightness is close enough to luminance for light/dark decisions.
+    const L = Number(ok[1]) / (ok[2] ? 100 : 1);
+    const v = Math.round(Math.max(0, Math.min(1, L)) ** 2.2 * 255);
+    return [v, v, v];
+  }
+  return undefined;
+}
+
+export function luminance([r, g, b]) {
+  const ch = (c) => {
+    c /= 255;
+    return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * ch(r) + 0.7152 * ch(g) + 0.0722 * ch(b);
+}
+
+export function hueSat([r, g, b]) {
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const d = max - min;
+  const l = (max + min) / 2;
+  const s = d === 0 ? 0 : d / (1 - Math.abs(2 * l - 1));
+  let h = 0;
+  if (d) {
+    if (max === r) h = ((g - b) / d) % 6;
+    else if (max === g) h = (b - r) / d + 2;
+    else h = (r - g) / d + 4;
+    h *= 60;
+    if (h < 0) h += 360;
+  }
+  return { h, s };
+}
+
+export function themeOf(colors) {
+  const rgbs = colors.map(parseColor).filter(Boolean);
+  if (!rgbs.length) return undefined;
+  // The first colour is usually the background; weigh it most.
+  const lum = luminance(rgbs[0]);
+  return lum > 0.4 ? "light" : lum < 0.12 ? "dark" : "mid";
+}
+
+export function accentHue(colors) {
+  const sat = colors
+    .map(parseColor)
+    .filter(Boolean)
+    .map((c) => ({ ...hueSat(c), c }))
+    .filter((x) => x.s > 0.35)
+    .sort((a, b) => b.s - a.s)[0];
+  return sat ? Math.round(sat.h) : undefined;
+}

package/src/catalog/curated.mjs

@@ -0,0 +1,128 @@
+// Curated catalogue: the leading sites from kb/sources/*.md (tables of Site | URL | Best for | Notes).
+// These records have no image until palate captures the live site, which happens only when one is picked.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { fontClass } from "./classify.mjs";
+import { KB_ROOT } from "../paths.mjs";
+
+const SOURCES_DIR = process.env.PALATE_SOURCES ?? path.join(KB_ROOT, "sources");
+
+// "Best for" phrases → shelves. A site can sit on several shelves.
+const SHELF_WORDS = [
+  [/mobile|phone|ios app|daily checklist/i, "mobile"],
+  [/api reference|docs nav|docs landing|parameters/i, "docs"],
+  [/data table|table with|filters, row/i, "data-table"],
+  [/dashboard/i, "dashboard"],
+  [/settings/i, "settings"],
+  [/node canvas|workflow builder/i, "canvas"],
+  [/app layout|app shell|list \+ detail/i, "app-shell"],
+  [/hero|try-it|first screen/i, "hero"],
+  [/mega-?menu|nav|menu/i, "nav"],
+  [/pricing|plans?|toggle|engagement/i, "pricing"],
+  [/footer/i, "footer"],
+  [/testimonial|quote|wall of love|reviews?/i, "testimonials"],
+  [/logo|marquee|proof row/i, "logo-cloud"],
+  [/stats?|numbers|backbone/i, "stats"],
+  [/faq/i, "faq"],
+  [/bento|fig cards|feature tabs|tabs|pillars|product module/i, "features"],
+  [/workflow|canvas|demo|event stream|code tabs|product window/i, "features"],
+  [/how it works|process|steps/i, "how-it-works"],
+  [/integration|ecosystem|directory/i, "integrations"],
+  [/customers?\b|case stud|outcome|stories/i, "customers"],
+  [/changelog|research timeline|journal|blog/i, "changelog"],
+  [/cta/i, "cta"],
+  [/contact|sales page|booking|form/i, "contact"],
+  [/product page|made-to-order|bespoke|sizer|gift/i, "product-page"],
+  [/collection|shop by|nav by|curated|roster|doors/i, "collections"],
+  [/founder|maker|story|about|team|heritage/i, "about"],
+  [/events?|markets?|workshops?/i, "events"],
+  [/newsletter|club|coven|guild/i, "newsletter"],
+  [/seasonal|campaign/i, "campaign"],
+];
+
+const KNOWN_FONTS = ["Inter Variable", "Inter", "Geist", "Söhne", "Cal Sans", "Geomanist", "Domaine", "Waldenburg", "Geist Mono", "Cormorant Garamond", "Playfair", "IM Fell", "Cinzel"];
+
+function shelvesFor(text) {
+  const s = new Set();
+  for (const [re, shelf] of SHELF_WORDS) if (re.test(text)) s.add(shelf);
+  return [...s];
+}
+
+function themeFor(text) {
+  const t = text.toLowerCase();
+  if (/\b(dark|black|#0[0-9a-f]{5}|night|candlelit)\b/.test(t)) return "dark";
+  if (/\b(cream|white|light|#f[0-9a-f]{5}|cottage)\b/.test(t)) return "light";
+  return undefined;
+}
+
+function parseTables(md, file) {
+  const records = [];
+  let section = "";
+  for (const block of md.split(/\n(?=#+ )/)) {
+    const heading = /^#+ (.*)/.exec(block)?.[1] ?? section;
+    section = heading;
+    const lines = block.split("\n").filter((l) => l.trim().startsWith("|"));
+    if (lines.length < 3) continue;
+    const head = lines[0].split("|").map((c) => c.trim().toLowerCase());
+    const col = (name) => head.findIndex((h) => h === name);
+    const urlCol = head.findIndex((h) => h === "url" || h === "link");
+    const nameCol = [col("site"), col("shop"), col("entry")].find((i) => i >= 0);
+    if (urlCol < 0 || nameCol === undefined) continue;
+    const bestCol = [col("best for"), col("what's great")].find((i) => i >= 0);
+    const notesCol = col("notes");
+    const sectionCol = col("section");
+    for (const line of lines.slice(2)) {
+      const cells = line.split("|").map((c) => c.trim());
+      const url = /https?:\/\/[^\s)|]+/.exec(cells[urlCol] ?? "")?.[0];
+      if (!url) continue;
+      const name = cells[nameCol]?.replace(/\*\*/g, "");
+      const best = bestCol !== undefined ? cells[bestCol] ?? "" : "";
+      const notes = notesCol >= 0 ? cells[notesCol] ?? "" : "";
+      const shelfText = [sectionCol >= 0 ? cells[sectionCol] : "", best].join(" ");
+      const fonts = KNOWN_FONTS.filter((f) => notes.includes(f));
+      const scope = /shop|maker|gothic|botanical/i.test(heading) ? "commerce" : /docs|api|changelog/i.test(heading) ? "docs" : /app screens|dashboard/i.test(heading) ? "app" : /mobile/i.test(heading) ? "mobile" : "marketing";
+      records.push({
+        id: `curated:${name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}`,
+        source: path.basename(file),
+        url,
+        site: url,
+        name,
+        description: [best, notes].filter(Boolean).join(". "),
+        format: "curated",
+        shelf: shelvesFor(shelfText)[0] ?? "website",
+        shelves: [...new Set([...shelvesFor(shelfText), "website"])],
+        categories: [scope],
+        industry: [scope === "commerce" ? "handmade shop" : scope === "docs" ? "developer" : "saas"],
+        style: [],
+        colorTags: [],
+        interaction: [],
+        audience: [],
+        features: [],
+        keywords: words(best).slice(0, 12),
+        fonts,
+        typeClasses: [...new Set(fonts.map(fontClass).filter(Boolean))],
+        colors: [],
+        theme: themeFor(`${best} ${notes}`),
+        image: undefined,
+        capture: true, // capture the live page when picked
+        related: [],
+        views: 0,
+        curated: true,
+        section: heading,
+      });
+    }
+  }
+  return records;
+}
+
+const words = (s) => (s.toLowerCase().match(/[a-z][a-z-]{2,}/g) ?? []).filter((w) => !["the", "and", "with", "for"].includes(w));
+
+export function curatedRecords() {
+  if (!fs.existsSync(SOURCES_DIR)) return [];
+  return fs
+    .readdirSync(SOURCES_DIR)
+    .filter((f) => f.endsWith(".md"))
+    .flatMap((f) => parseTables(fs.readFileSync(path.join(SOURCES_DIR, f), "utf8"), f))
+    .filter((r, i, all) => all.findIndex((x) => x.id === r.id) === i);
+}

package/src/catalog/index-build.mjs

@@ -0,0 +1,67 @@
+// Builds the index palate ships with: facts and links only (name, original site, shelf, tags, fonts,
+// credit link), enriched with each original site's own <title>, meta description and theme colour.
+// Users get this file, so they never crawl a gallery; only the 2-3 picked sites are captured, live.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readCatalogs } from "./store.mjs";
+import { themeOf } from "./classify.mjs";
+import { KB_ROOT } from "../paths.mjs";
+
+export const INDEX_DIR = process.env.PALATE_INDEX ?? path.join(KB_ROOT, "index");
+
+const decode = (s) => s.replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;|&#x27;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").trim();
+
+async function siteFacts(url) {
+  if (/\/\/(www\.)?(x|twitter)\.com\//i.test(url)) return {};
+  try {
+    const res = await fetch(url, { headers: { "user-agent": "palate-index/0.1 (design reference index)", accept: "text/html" }, signal: AbortSignal.timeout(12_000), redirect: "follow" });
+    if (!res.ok) return {};
+    const html = (await res.text()).slice(0, 300_000);
+    const meta = (name) => new RegExp(`<meta[^>]+(?:name|property)=["']${name}["'][^>]+content=["']([^"']*)["']|<meta[^>]+content=["']([^"']*)["'][^>]+(?:name|property)=["']${name}["']`, "i").exec(html);
+    const pick = (m) => (m ? decode(m[1] ?? m[2] ?? "") : undefined);
+    const themeColor = pick(meta("theme-color"));
+    return {
+      siteTitle: decode(/<title[^>]*>([^<]*)<\/title>/i.exec(html)?.[1] ?? ""),
+      siteDescription: pick(meta("description")) ?? pick(meta("og:description")),
+      siteName: pick(meta("og:site_name")),
+      themeColor,
+      themeFromSite: themeColor ? themeOf([themeColor]) : undefined,
+    };
+  } catch {
+    return {};
+  }
+}
+
+export async function buildIndex({ concurrency = 6, log = console.log } = {}) {
+  const records = readCatalogs().filter((r) => r.site);
+  const out = [];
+  const queue = [...records];
+  let done = 0;
+  await Promise.all(
+    Array.from({ length: concurrency }, async () => {
+      while (queue.length) {
+        const r = queue.shift();
+        const facts = await siteFacts(r.site);
+        out.push({ ...r, ...facts, theme: r.theme ?? facts.themeFromSite });
+        if (++done % 50 === 0) log(`  ${done}/${records.length} sites`);
+      }
+    }),
+  );
+  out.sort((a, b) => a.id.localeCompare(b.id));
+  fs.mkdirSync(INDEX_DIR, { recursive: true });
+  const file = path.join(INDEX_DIR, "discovery.json");
+  fs.writeFileSync(
+    file,
+    JSON.stringify({ builtAt: new Date().toISOString(), note: "Facts and links only. Designs belong to their creators; discovery credit to the listed sources.", records: out }),
+  );
+  return { file, count: out.length };
+}
+
+export function readIndex() {
+  if (!fs.existsSync(INDEX_DIR)) return [];
+  return fs
+    .readdirSync(INDEX_DIR)
+    .filter((f) => f.endsWith(".json"))
+    .flatMap((f) => JSON.parse(fs.readFileSync(path.join(INDEX_DIR, f), "utf8")).records ?? []);
+}

package/src/catalog/literal.mjs

@@ -0,0 +1,146 @@
+// Parses the JavaScript-literal data that some sites embed in their HTML (seroval-style "$R[n]=" payloads).
+// It reads the text; it never evaluates it, so a page can't run code on the user's machine.
+
+export function parseLiteralAt(src, start) {
+  const refs = new Map();
+  let i = start;
+
+  const ws = () => {
+    while (i < src.length && /\s/.test(src[i])) i++;
+  };
+  const fail = (msg) => {
+    throw new Error(`${msg} at ${i}: ${src.slice(i, i + 40)}`);
+  };
+
+  function string() {
+    const quote = src[i++];
+    let out = "";
+    while (i < src.length && src[i] !== quote) {
+      if (src[i] === "\\") {
+        const c = src[i + 1];
+        if (c === "u") {
+          out += String.fromCharCode(parseInt(src.slice(i + 2, i + 6), 16));
+          i += 6;
+          continue;
+        }
+        if (c === "x") {
+          out += String.fromCharCode(parseInt(src.slice(i + 2, i + 4), 16));
+          i += 4;
+          continue;
+        }
+        out += { n: "\n", t: "\t", r: "\r", b: "\b", f: "\f", v: "\v", 0: "\0" }[c] ?? c;
+        i += 2;
+        continue;
+      }
+      out += src[i++];
+    }
+    i++;
+    return out;
+  }
+
+  function key() {
+    ws();
+    if (src[i] === '"' || src[i] === "'") return string();
+    const m = /^[A-Za-z_$][\w$]*/.exec(src.slice(i, i + 200));
+    if (!m) fail("expected key");
+    i += m[0].length;
+    return m[0];
+  }
+
+  function value() {
+    ws();
+    // "$R[12]=value" defines a reference; "$R[12]" alone points back to one.
+    const ref = /^\$R\[(\d+)\]/.exec(src.slice(i, i + 20));
+    if (ref) {
+      i += ref[0].length;
+      ws();
+      if (src[i] === "=") {
+        i++;
+        const v = value();
+        refs.set(ref[1], v);
+        return v;
+      }
+      return refs.get(ref[1]) ?? null;
+    }
+    const c = src[i];
+    if (c === "{") {
+      i++;
+      const obj = {};
+      ws();
+      if (src[i] === "}") {
+        i++;
+        return obj;
+      }
+      for (;;) {
+        const k = key();
+        ws();
+        if (src[i] !== ":") fail("expected :");
+        i++;
+        obj[k] = value();
+        ws();
+        if (src[i] === ",") {
+          i++;
+          continue;
+        }
+        if (src[i] === "}") {
+          i++;
+          return obj;
+        }
+        fail("expected , or }");
+      }
+    }
+    if (c === "[") {
+      i++;
+      const arr = [];
+      ws();
+      if (src[i] === "]") {
+        i++;
+        return arr;
+      }
+      for (;;) {
+        arr.push(value());
+        ws();
+        if (src[i] === ",") {
+          i++;
+          continue;
+        }
+        if (src[i] === "]") {
+          i++;
+          return arr;
+        }
+        fail("expected , or ]");
+      }
+    }
+    if (c === '"' || c === "'") return string();
+    if (src.startsWith("!0", i)) return (i += 2), true;
+    if (src.startsWith("!1", i)) return (i += 2), false;
+    if (src.startsWith("true", i)) return (i += 4), true;
+    if (src.startsWith("false", i)) return (i += 5), false;
+    if (src.startsWith("null", i)) return (i += 4), null;
+    if (src.startsWith("void 0", i)) return (i += 6), null;
+    if (src.startsWith("new Date(", i)) {
+      i += 9;
+      ws();
+      const d = value();
+      ws();
+      i++; // )
+      return d;
+    }
+    const num = /^-?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?/i.exec(src.slice(i, i + 40));
+    if (num) {
+      i += num[0].length;
+      return Number(num[0]);
+    }
+    fail("unexpected token");
+  }
+
+  const v = value();
+  return { value: v, end: i };
+}
+
+// Finds `marker` (for example "initialData:") and parses the value right after it.
+export function extractAfter(src, marker) {
+  const at = src.indexOf(marker);
+  if (at < 0) return undefined;
+  return parseLiteralAt(src, at + marker.length).value;
+}

package/src/catalog/store.mjs

@@ -0,0 +1,40 @@
+// Where catalogues and cached images live: on the user's machine, never in the package.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export const PALATE_HOME = process.env.PALATE_HOME ?? path.join(os.homedir(), ".palate");
+export const CATALOG_DIR = path.join(PALATE_HOME, "catalog");
+export const CACHE_DIR = path.join(PALATE_HOME, "cache");
+export const NOTES_FILE = path.join(PALATE_HOME, "notes.json");
+
+export function readCatalogs() {
+  if (!fs.existsSync(CATALOG_DIR)) return [];
+  return fs
+    .readdirSync(CATALOG_DIR)
+    .filter((f) => f.endsWith(".json"))
+    .flatMap((f) => JSON.parse(fs.readFileSync(path.join(CATALOG_DIR, f), "utf8")).records ?? []);
+}
+
+export function writeCatalog(source, records, meta = {}) {
+  fs.mkdirSync(CATALOG_DIR, { recursive: true });
+  const file = path.join(CATALOG_DIR, `${source}.json`);
+  fs.writeFileSync(file, JSON.stringify({ source, syncedAt: new Date().toISOString(), ...meta, records }, null, 0));
+  return file;
+}
+
+export function readNotes() {
+  try {
+    return JSON.parse(fs.readFileSync(NOTES_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+export function addNote(id, text) {
+  const notes = readNotes();
+  (notes[id] ??= []).push({ text, at: new Date().toISOString() });
+  fs.mkdirSync(PALATE_HOME, { recursive: true });
+  fs.writeFileSync(NOTES_FILE, JSON.stringify(notes, null, 2));
+  return notes[id].length;
+}

package/src/catalog/vibrant.mjs

@@ -0,0 +1,126 @@
+// Builds a local catalogue from vibrant.design's public pages. Polite by design: follows robots.txt
+// (only /sections, /website, /feed, sitemaps), one request at a time with a pause, identified user agent,
+// raw pages cached so re-syncs don't refetch. Stores records and links only; images stay on vibrant's CDN.
+import fs from "node:fs";
+import path from "node:path";
+import { CACHE_DIR, writeCatalog } from "./store.mjs";
+import { extractAfter } from "./literal.mjs";
+import { fontClass } from "./classify.mjs";
+
+const BASE = "https://vibrant.design";
+const UA = "palate-catalog/0.1 (design reference index; https://github.com/Garvit1000)";
+const SHELVES = ["hero", "features", "bento", "pricing", "cta", "logo-cloud", "testimonials", "faq", "footer", "how-it-works", "integrations", "stats", "blogs", "changelog", "careers", "docs", "login-and-signup", "404"];
+const PAGE_CACHE = path.join(CACHE_DIR, "pages", "vibrant");
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function get(url, { delayMs, refresh }) {
+  const file = path.join(PAGE_CACHE, url.replace(BASE, "").replace(/[^a-z0-9-]+/gi, "_") + ".html");
+  if (!refresh && fs.existsSync(file)) return fs.readFileSync(file, "utf8");
+  await sleep(delayMs);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const res = await fetch(url, { headers: { "user-agent": UA, accept: "text/html,application/xml" } });
+      if (res.status === 404) return undefined;
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const text = await res.text();
+      fs.mkdirSync(PAGE_CACHE, { recursive: true });
+      fs.writeFileSync(file, text);
+      return text;
+    } catch (err) {
+      if (attempt === 1) throw err;
+      await sleep(delayMs * 3);
+    }
+  }
+}
+
+// When a record has no colours, its tags and description usually say ("dark-themed", "off-white background").
+function themeFromWords(text) {
+  const t = text.toLowerCase();
+  const dark = (t.match(/\b(dark|black|night|midnight|charcoal)\b/g) ?? []).length;
+  const light = (t.match(/\b(light|white|off-white|cream|beige|pastel|bright)\b/g) ?? []).length;
+  if (dark > light) return "dark";
+  if (light > dark) return "light";
+  return undefined;
+}
+
+const hostOf = (u) => {
+  try {
+    return new URL(u).hostname;
+  } catch {
+    return "";
+  }
+};
+
+const links = (html, kind) => [...new Set([...(html ?? "").matchAll(new RegExp(`href="/(${kind})/([^"?#]+)"`, "g"))].map((m) => `${m[1]}/${m[2]}`))];
+
+// Discovery only: which original site, which shelf, which tags. No descriptions, images or colours from
+// vibrant; palate builds its own record of the design by capturing the original site when it's picked.
+function toRecord(d, shelfHint) {
+  const tags = (d.tags ?? []).map((t) => ({ context: t.context ?? "other", slug: t.slug }));
+  const byContext = (ctx) => tags.filter((t) => t.context === ctx).map((t) => t.slug);
+  const meta = Object.fromEntries((d.metadata ?? []).map((m) => [m.key, m.value]));
+  const categories = (d.categories ?? []).map((c) => c.slug);
+  const shelf =
+    categories.find((c) => SHELVES.includes(c)) ??
+    (shelfHint && SHELVES.includes(shelfHint) ? shelfHint : undefined) ??
+    (d.format === "website" ? "website" : d.format === "section" ? "section" : d.format ?? "other");
+  const fonts = d.fonts ?? [];
+  const host = hostOf(d.source?.url ?? d.websiteUrl).replace(/^www\./, "");
+  const isPost = host === "x.com" || host === "twitter.com";
+  return {
+    id: `vibrant:${d.shortId ?? d.slug}`,
+    source: "vibrant.design",
+    credit: `${BASE}${d.path ?? `/website/${d.slug}`}`,
+    url: `${BASE}${d.path ?? `/website/${d.slug}`}`,
+    site: d.source?.url ?? d.websiteUrl,
+    name: d.name,
+    format: d.format,
+    shelf: isPost ? "micro" : shelf,
+    industry: [...byContext("industry"), ...categories.filter((c) => !SHELVES.includes(c))],
+    style: byContext("style"),
+    colorTags: byContext("color"),
+    interaction: byContext("interaction"),
+    audience: [meta.audience ?? []].flat(),
+    keywords: [meta.keywords ?? []].flat(),
+    fonts,
+    typeClasses: [...new Set(fonts.map(fontClass).filter(Boolean))],
+    theme: themeFromWords([...byContext("color"), ...byContext("style")].join(" ")),
+    // Posts on X are interaction ideas behind a login wall: their own shelf, never captured.
+    capture: !isPost,
+    publishedAt: d.publishedAt,
+  };
+}
+
+export async function syncVibrant({ limit = Infinity, delayMs = 1000, refresh = false, log = console.log } = {}) {
+  const queue = new Map(); // path -> shelf hint
+  for (const shelf of SHELVES) {
+    const html = await get(`${BASE}/sections/${shelf}`, { delayMs, refresh: true });
+    for (const p of links(html, "website")) if (!queue.has(p)) queue.set(p, shelf);
+  }
+  for (const listing of ["websites", "feed"]) {
+    const html = await get(`${BASE}/${listing}`, { delayMs, refresh: true });
+    for (const p of links(html, "website|feed")) if (!queue.has(p)) queue.set(p, undefined);
+  }
+  const sitemap = await get(`${BASE}/sitemaps/projects-1.xml`, { delayMs, refresh: true });
+  for (const m of (sitemap ?? "").matchAll(/<loc>https:\/\/vibrant\.design\/((?:website|feed)\/[^<]+)<\/loc>/g)) if (!queue.has(m[1])) queue.set(m[1], undefined);
+
+  log(`vibrant.design: ${queue.size} entries found`);
+  const records = [];
+  let n = 0;
+  for (const [p, shelfHint] of queue) {
+    if (n >= limit) break;
+    n++;
+    try {
+      const html = await get(`${BASE}/${p}`, { delayMs, refresh });
+      const data = html && extractAfter(html, "initialData:");
+      if (!data?.name) continue;
+      records.push(toRecord(data, shelfHint));
+      if (n % 25 === 0) log(`  ${n}/${Math.min(queue.size, limit)} entries`);
+    } catch (err) {
+      log(`  skip ${p}: ${String(err.message ?? err).slice(0, 120)}`);
+    }
+  }
+  const file = writeCatalog("vibrant", records, { credit: "vibrant.design (work belongs to the original creators)" });
+  return { file, count: records.length };
+}