getfilepress 0.0.0 → 0.1.0

package/packages/import/src/images.ts

@@ -0,0 +1,247 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseHTML } from 'linkedom';
+import { fetchBuffer, fetchText, resolveUrl } from './fetch.ts';
+import type { DesignBrief, ImageCandidate, SiteIR } from './ir.ts';
+
+function isFaviconish(url: string, alt = ''): boolean {
+	return /favicon|apple-touch|android-chrome|icon-\d|\/icon\./i.test(`${url} ${alt}`);
+}
+
+function isPortraitish(url: string, context = ''): boolean {
+	const s = `${url} ${context}`.toLowerCase();
+	return /portrait|headshot|avatar|profile|photo-of|author|face|example-portrait|head-shot/.test(
+		s
+	);
+}
+
+function isAtmosphereish(url: string, context = ''): boolean {
+	const s = `${url} ${context}`.toLowerCase();
+	return /board-?room|office|conference|texture|atmosphere|background|bg-|landscape|hero-bg|banner-bg|pipeline|dossier|contender/.test(
+		s
+	);
+}
+
+function isWordmarkish(url: string, context = ''): boolean {
+	const s = `${url} ${context}`.toLowerCase();
+	if (isFaviconish(url, context)) return false;
+	return /logo|wordmark|brand/.test(s) && !/favicon|icon/.test(s);
+}
+
+function classifyImage(url: string, context: string): ImageCandidate['role'] {
+	const u = url.toLowerCase();
+	const ctx = context.toLowerCase();
+	if (isPortraitish(u, ctx)) return 'portrait';
+	if (isWordmarkish(u, ctx)) return 'logo';
+	if (isFaviconish(u, ctx)) return 'logo'; // filtered later unless nothing else
+	if (isAtmosphereish(u, ctx) || /bg|background|texture|noise|pattern/.test(u + ctx)) {
+		return 'background';
+	}
+	if (/hero|banner|masthead|header/.test(u) || /hero|banner|masthead/.test(ctx)) {
+		return /header|nav|masthead/.test(ctx) ? 'header' : 'hero';
+	}
+	// og:image is often a portrait or card — never assume it's a CSS hero strip
+	if (/og:image|twitter:image|opengraph/.test(ctx)) {
+		return isPortraitish(u, ctx) ? 'portrait' : 'other';
+	}
+	return 'other';
+}
+
+function pushUnique(list: ImageCandidate[], item: ImageCandidate) {
+	if (!item.url || item.url.startsWith('data:')) return;
+	if (list.some((x) => x.url === item.url)) return;
+	list.push(item);
+}
+
+/** Harvest image candidates from a page (meta + CSS urls + large imgs). */
+export async function harvestImagesFromPage(
+	pageUrl: string,
+	label: string
+): Promise<ImageCandidate[]> {
+	const { text: html, url: finalUrl } = await fetchText(pageUrl);
+	const { document } = parseHTML(html);
+	const out: ImageCandidate[] = [];
+
+	for (const sel of [
+		'meta[property="og:image"]',
+		'meta[name="twitter:image"]',
+		'meta[property="og:image:url"]'
+	]) {
+		const content = document.querySelector(sel)?.getAttribute('content');
+		if (!content) continue;
+		const abs = resolveUrl(finalUrl, content);
+		if (!abs) continue;
+		const role = classifyImage(abs, 'og:image');
+		pushUnique(out, { url: abs, role, source: label, alt: 'og:image' });
+	}
+
+	for (const link of document.querySelectorAll('link[rel="apple-touch-icon"], link[rel="icon"]')) {
+		const href = link.getAttribute('href');
+		if (!href) continue;
+		const abs = resolveUrl(finalUrl, href);
+		if (abs && /\.(png|jpe?g|webp|svg)(\?|$)/i.test(abs)) {
+			pushUnique(out, { url: abs, role: 'logo', source: label, alt: 'icon' });
+		}
+	}
+
+	for (const img of document.querySelectorAll('img[src]')) {
+		const src = img.getAttribute('src');
+		if (!src) continue;
+		const abs = resolveUrl(finalUrl, src);
+		if (!abs) continue;
+		const alt = img.getAttribute('alt') || '';
+		const w = Number(img.getAttribute('width') || 0);
+		const cls = img.getAttribute('class') || '';
+		const role = classifyImage(abs, `${alt} ${cls}`);
+		if (role === 'other' && w > 0 && w < 200) continue;
+		// Don't promote unknown small imgs to hero covers
+		pushUnique(out, { url: abs, role, source: label, alt });
+	}
+
+	for (const m of html.matchAll(/background-image:\s*url\((['"]?)([^'")]+)\1\)/gi)) {
+		const abs = resolveUrl(finalUrl, m[2]);
+		if (!abs || abs.startsWith('data:')) continue;
+		pushUnique(out, {
+			url: abs,
+			role: classifyImage(abs, 'background'),
+			source: label,
+			alt: 'css-background'
+		});
+	}
+
+	return out;
+}
+
+export type ImagePlan = {
+	candidates: ImageCandidate[];
+	chosen: NonNullable<DesignBrief['images']>;
+	unsplashQueries: string[];
+	notes: string[];
+};
+
+/**
+ * Pick site-owned assets from the crawl.
+ * CSS covers (hero/header/background) come from Openverse stock via planStockCovers —
+ * never from --inspire marketing photos.
+ */
+export function planImages(
+	ir: SiteIR,
+	harvested: ImageCandidate[],
+	brief: DesignBrief
+): ImagePlan {
+	const sourceHost = (() => {
+		try {
+			return new URL(ir.source.url).hostname.replace(/^www\./, '');
+		} catch {
+			return '';
+		}
+	})();
+
+	const fromSource = (c: ImageCandidate) => {
+		try {
+			return new URL(c.url).hostname.replace(/^www\./, '') === sourceHost;
+		} catch {
+			return c.source.includes(sourceHost);
+		}
+	};
+
+	const byRole = (role: ImageCandidate['role']) => harvested.filter((c) => c.role === role);
+
+	const pick = (
+		roles: ImageCandidate['role'][],
+		opts?: { skipFavicon?: boolean; sourceOnly?: boolean }
+	) => {
+		for (const r of roles) {
+			for (const hit of byRole(r)) {
+				if (opts?.skipFavicon && isFaviconish(hit.url, hit.alt)) continue;
+				if (opts?.sourceOnly && !fromSource(hit)) continue;
+				return hit.url;
+			}
+		}
+		return null;
+	};
+
+	const portrait = pick(['portrait'], { skipFavicon: true });
+	const logo = pick(['logo'], { sourceOnly: true, skipFavicon: true });
+
+	// Covers filled later by Openverse when --fetch-images is set
+	const chosen = {
+		hero: null,
+		header: null,
+		background: null,
+		logo,
+		portrait
+	};
+
+	const mood = brief.mood || 'editorial';
+	const mode = brief.paletteMode || 'dark';
+	const unsplashQueries = [
+		`${mode} abstract ${mood.split(/[—,:]/)[0]?.trim() || 'editorial'} texture`,
+		`minimal geometric background ${mode === 'dark' ? 'dark gold' : 'warm paper'}`,
+		`soft atmospheric gradient ${mode}`,
+		`${ir.identity.author || ir.identity.title} portrait professional (photo slot, not CSS cover)`
+	];
+
+	const notes = [
+		`Source/inspire image candidates (logos & portraits only used from source): ${harvested.length}`,
+		...harvested.slice(0, 10).map((c) => `- [${c.role}] ${c.url} (${c.source})`),
+		harvested.length > 10 ? `- …and ${harvested.length - 10} more` : '',
+		'',
+		'CSS covers use Openverse Creative Commons stock (not inspiration-site photos).',
+		chosen.portrait
+			? `Portrait candidate (not a cover): ${chosen.portrait}`
+			: 'No portrait candidate found.',
+		!chosen.logo
+			? 'No source wordmark logo — keeping text site title.'
+			: `Logo: ${chosen.logo}`,
+		'',
+		'Manual stock search ideas:',
+		...unsplashQueries.map((q) => `- ${q}`),
+		'',
+		'Re-run with --fetch-images to download Openverse covers + source portrait/logo.'
+	].filter(Boolean);
+
+	return { candidates: harvested, chosen, unsplashQueries, notes };
+}
+
+function extOf(url: string, buf: Uint8Array): string {
+	const path = new URL(url).pathname.toLowerCase();
+	if (path.endsWith('.png')) return '.png';
+	if (path.endsWith('.webp')) return '.webp';
+	if (path.endsWith('.svg')) return '.svg';
+	if (path.endsWith('.jpg') || path.endsWith('.jpeg')) return '.jpg';
+	if (buf[0] === 0x89 && buf[1] === 0x50) return '.png';
+	if (buf[0] === 0xff && buf[1] === 0xd8) return '.jpg';
+	return '.jpg';
+}
+
+/**
+ * Download chosen remote images into static/images/{role}.*
+ * Returns local public paths for the brief.
+ */
+export async function fetchChosenImages(
+	chosen: NonNullable<DesignBrief['images']>,
+	staticDir: string
+): Promise<NonNullable<DesignBrief['images']>> {
+	const imgDir = join(staticDir, 'images');
+	mkdirSync(imgDir, { recursive: true });
+	const local: NonNullable<DesignBrief['images']> = {};
+
+	for (const role of ['hero', 'header', 'background', 'logo', 'portrait'] as const) {
+		const url = chosen[role];
+		if (!url) continue;
+		try {
+			const buf = await fetchBuffer(url);
+			const ext = extOf(url, buf);
+			const name = `${role}${ext}`;
+			writeFileSync(join(imgDir, name), buf);
+			local[role] = `/images/${name}`;
+			console.log(`import: saved ${role} → static/images/${name}`);
+		} catch (e) {
+			console.warn(
+				`import: could not fetch ${role} image ${url}: ${e instanceof Error ? e.message : e}`
+			);
+		}
+	}
+	return local;
+}

package/packages/import/src/inspire.ts

@@ -0,0 +1,417 @@
+import { fetchText, resolveUrl } from './fetch.ts';
+import type { DesignBrief } from './ir.ts';
+
+export type InspirationSignals = {
+	url: string;
+	/** Raw Google Fonts stylesheet hrefs. */
+	googleFontHrefs: string[];
+	fontSerif: string | null;
+	fontSans: string | null;
+	fontMono: string | null;
+	tokens: Partial<DesignBrief['tokens']> & {
+		surface?: string;
+		rule?: string;
+		ruleStrong?: string;
+		accentWash?: string;
+	};
+	paletteMode: 'dark' | 'light';
+	hasNoise: boolean;
+	notes: string[];
+};
+
+function luminance(hex: string): number {
+	const h = hex.replace('#', '');
+	const full = h.length === 3 ? h.split('').map((c) => c + c).join('') : h;
+	if (full.length !== 6) return 0.5;
+	const n = parseInt(full, 16);
+	const r = ((n >> 16) & 255) / 255;
+	const g = ((n >> 8) & 255) / 255;
+	const b = (n & 255) / 255;
+	return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+function collectCssVars(css: string): Map<string, string> {
+	const vars = new Map<string, string>();
+	for (const block of css.matchAll(/:root\s*\{([^}]+)\}/g)) {
+		for (const hit of block[1].matchAll(/--([a-zA-Z0-9-_]+)\s*:\s*([^;}]+)/g)) {
+			vars.set(hit[1], hit[2].trim());
+		}
+	}
+	return vars;
+}
+
+function resolveVar(vars: Map<string, string>, name: string, depth = 0): string | undefined {
+	if (depth > 6) return undefined;
+	const raw = vars.get(name);
+	if (!raw) return undefined;
+	const ref = raw.match(/^var\(\s*--([a-zA-Z0-9-_]+)\s*\)$/);
+	if (ref) return resolveVar(vars, ref[1], depth + 1);
+	return raw;
+}
+
+function firstHex(vars: Map<string, string>, ...names: string[]): string | undefined {
+	for (const n of names) {
+		const v = resolveVar(vars, n);
+		if (!v) continue;
+		const hex = v.match(/#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})\b/);
+		if (hex) return hex[0];
+	}
+	return undefined;
+}
+
+function parseGoogleFonts(href: string): { serif?: string; sans?: string; mono?: string } {
+	try {
+		const u = new URL(href);
+		const family = u.searchParams.get('family') || '';
+		const names = family.split('|').map((p) => decodeURIComponent(p.split(':')[0].replace(/\+/g, ' ')));
+		const out: { serif?: string; sans?: string; mono?: string } = {};
+		for (const name of names) {
+			const lower = name.toLowerCase();
+			if (!out.serif && /serif|fraunces|newsreader|instrument|display|playfair|libre/.test(lower)) {
+				out.serif = name;
+			} else if (!out.mono && /mono|jetbrains|fira code|source code/.test(lower)) {
+				out.mono = name;
+			} else if (!out.sans && /sans|inter|dm sans|sen|geist|helvetica|work sans/.test(lower)) {
+				out.sans = name;
+			} else if (!out.sans) {
+				out.sans = name;
+			} else if (!out.serif) {
+				out.serif = name;
+			}
+		}
+		return out;
+	} catch {
+		return {};
+	}
+}
+
+async function fetchLinkedStylesheets(html: string, pageUrl: string, limit = 4): Promise<string> {
+	const hrefs = [...html.matchAll(/<link[^>]+rel=["']stylesheet["'][^>]*>/gi)]
+		.map((m) => {
+			const href = m[0].match(/href=["']([^"']+)["']/i)?.[1];
+			return href ? resolveUrl(pageUrl, href) : null;
+		})
+		.filter((u): u is string => Boolean(u))
+		.slice(0, limit);
+
+	const chunks: string[] = [];
+	for (const href of hrefs) {
+		try {
+			const { status, text } = await fetchText(href);
+			if (status < 400 && text.length < 800_000) chunks.push(text);
+		} catch {
+			/* skip */
+		}
+	}
+	return chunks.join('\n');
+}
+
+/** Pull fonts + palette + atmosphere cues from an inspiration homepage. */
+export async function extractInspirationSignals(url: string): Promise<InspirationSignals> {
+	const { text: html, url: finalUrl } = await fetchText(url);
+	const notes: string[] = [];
+	const googleFontHrefs = [...html.matchAll(/href=["'](https:\/\/fonts\.googleapis\.com\/css2\?[^"']+)["']/gi)].map(
+		(m) => m[1]
+	);
+
+	let fontSerif: string | null = null;
+	let fontSans: string | null = null;
+	let fontMono: string | null = null;
+	for (const href of googleFontHrefs) {
+		const parsed = parseGoogleFonts(href);
+		fontSerif ||= parsed.serif ?? null;
+		fontSans ||= parsed.sans ?? null;
+		fontMono ||= parsed.mono ?? null;
+	}
+
+	const css = `${html}\n${await fetchLinkedStylesheets(html, finalUrl)}`;
+	const vars = collectCssVars(css);
+
+	const bg = firstHex(vars, 'bg', 'background', 'bg-color', 'color-bg');
+	const ink = firstHex(vars, 'text', 'ink', 'text-color', 'color-text', 'foreground');
+	const accent = firstHex(vars, 'accent', 'accent-color', 'color-accent', 'primary');
+	const accentStrong = firstHex(vars, 'accent-dim', 'accent-strong', 'hot', 'color-hot') || accent;
+	const surface = firstHex(vars, 'surface', 'bg-card', 'bg-elevated', 'color-surface');
+	const rule = firstHex(vars, 'border', 'rule', 'color-border');
+	const ruleStrong = firstHex(vars, 'border-glow', 'rule-strong');
+	const inkSoft = firstHex(vars, 'text-muted', 'ink-soft', 'color-muted');
+
+	// CSS var font families when Google parse missed
+	const serifVar = resolveVar(vars, 'serif') || resolveVar(vars, 'font-serif');
+	const sansVar = resolveVar(vars, 'sans') || resolveVar(vars, 'font-sans');
+	const monoVar = resolveVar(vars, 'mono') || resolveVar(vars, 'font-mono');
+	const named = (v?: string) => v?.match(/"([^"]+)"/)?.[1] || null;
+	fontSerif ||= named(serifVar);
+	fontSans ||= named(sansVar);
+	fontMono ||= named(monoVar);
+
+	// When theme tokens are CSS-var indirection (Tailwind @theme), fall back to
+	// frequent warm/dark hexes in the stylesheet.
+	const hexFallback = inferHexPalette(css);
+	const accentResolved = accent || hexFallback.accent;
+	const accentStrongResolved = accentStrong || hexFallback.accentStrong || accentResolved;
+	const bgResolved = bg || hexFallback.bg;
+	const inkResolved = ink || hexFallback.ink;
+
+	const paletteMode: 'dark' | 'light' =
+		bgResolved && luminance(bgResolved) < 0.35
+			? 'dark'
+			: inkResolved && luminance(inkResolved) > 0.6
+				? 'dark'
+				: 'light';
+
+	const hasNoise = /feTurbulence|noiseFilter|fractalNoise|opacity=['"]0\.0[2-5]/.test(css);
+
+	if (accentResolved) notes.push(`Inspiration accent ${accentResolved}`);
+	if (fontSerif || fontSans) notes.push(`Fonts: ${[fontSerif, fontSans, fontMono].filter(Boolean).join(' / ')}`);
+	notes.push(`Palette mode: ${paletteMode}`);
+
+	return {
+		url: finalUrl,
+		googleFontHrefs,
+		fontSerif,
+		fontSans,
+		fontMono,
+		tokens: {
+			accent: accentResolved || undefined,
+			accentStrong: accentStrongResolved || undefined,
+			bg: bgResolved || undefined,
+			ink: inkResolved || undefined,
+			inkSoft: inkSoft || undefined,
+			surface: surface || hexFallback.surface || undefined,
+			rule: rule || undefined,
+			ruleStrong: ruleStrong || undefined,
+			accentWash: undefined
+		},
+		paletteMode,
+		hasNoise,
+		notes
+	};
+}
+
+function isWarmAccent(hex: string): boolean {
+	const n = parseInt(hex.slice(1), 16);
+	const r = (n >> 16) & 255;
+	const g = (n >> 8) & 255;
+	const b = n & 255;
+	return r > 160 && g > 80 && g < 220 && b < 120 && r >= g;
+}
+
+/** Near-neutral text colors only — never treat gold/amber accents as ink. */
+function isInkCandidate(hex: string): boolean {
+	if (isWarmAccent(hex)) return false;
+	const n = parseInt(hex.slice(1), 16);
+	const r = (n >> 16) & 255;
+	const g = (n >> 8) & 255;
+	const b = n & 255;
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	return max - min < 40; // low chroma
+}
+
+/** Guess accent/bg/ink from hex frequency when CSS vars don't resolve. */
+export function inferHexPalette(css: string): Partial<DesignBrief['tokens']> {
+	const counts = new Map<string, number>();
+	for (const m of css.matchAll(/#([0-9a-fA-F]{6})\b/g)) {
+		const hex = `#${m[1].toLowerCase()}`;
+		if (/^#(000000|ffffff)$/i.test(hex)) continue;
+		counts.set(hex, (counts.get(hex) ?? 0) + 1);
+	}
+	const ranked = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+	const warm = ranked.find(([h]) => isWarmAccent(h))?.[0];
+	const darkBg = ranked.find(([h]) => luminance(h) < 0.2 && !isWarmAccent(h))?.[0];
+	const lightInk = ranked.find(([h]) => luminance(h) > 0.75 && isInkCandidate(h))?.[0];
+	const darkInk = ranked.find(
+		([h]) => luminance(h) < 0.28 && h !== darkBg && isInkCandidate(h)
+	)?.[0];
+	const out: Partial<DesignBrief['tokens']> = {};
+	if (warm) {
+		out.accent = warm;
+		out.accentStrong = warm;
+	}
+	if (darkBg) out.bg = darkBg;
+	if (darkBg && lightInk) out.ink = lightInk;
+	else if (darkInk) out.ink = darkInk;
+	return out;
+}
+
+function pickFont(
+	signals: InspirationSignals[],
+	key: 'fontSerif' | 'fontSans' | 'fontMono',
+	fallback: string
+): string {
+	// First inspiration URL wins font roles; later URLs mainly retint accent.
+	for (const s of signals) {
+		const v = s[key];
+		if (v) return v;
+	}
+	return fallback;
+}
+
+function mergeGoogleHref(signals: InspirationSignals[]): string | null {
+	const families = new Set<string>();
+	for (const s of signals) {
+		for (const href of s.googleFontHrefs) {
+			try {
+				const u = new URL(href.replace(/&amp;/g, '&'));
+				const family = u.searchParams.get('family') || '';
+				for (const part of family.split('|')) {
+					const name = part.split(':')[0];
+					if (name) families.add(name);
+				}
+			} catch {
+				/* skip */
+			}
+		}
+	}
+	// Keep the mix small — display + UI + mono/serif for essays
+	const preferred = [
+		'Instrument+Serif',
+		'Syne',
+		'Fraunces',
+		'Source+Serif+4',
+		'DM+Sans',
+		'Outfit',
+		'Manrope',
+		'JetBrains+Mono'
+	];
+	const chosen: string[] = [];
+	for (const p of preferred) {
+		const hit = [...families].find((f) => f.replace(/ /g, '+') === p || f === p.replace(/\+/g, ' '));
+		if (hit) chosen.push(hit.includes(':') ? hit : `${hit.replace(/ /g, '+')}:wght@400;500;600;700`);
+		if (chosen.length >= 4) break;
+	}
+	if (!chosen.length && signals[0]?.googleFontHrefs[0]) {
+		return signals[0].googleFontHrefs[0].replace(/&amp;/g, '&');
+	}
+	if (!chosen.length) return null;
+	return `https://fonts.googleapis.com/css2?${chosen.map((f) => `family=${f}`).join('&')}&display=swap`;
+}
+
+/**
+ * Merge up to 3 inspiration signals into one brief.
+ * First URL = structure/mood bias; later URLs contribute accent/fonts/atmosphere.
+ */
+export function briefFromInspiration(signals: InspirationSignals[]): DesignBrief {
+	const list = signals.slice(0, 3);
+	if (!list.length) {
+		return {
+			mood: 'Modern editorial personal site',
+			do: ['Strong display type', 'Clear accent', 'Atmospheric background'],
+			dont: ['Flat purple gradients', 'Marketing stat strips'],
+			tokens: {
+				accent: '#f0c040',
+				accentStrong: '#b8922e',
+				bg: '#0a0a0c',
+				ink: '#e8e6e3',
+				inkSoft: '#9a9898',
+				surface: '#16161a',
+				rule: '#2a2a33'
+			},
+			density: 'balanced',
+			paletteMode: 'dark',
+			fonts: {
+				serif: 'Instrument Serif',
+				sans: 'DM Sans',
+				mono: 'JetBrains Mono',
+				googleHref:
+					'https://fonts.googleapis.com/css2?family=Instrument+Serif:ital@0;1&family=DM+Sans:ital,opsz,wght@0,9..40,300..700;1,9..40,300..700&family=JetBrains+Mono:wght@400;500&display=swap'
+			},
+			hero: 'bold',
+			atmosphere: 'noise',
+			navStyle: 'uppercase-tracked',
+			elevatedCards: true,
+			cssNotes: ['Fallback forge-inspired dark theme']
+		};
+	}
+
+	const primary = list[0];
+	const secondary = list[1];
+	const tertiary = list[2];
+
+	// Dark wins if any inspiration is dark (personal sites look sharper that way
+	// when mixing a marketing dark site with a product light site).
+	const darkCount = list.filter((s) => s.paletteMode === 'dark').length;
+	const paletteMode: 'dark' | 'light' = darkCount > 0 ? 'dark' : 'light';
+
+	// Accent: prefer a later site's accent when it differs (keeps the blend visible).
+	const accents = list.map((s) => s.tokens.accent).filter(Boolean) as string[];
+	const accent =
+		(secondary?.tokens.accent && secondary.tokens.accent !== primary.tokens.accent
+			? secondary.tokens.accent
+			: null) ||
+		accents[0] ||
+		(paletteMode === 'dark' ? '#f0c040' : '#1e4d6b');
+	const accentStrong =
+		secondary?.tokens.accentStrong ||
+		primary.tokens.accentStrong ||
+		tertiary?.tokens.accentStrong ||
+		accent;
+
+	const bg =
+		list.find((s) => s.paletteMode === paletteMode)?.tokens.bg ||
+		primary.tokens.bg ||
+		(paletteMode === 'dark' ? '#0a0a0c' : '#f7f5f1');
+	const ink =
+		list.find((s) => s.paletteMode === paletteMode)?.tokens.ink ||
+		primary.tokens.ink ||
+		(paletteMode === 'dark' ? '#e8e6e3' : '#1a1917');
+	const surface =
+		list.find((s) => s.tokens.surface)?.tokens.surface ||
+		(paletteMode === 'dark' ? '#16161a' : '#ffffff');
+	const rule =
+		list.find((s) => s.tokens.rule)?.tokens.rule ||
+		(paletteMode === 'dark' ? '#2a2a33' : '#e7e2d8');
+	const inkSoft =
+		list.find((s) => s.tokens.inkSoft)?.tokens.inkSoft ||
+		(paletteMode === 'dark' ? '#9a9898' : '#4d4a44');
+
+	const hasNoise = list.some((s) => s.hasNoise);
+	const sources = list.map((s) => s.url).join(' · ');
+
+	return {
+		mood:
+			list.length > 1
+				? `Blend of ${list.length} inspiration sites — ${paletteMode} editorial with a product-grade accent`
+				: paletteMode === 'dark'
+					? 'Dark modern forge — sharp type, gold accent, atmospheric depth'
+					: 'Bright modern editorial with confident display type',
+		do: [
+			'Blend fonts and accent across inspiration URLs',
+			'Punchy display titles with tight tracking',
+			'Uppercase tracked nav',
+			hasNoise || paletteMode === 'dark' ? 'Subtle noise atmosphere' : 'Clean surfaces'
+		],
+		dont: [
+			'Do not clone multi-section marketing grids onto the essay index',
+			'Do not keep the quiet parchment Essay look when inspiration is dark/modern'
+		],
+		tokens: {
+			accent,
+			accentStrong,
+			bg,
+			ink,
+			inkSoft,
+			surface,
+			rule,
+			ruleStrong:
+				list.find((s) => s.tokens.ruleStrong)?.tokens.ruleStrong ||
+				(paletteMode === 'dark' ? '#3d3d4a' : '#d6cfc1'),
+			accentWash:
+				paletteMode === 'dark' ? 'color-mix(in srgb, var(--accent) 14%, transparent)' : undefined
+		},
+		density: 'balanced',
+		paletteMode,
+		fonts: {
+			serif: pickFont(list, 'fontSerif', 'Instrument Serif'),
+			sans: pickFont(list, 'fontSans', 'DM Sans'),
+			mono: pickFont(list, 'fontMono', 'JetBrains Mono'),
+			googleHref: mergeGoogleHref(list)
+		},
+		hero: 'bold',
+		atmosphere: hasNoise || paletteMode === 'dark' ? 'noise' : 'none',
+		navStyle: 'uppercase-tracked',
+		elevatedCards: paletteMode === 'dark',
+		cssNotes: [`Blended from: ${sources}`, ...list.flatMap((s) => s.notes)]
+	};
+}