shipseal 0.0.1 → 0.0.2

package/dist/cli.js

@@ -1,13 +1,4939 @@
 #!/usr/bin/env node
-//#region src/cli.ts
-process.stdout.write([
-	"shipseal is pre-alpha and not usable yet.",
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, relative } from "node:path";
+import { cac } from "cac";
+import { appendFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+import { Renderer } from "takumi-js/node";
+import { container, text } from "takumi-js/helpers";
+import { fromJsx } from "takumi-js/helpers/jsx";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { inflateSync } from "node:zlib";
+
+//#region src/core/errors.ts
+var ShipsealError = class extends Error {
+	code;
+	fix;
+	constructor(code, message, fix, options) {
+		super(message, options);
+		this.name = "ShipsealError";
+		this.code = code;
+		this.fix = fix;
+	}
+};
+function formatError(error) {
+	return `${error.message}\nFix: ${error.fix}`;
+}
+
+//#endregion
+//#region src/brand/schema.ts
+const hexColorSchema = z.string().regex(/^#([\da-f]{6})$/i, "Expected a 6-digit hex color like #0b0b0c");
+const fontFaceSchema = z.object({
+	family: z.string().min(1),
+	weight: z.number().int().min(100).max(900),
+	file: z.string().min(1).optional()
+});
+const brandSchema = z.object({
+	$schema: z.string().optional(),
+	version: z.literal(1),
+	name: z.string().min(1),
+	tagline: z.string().optional(),
+	url: z.string().optional(),
+	logo: z.object({
+		light: z.string().min(1),
+		dark: z.string().min(1).optional()
+	}).optional(),
+	colors: z.object({
+		background: hexColorSchema,
+		foreground: hexColorSchema,
+		muted: hexColorSchema.optional(),
+		primary: hexColorSchema.optional(),
+		accent: hexColorSchema.optional()
+	}),
+	fonts: z.object({
+		heading: fontFaceSchema,
+		body: fontFaceSchema,
+		mono: fontFaceSchema
+	}),
+	radius: z.number().nonnegative(),
+	theme: z.enum(["dark", "light"]),
+	style: z.literal("minimal"),
+	tokens: z.string().nullable()
+});
+const DEFAULT_BRAND_COLORS = {
+	background: "#0b0b0c",
+	foreground: "#fafafa",
+	muted: "#a1a1aa",
+	primary: "#ff4d4d",
+	accent: "#fbbf24"
+};
+const DEFAULT_BRAND_FONTS = {
+	heading: {
+		family: "Geist",
+		weight: 700
+	},
+	body: {
+		family: "Geist",
+		weight: 400
+	},
+	mono: {
+		family: "Geist Mono",
+		weight: 400
+	}
+};
+
+//#endregion
+//#region src/brand/load.ts
+async function loadBrand(cwd) {
+	const path = join(cwd, ".shipseal", "brand.json");
+	try {
+		const raw = JSON.parse(await readFile(path, "utf8"));
+		return brandSchema.parse(raw);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") throw new ShipsealError("brand.missing", "No .shipseal/brand.json found.", "Run shipseal init to detect brand colors and write brand.json.");
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/formats.ts
+const FORMAT_IDS = [
+	"og",
+	"github-social",
+	"x",
+	"linkedin",
+	"square",
+	"portrait",
+	"producthunt",
+	"readme-banner"
+];
+const LANDSCAPE_SAFE_ZONE = 64;
+const FORMATS = {
+	og: {
+		id: "og",
+		width: 1200,
+		height: 630,
+		safeZone: LANDSCAPE_SAFE_ZONE
+	},
+	"github-social": {
+		id: "github-social",
+		width: 1280,
+		height: 640,
+		safeZone: LANDSCAPE_SAFE_ZONE
+	},
+	x: {
+		id: "x",
+		width: 1200,
+		height: 675,
+		safeZone: LANDSCAPE_SAFE_ZONE
+	},
+	linkedin: {
+		id: "linkedin",
+		width: 1200,
+		height: 627,
+		safeZone: LANDSCAPE_SAFE_ZONE
+	},
+	square: {
+		id: "square",
+		width: 1080,
+		height: 1080,
+		safeZone: LANDSCAPE_SAFE_ZONE
+	},
+	portrait: {
+		id: "portrait",
+		width: 1080,
+		height: 1350,
+		safeZone: LANDSCAPE_SAFE_ZONE
+	},
+	producthunt: {
+		id: "producthunt",
+		width: 1270,
+		height: 760,
+		safeZone: LANDSCAPE_SAFE_ZONE
+	},
+	"readme-banner": {
+		id: "readme-banner",
+		width: 1280,
+		height: 400,
+		safeZone: LANDSCAPE_SAFE_ZONE
+	}
+};
+
+//#endregion
+//#region src/config/schema.ts
+const configSchema = z.object({
+	$schema: z.string().optional(),
+	version: z.literal(1),
+	outputDir: z.string().optional(),
+	formats: z.array(z.enum(FORMAT_IDS)).optional(),
+	release: z.object({
+		templates: z.array(z.string()).optional(),
+		maxHighlights: z.number().int().positive().optional(),
+		changelogPath: z.string().optional(),
+		snippet: z.string().nullable().optional()
+	}).optional(),
+	milestones: z.object({
+		stars: z.array(z.number().int().positive()).optional(),
+		downloads: z.array(z.number().int().positive()).optional(),
+		contributors: z.array(z.number().int().positive()).optional()
+	}).optional(),
+	bench: z.object({ file: z.string().optional() }).optional(),
+	copy: z.object({
+		llm: z.boolean().optional(),
+		provider: z.string().nullable().optional(),
+		model: z.string().nullable().optional(),
+		maxRetries: z.number().int().nonnegative().optional()
+	}).optional(),
+	output: z.object({ imageFormat: z.enum([
+		"png",
+		"webp",
+		"jpeg"
+	]).optional() }).optional(),
+	attribution: z.boolean().optional()
+});
+const DEFAULT_CONFIG = {
+	version: 1,
+	outputDir: ".shipseal/output",
+	formats: [
+		"og",
+		"github-social",
+		"x",
+		"linkedin"
+	],
+	release: {
+		templates: [
+			"release-hero",
+			"release-highlights",
+			"code-card"
+		],
+		maxHighlights: 4,
+		changelogPath: "CHANGELOG.md",
+		snippet: null
+	},
+	milestones: {
+		stars: [
+			100,
+			250,
+			500,
+			1e3,
+			2500,
+			5e3,
+			1e4
+		],
+		downloads: [
+			1e3,
+			1e4,
+			1e5,
+			1e6
+		],
+		contributors: [
+			10,
+			25,
+			50,
+			100
+		]
+	},
+	bench: { file: ".shipseal/bench.json" },
+	copy: {
+		llm: false,
+		provider: null,
+		model: null,
+		maxRetries: 2
+	},
+	output: { imageFormat: "png" },
+	attribution: true
+};
+
+//#endregion
+//#region src/config/load.ts
+async function loadConfig(cwd) {
+	const path = join(cwd, ".shipseal", "config.json");
+	try {
+		const raw = JSON.parse(await readFile(path, "utf8"));
+		const parsed = configSchema.parse(raw);
+		return mergeConfig(DEFAULT_CONFIG, parsed);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return DEFAULT_CONFIG;
+		throw error;
+	}
+}
+function mergeConfig(base, overlay) {
+	return {
+		...base,
+		...overlay,
+		release: {
+			...base.release,
+			...overlay.release
+		},
+		milestones: {
+			...base.milestones,
+			...overlay.milestones
+		},
+		bench: {
+			...base.bench,
+			...overlay.bench
+		},
+		copy: {
+			...base.copy,
+			...overlay.copy
+		},
+		output: {
+			...base.output,
+			...overlay.output
+		}
+	};
+}
+
+//#endregion
+//#region src/copy/slots.ts
+const COPY_LIMITS = {
+	headline: 48,
+	subheadline: 90,
+	highlight: 56,
+	cta: 32,
+	milestoneLine: 48
+};
+
+//#endregion
+//#region src/copy/deterministic.ts
+function deterministicCopy(facts, maxHighlights = 4) {
+	const name = facts.project.name.value;
+	const version = facts.release?.version.value;
+	const features = (facts.release?.features ?? []).map((item) => item.value);
+	const fixes = (facts.release?.fixes ?? []).map((item) => item.value);
+	const breaking = (facts.release?.breaking ?? []).map((item) => item.value);
+	const headlineSource = features[0];
+	const headline = headlineSource !== void 0 ? cleanLine(headlineSource) : version === void 0 ? name : `${name} ${version}`;
+	const tagline = facts.project.tagline?.value;
+	const subheadline = tagline !== void 0 && tagline.length > 0 ? cleanLine(tagline) : cleanLine(features[1] ?? fixes[0] ?? `What's new in ${version ?? name}`);
+	const highlights = [];
+	for (const line of features) {
+		if (highlights.length >= maxHighlights) break;
+		highlights.push(cleanLine(line));
+	}
+	for (const line of fixes) {
+		if (highlights.length >= maxHighlights) break;
+		highlights.push(cleanLine(line));
+	}
+	for (const line of breaking) {
+		if (highlights.length >= maxHighlights) break;
+		highlights.push(`Breaking: ${cleanLine(line)}`);
+	}
+	return {
+		headline,
+		subheadline,
+		highlights,
+		cta: ctaFor(facts)
+	};
+}
+function formatCount$1(value) {
+	return value.toLocaleString("en-US");
+}
+function milestoneCopy(facts, metric, threshold) {
+	const formatted = formatCount$1(threshold);
+	const line = metric === "stars" ? `Thank you for ${formatted} stars` : metric === "downloads" ? `${formatted} weekly downloads` : `Thank you, ${formatted} contributors`;
+	const tagline = facts.project.tagline?.value;
+	return {
+		headline: facts.project.name.value,
+		subheadline: tagline !== void 0 && tagline.length > 0 ? cleanLine(tagline) : "",
+		highlights: [],
+		cta: ctaFor(facts),
+		milestoneLine: line
+	};
+}
+function benchCopy(facts) {
+	const title = facts.bench?.title.value ?? facts.project.name.value;
+	const note = facts.bench?.note?.value;
+	return {
+		headline: title,
+		subheadline: note !== void 0 && note.length > 0 ? note : facts.project.tagline?.value ?? "",
+		highlights: [],
+		cta: ctaFor(facts)
+	};
+}
+function cleanLine(text) {
+	const stripped = text.replaceAll("—", ":").replaceAll("–", "-").replaceAll("!", ".").trim();
+	const noTrail = stripped.endsWith(".") ? stripped.slice(0, -1) : stripped;
+	const first = noTrail.at(0);
+	if (first === void 0) return noTrail;
+	return first.toUpperCase() + noTrail.slice(1);
+}
+function ctaFor(facts) {
+	const npm = facts.project.npmPackage?.value;
+	if (npm !== void 0 && npm.length > 0) return `npm i ${npm}`;
+	const url = facts.project.url?.value ?? facts.project.repo?.value;
+	if (url === void 0) return facts.project.name.value;
+	return url.replace(/^https?:\/\//, "");
+}
+
+//#endregion
+//#region src/bench/percent.ts
+function percentChange(before, after, better) {
+	if (before === 0) {
+		if (after === 0) return {
+			signed: 0,
+			absPercent: 0,
+			regression: false
+		};
+		const improved = better === "higher" ? after > 0 : after < 0;
+		return {
+			signed: improved ? 100 : -100,
+			absPercent: 100,
+			regression: !improved
+		};
+	}
+	const raw = better === "lower" ? (before - after) / before : (after - before) / before;
+	const signed = Math.round(raw * 100);
+	return {
+		signed,
+		absPercent: Math.abs(signed),
+		regression: signed < 0
+	};
+}
+function changePhrase(unit, better, change) {
+	if (change.absPercent === 0) return "unchanged";
+	return `${String(change.absPercent)}% ${deltaWord(unit, better, change.regression)}`;
+}
+function deltaWord(unit, better, regression) {
+	if (better === "higher") return regression ? "lower" : "higher";
+	const normalized = unit.toLowerCase();
+	if (normalized === "ms" || normalized === "s" || normalized === "sec" || normalized === "seconds") return regression ? "slower" : "faster";
+	if (normalized === "kb" || normalized === "mb" || normalized === "b" || normalized === "bytes" || normalized === "gzip") return regression ? "larger" : "smaller";
+	return regression ? "worse" : "better";
+}
+
+//#endregion
+//#region src/fit/fit-text.ts
+async function fitText(renderer, text, spec, font) {
+	const sizes = fontSizes(spec);
+	for (const fontSize of sizes) {
+		const measured = await renderer.measureText(text, measureOpts$1(spec, font, fontSize));
+		if (measured.lines <= spec.maxLines) return {
+			fontSize,
+			text,
+			lines: measured.lines,
+			truncated: false
+		};
+	}
+	const fontSize = spec.minFontSize;
+	const truncated = await truncateToFit(renderer, text, spec, font, fontSize);
+	return {
+		fontSize,
+		text: truncated,
+		lines: (await renderer.measureText(truncated, measureOpts$1(spec, font, fontSize))).lines,
+		truncated: truncated !== text
+	};
+}
+function fontSizes(spec) {
+	const sizes = [];
+	for (let size = spec.maxFontSize; size >= spec.minFontSize; size -= spec.step) sizes.push(size);
+	if (sizes[sizes.length - 1] !== spec.minFontSize) sizes.push(spec.minFontSize);
+	return sizes;
+}
+function measureOpts$1(spec, font, fontSize) {
+	const opts = {
+		fontFamily: font.family,
+		fontSize,
+		maxWidth: spec.box.width,
+		lineHeight: font.lineHeight
+	};
+	if (font.weight !== void 0) opts.fontWeight = font.weight;
+	if (font.whiteSpace !== void 0) opts.whiteSpace = font.whiteSpace;
+	return opts;
+}
+async function truncateToFit(renderer, text, spec, font, fontSize) {
+	const words = text.trim().length === 0 ? [] : text.trim().split(/\s+/);
+	if (words.length === 0) return text;
+	const fits = async (candidate) => {
+		return (await renderer.measureText(candidate, measureOpts$1(spec, font, fontSize))).lines <= spec.maxLines;
+	};
+	for (let count = words.length - 1; count >= 1; count -= 1) {
+		const candidate = `${words.slice(0, count).join(" ")}...`;
+		if (await fits(candidate)) return candidate;
+	}
+	const first = words[0];
+	if (first === void 0) return "...";
+	for (let length = first.length; length >= 1; length -= 1) {
+		const candidate = `${first.slice(0, length)}...`;
+		if (await fits(candidate)) return candidate;
+	}
+	return "...";
+}
+
+//#endregion
+//#region src/templates/theme.ts
+function themeColors(brand, theme) {
+	const primary = brand.colors.primary ?? DEFAULT_BRAND_COLORS.primary;
+	const accent = brand.colors.accent ?? DEFAULT_BRAND_COLORS.accent;
+	const muted = brand.colors.muted ?? DEFAULT_BRAND_COLORS.muted;
+	if (theme === "dark") {
+		const background = brand.theme === "dark" ? brand.colors.background : brand.colors.foreground;
+		const foreground = brand.theme === "dark" ? brand.colors.foreground : brand.colors.background;
+		return {
+			background,
+			foreground,
+			muted: brand.theme === "dark" ? muted : DEFAULT_BRAND_COLORS.muted,
+			primary,
+			accent,
+			card: mix(background, foreground, .08)
+		};
+	}
+	const background = brand.theme === "light" ? brand.colors.background : brand.colors.foreground;
+	const foreground = brand.theme === "light" ? brand.colors.foreground : brand.colors.background;
+	return {
+		background,
+		foreground,
+		muted: brand.theme === "light" ? muted : "#52525b",
+		primary,
+		accent,
+		card: mix(background, foreground, .06)
+	};
+}
+function mix(a, b, amount) {
+	const ar = Number.parseInt(a.slice(1, 3), 16);
+	const ag = Number.parseInt(a.slice(3, 5), 16);
+	const ab = Number.parseInt(a.slice(5, 7), 16);
+	const br = Number.parseInt(b.slice(1, 3), 16);
+	const bg = Number.parseInt(b.slice(3, 5), 16);
+	const bb = Number.parseInt(b.slice(5, 7), 16);
+	return `#${toHex(ar + (br - ar) * amount)}${toHex(ag + (bg - ag) * amount)}${toHex(ab + (bb - ab) * amount)}`;
+}
+function toHex(value) {
+	return Math.round(value).toString(16).padStart(2, "0");
+}
+
+//#endregion
+//#region src/takumi-jsx/jsx-runtime.ts
+function jsx(type, props, key) {
+	return {
+		type,
+		props,
+		key: key ?? null
+	};
+}
+const jsxs = jsx;
+
+//#endregion
+//#region src/templates/code-card.tsx
+const propsSchema$4 = z.object({
+	headline: z.string(),
+	headingFamily: z.string(),
+	monoFamily: z.string(),
+	headingWeight: z.number(),
+	monoWeight: z.number(),
+	radius: z.number(),
+	lines: z.array(z.array(z.object({
+		text: z.string(),
+		color: z.string()
+	})))
+});
+const codeCard = {
+	id: "code-card",
+	events: ["release"],
+	formats: ["x", "linkedin"],
+	propsSchema: propsSchema$4,
+	slots(format) {
+		return { headline: {
+			maxLines: 1,
+			maxFontSize: 40,
+			minFontSize: 28,
+			step: 2,
+			box: { width: format.width - 2 * format.safeZone }
+		} };
+	},
+	slotText(raw) {
+		return { headline: propsSchema$4.parse(raw).headline };
+	},
+	slotFont(raw, slot) {
+		const props = propsSchema$4.parse(raw);
+		if (slot === "headline") return {
+			family: props.headingFamily,
+			weight: props.headingWeight,
+			lineHeight: 1.1
+		};
+		return {
+			family: props.monoFamily,
+			weight: props.monoWeight,
+			lineHeight: 1.35,
+			whiteSpace: "pre"
+		};
+	},
+	buildProps(facts, copy, brand) {
+		const missing = [];
+		const lines = copy.codeLines ?? [];
+		if (lines.length === 0) missing.push({
+			fact: "release.codeSnippet",
+			effect: "code card uses empty snippet"
+		});
+		return {
+			props: {
+				headline: copy.headline,
+				headingFamily: brand.fonts.heading.family,
+				monoFamily: brand.fonts.mono.family,
+				headingWeight: brand.fonts.heading.weight,
+				monoWeight: brand.fonts.mono.weight,
+				radius: brand.radius,
+				lines
+			},
+			missing
+		};
+	},
+	render(raw, ctx) {
+		const props = propsSchema$4.parse(raw);
+		const colors = themeColors(ctx.brand, ctx.theme);
+		const pad = ctx.format.safeZone;
+		const headline = ctx.fitted.headline;
+		return /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				width: "100%",
+				height: "100%",
+				backgroundColor: colors.background,
+				padding: pad,
+				gap: 24
+			},
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					style: {
+						fontFamily: props.headingFamily,
+						fontWeight: props.headingWeight,
+						fontSize: headline?.fontSize ?? 36,
+						color: colors.foreground
+					},
+					children: headline?.text ?? props.headline
+				}),
+				/* @__PURE__ */ jsx("div", {
+					style: {
+						display: "flex",
+						flexDirection: "column",
+						flexGrow: 1,
+						backgroundColor: colors.card,
+						borderRadius: props.radius,
+						padding: 28,
+						gap: 0
+					},
+					children: props.lines.map((line, lineIndex) => /* @__PURE__ */ jsx("div", {
+						style: {
+							display: "flex",
+							flexDirection: "row",
+							flexWrap: "nowrap"
+						},
+						children: line.map((token, tokenIndex) => /* @__PURE__ */ jsx("div", {
+							style: {
+								fontFamily: props.monoFamily,
+								fontWeight: props.monoWeight,
+								fontSize: 22,
+								color: token.color,
+								whiteSpace: "pre",
+								lineHeight: 1.35
+							},
+							children: token.text
+						}, `${String(lineIndex)}-${String(tokenIndex)}`))
+					}, String(lineIndex)))
+				}),
+				ctx.attribution ? /* @__PURE__ */ jsx("div", {
+					style: {
+						fontFamily: props.headingFamily,
+						fontWeight: 400,
+						fontSize: 18,
+						color: colors.muted
+					},
+					children: "made with shipseal.dev"
+				}) : void 0
+			]
+		});
+	}
+};
+function emptyCodeLines() {
+	return [[{
+		text: " ",
+		color: "#e6edf3"
+	}]];
+}
+
+//#endregion
+//#region src/templates/highlight.ts
+const MAX_LINES = 14;
+async function highlightCode(code, lang, theme) {
+	const clipped = code.split("\n").slice(0, MAX_LINES).join("\n");
+	const fallbackColor = theme === "dark" ? "#e6edf3" : "#1f2328";
+	try {
+		const { codeToTokens } = await import("shiki");
+		return (await codeToTokens(clipped, {
+			lang: mapLang(lang),
+			theme: theme === "dark" ? "github-dark" : "github-light"
+		})).tokens.map((line) => {
+			if (line.length === 0) return [{
+				text: " ",
+				color: fallbackColor
+			}];
+			return line.map((token) => ({
+				text: token.content,
+				color: token.color ?? fallbackColor
+			}));
+		});
+	} catch {
+		return clipped.split("\n").map((line) => [{
+			text: line.length === 0 ? " " : line,
+			color: fallbackColor
+		}]);
+	}
+}
+function mapLang(lang) {
+	const key = lang.toLowerCase();
+	if (key === "javascript" || key === "js") return "js";
+	if (key === "tsx") return "tsx";
+	if (key === "jsx") return "jsx";
+	if (key === "json") return "json";
+	if (key === "bash" || key === "shell" || key === "sh") return "bash";
+	return "ts";
+}
+
+//#endregion
+//#region src/templates/bench.tsx
+const rowSchema = z.object({
+	label: z.string(),
+	beforeText: z.string(),
+	afterText: z.string(),
+	changeText: z.string(),
+	regression: z.boolean()
+});
+const propsSchema$3 = z.object({
+	title: z.string(),
+	note: z.string(),
+	rows: z.array(rowSchema),
+	headingFamily: z.string(),
+	bodyFamily: z.string(),
+	headingWeight: z.number(),
+	bodyWeight: z.number(),
+	radius: z.number()
+});
+const bench = {
+	id: "bench",
+	events: ["bench"],
+	formats: ["x", "linkedin"],
+	propsSchema: propsSchema$3,
+	slots(format) {
+		const width = format.width - 2 * format.safeZone;
+		const slots = { title: {
+			maxLines: 2,
+			maxFontSize: 48,
+			minFontSize: 28,
+			step: 2,
+			box: { width }
+		} };
+		for (let index = 0; index < 3; index += 1) slots[`change-${String(index)}`] = {
+			maxLines: 1,
+			maxFontSize: 36,
+			minFontSize: 22,
+			step: 2,
+			box: { width: Math.min(360, width) }
+		};
+		return slots;
+	},
+	slotText(raw) {
+		const props = propsSchema$3.parse(raw);
+		const text = { title: props.title };
+		props.rows.forEach((row, index) => {
+			text[`change-${String(index)}`] = row.changeText;
+		});
+		return text;
+	},
+	slotFont(raw, slot) {
+		const props = propsSchema$3.parse(raw);
+		if (slot === "title") return {
+			family: props.headingFamily,
+			weight: props.headingWeight,
+			lineHeight: 1.15
+		};
+		return {
+			family: props.headingFamily,
+			weight: props.headingWeight,
+			lineHeight: 1.1
+		};
+	},
+	buildProps(facts, copy, brand) {
+		const missing = [];
+		if (facts.bench === void 0) missing.push({
+			fact: "bench",
+			effect: "metrics hidden"
+		});
+		const rows = facts.bench?.metrics.map((metric) => {
+			const change = percentChange(metric.before.value, metric.after.value, metric.better.value);
+			return {
+				label: metric.label.value,
+				beforeText: `${formatMetric(metric.before.value)} ${metric.unit.value}`,
+				afterText: `${formatMetric(metric.after.value)} ${metric.unit.value}`,
+				changeText: changePhrase(metric.unit.value, metric.better.value, change),
+				regression: change.regression
+			};
+		}) ?? [];
+		return {
+			props: {
+				title: copy.headline,
+				note: copy.subheadline,
+				rows,
+				headingFamily: brand.fonts.heading.family,
+				bodyFamily: brand.fonts.body.family,
+				headingWeight: brand.fonts.heading.weight,
+				bodyWeight: brand.fonts.body.weight,
+				radius: brand.radius
+			},
+			missing
+		};
+	},
+	render(raw, ctx) {
+		const props = propsSchema$3.parse(raw);
+		const colors = themeColors(ctx.brand, ctx.theme);
+		const pad = ctx.format.safeZone;
+		const title = ctx.fitted.title;
+		return /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				justifyContent: "space-between",
+				width: "100%",
+				height: "100%",
+				backgroundColor: colors.background,
+				padding: pad
+			},
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					style: {
+						fontFamily: props.headingFamily,
+						fontWeight: props.headingWeight,
+						fontSize: title?.fontSize ?? 40,
+						color: colors.foreground,
+						lineHeight: 1.15
+					},
+					children: title?.text ?? props.title
+				}),
+				/* @__PURE__ */ jsx("div", {
+					style: {
+						display: "flex",
+						flexDirection: "column",
+						gap: 20
+					},
+					children: props.rows.map((row, index) => {
+						const change = ctx.fitted[`change-${String(index)}`];
+						return /* @__PURE__ */ jsxs("div", {
+							style: {
+								display: "flex",
+								flexDirection: "row",
+								justifyContent: "space-between",
+								alignItems: "center",
+								backgroundColor: colors.card,
+								borderRadius: props.radius,
+								paddingTop: 16,
+								paddingBottom: 16,
+								paddingLeft: 24,
+								paddingRight: 24
+							},
+							children: [/* @__PURE__ */ jsxs("div", {
+								style: {
+									display: "flex",
+									flexDirection: "column",
+									gap: 6
+								},
+								children: [/* @__PURE__ */ jsx("div", {
+									style: {
+										fontFamily: props.bodyFamily,
+										fontWeight: props.bodyWeight,
+										fontSize: 22,
+										color: colors.muted
+									},
+									children: row.label
+								}), /* @__PURE__ */ jsx("div", {
+									style: {
+										fontFamily: props.bodyFamily,
+										fontWeight: props.bodyWeight,
+										fontSize: 24,
+										color: colors.foreground
+									},
+									children: `${row.beforeText} to ${row.afterText}`
+								})]
+							}), /* @__PURE__ */ jsxs("div", {
+								style: {
+									display: "flex",
+									flexDirection: "column",
+									alignItems: "flex-end",
+									gap: 4
+								},
+								children: [/* @__PURE__ */ jsx("div", {
+									style: {
+										fontFamily: props.headingFamily,
+										fontWeight: props.headingWeight,
+										fontSize: change?.fontSize ?? 32,
+										color: row.regression ? colors.primary : colors.accent
+									},
+									children: change?.text ?? row.changeText
+								}), row.regression ? /* @__PURE__ */ jsx("div", {
+									style: {
+										fontFamily: props.bodyFamily,
+										fontWeight: props.bodyWeight,
+										fontSize: 18,
+										color: colors.primary
+									},
+									children: "regression"
+								}) : void 0]
+							})]
+						}, row.label);
+					})
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					style: {
+						display: "flex",
+						flexDirection: "row",
+						justifyContent: "space-between",
+						alignItems: "flex-end"
+					},
+					children: [/* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.bodyFamily,
+							fontWeight: props.bodyWeight,
+							fontSize: 20,
+							color: colors.muted
+						},
+						children: props.note
+					}), ctx.attribution ? /* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.bodyFamily,
+							fontWeight: props.bodyWeight,
+							fontSize: 18,
+							color: colors.muted
+						},
+						children: "made with shipseal.dev"
+					}) : void 0]
+				})
+			]
+		});
+	}
+};
+function formatMetric(value) {
+	return String(value);
+}
+
+//#endregion
+//#region src/templates/milestone.tsx
+const propsSchema$2 = z.object({
+	name: z.string(),
+	numberText: z.string(),
+	metricLabel: z.string(),
+	thankYou: z.string(),
+	headingFamily: z.string(),
+	bodyFamily: z.string(),
+	headingWeight: z.number(),
+	bodyWeight: z.number(),
+	radius: z.number(),
+	showLogo: z.boolean()
+});
+const milestone = {
+	id: "milestone",
+	events: ["milestone"],
+	formats: [
+		"og",
+		"x",
+		"linkedin"
+	],
+	propsSchema: propsSchema$2,
+	slots(format) {
+		const width = format.width - 2 * format.safeZone;
+		return {
+			number: {
+				maxLines: 1,
+				maxFontSize: 160,
+				minFontSize: 72,
+				step: 8,
+				box: { width }
+			},
+			thankYou: {
+				maxLines: 2,
+				maxFontSize: 36,
+				minFontSize: 24,
+				step: 2,
+				box: { width }
+			}
+		};
+	},
+	slotText(raw) {
+		const props = propsSchema$2.parse(raw);
+		return {
+			number: props.numberText,
+			thankYou: props.thankYou
+		};
+	},
+	slotFont(raw, slot) {
+		const props = propsSchema$2.parse(raw);
+		if (slot === "number") return {
+			family: props.headingFamily,
+			weight: props.headingWeight,
+			lineHeight: 1
+		};
+		return {
+			family: props.bodyFamily,
+			weight: props.bodyWeight,
+			lineHeight: 1.25
+		};
+	},
+	buildProps(facts, copy, brand) {
+		const missing = [];
+		const threshold = facts.milestone?.threshold.value;
+		if (threshold === void 0) missing.push({
+			fact: "milestone.threshold",
+			effect: "number hidden"
+		});
+		const metric = facts.milestone?.metric.value;
+		const metricLabel = metric === "downloads" ? "weekly downloads" : metric === "contributors" ? "contributors" : "stars";
+		const showLogo = brand.logo !== void 0;
+		if (!showLogo) missing.push({
+			fact: "brand.logo",
+			effect: "logo hidden"
+		});
+		const thankYou = copy.milestoneLine ?? (threshold === void 0 ? "" : `Thank you for ${formatCount$1(threshold)} ${metricLabel}`);
+		return {
+			props: {
+				name: brand.name,
+				numberText: threshold === void 0 ? "" : formatCount$1(threshold),
+				metricLabel,
+				thankYou,
+				headingFamily: brand.fonts.heading.family,
+				bodyFamily: brand.fonts.body.family,
+				headingWeight: brand.fonts.heading.weight,
+				bodyWeight: brand.fonts.body.weight,
+				radius: brand.radius,
+				showLogo
+			},
+			missing
+		};
+	},
+	render(raw, ctx) {
+		const props = propsSchema$2.parse(raw);
+		const colors = themeColors(ctx.brand, ctx.theme);
+		const pad = ctx.format.safeZone;
+		const number = ctx.fitted.number;
+		const thanks = ctx.fitted.thankYou;
+		const compact = ctx.format.height <= 640;
+		return /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				justifyContent: "space-between",
+				width: "100%",
+				height: "100%",
+				backgroundColor: colors.background,
+				padding: pad
+			},
+			children: [
+				/* @__PURE__ */ jsxs("div", {
+					style: {
+						display: "flex",
+						flexDirection: "row",
+						alignItems: "center",
+						gap: 20
+					},
+					children: [props.showLogo && ctx.logoSrc !== void 0 ? /* @__PURE__ */ jsx("img", {
+						src: ctx.logoSrc,
+						width: compact ? 56 : 72,
+						height: compact ? 56 : 72
+					}) : void 0, /* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.headingFamily,
+							fontWeight: props.headingWeight,
+							fontSize: 28,
+							color: colors.foreground
+						},
+						children: props.name
+					})]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					style: {
+						display: "flex",
+						flexDirection: "column",
+						gap: 12
+					},
+					children: [/* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.headingFamily,
+							fontWeight: props.headingWeight,
+							fontSize: number?.fontSize ?? 140,
+							color: colors.foreground,
+							lineHeight: 1
+						},
+						children: number?.text ?? props.numberText
+					}), /* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.bodyFamily,
+							fontWeight: props.headingWeight,
+							fontSize: 32,
+							color: colors.primary
+						},
+						children: props.metricLabel
+					})]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					style: {
+						display: "flex",
+						flexDirection: "row",
+						justifyContent: "space-between",
+						alignItems: "flex-end"
+					},
+					children: [/* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.bodyFamily,
+							fontWeight: props.bodyWeight,
+							fontSize: thanks?.fontSize ?? 28,
+							color: colors.muted,
+							lineHeight: 1.25
+						},
+						children: thanks?.text ?? props.thankYou
+					}), ctx.attribution ? /* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.bodyFamily,
+							fontWeight: props.bodyWeight,
+							fontSize: 18,
+							color: colors.muted
+						},
+						children: "made with shipseal.dev"
+					}) : void 0]
+				})
+			]
+		});
+	}
+};
+
+//#endregion
+//#region src/templates/release-hero.tsx
+const propsSchema$1 = z.object({
+	name: z.string(),
+	version: z.string(),
+	headline: z.string(),
+	subheadline: z.string(),
+	cta: z.string(),
+	headingFamily: z.string(),
+	bodyFamily: z.string(),
+	headingWeight: z.number(),
+	bodyWeight: z.number(),
+	radius: z.number(),
+	showCta: z.boolean(),
+	showLogo: z.boolean()
+});
+const releaseHero = {
+	id: "release-hero",
+	events: ["release"],
+	formats: [
+		"og",
+		"github-social",
+		"x",
+		"linkedin"
+	],
+	propsSchema: propsSchema$1,
+	slots(format) {
+		const width = format.width - 2 * format.safeZone;
+		return {
+			headline: {
+				maxLines: 2,
+				maxFontSize: 72,
+				minFontSize: 48,
+				step: 4,
+				box: { width }
+			},
+			subheadline: {
+				maxLines: 2,
+				maxFontSize: 32,
+				minFontSize: 24,
+				step: 2,
+				box: { width }
+			},
+			cta: {
+				maxLines: 1,
+				maxFontSize: 28,
+				minFontSize: 22,
+				step: 2,
+				box: { width: Math.min(480, width) }
+			}
+		};
+	},
+	slotText(raw) {
+		const props = propsSchema$1.parse(raw);
+		return {
+			headline: props.headline,
+			subheadline: props.subheadline,
+			cta: props.cta
+		};
+	},
+	slotFont(raw, slot) {
+		const props = propsSchema$1.parse(raw);
+		if (slot === "headline") return {
+			family: props.headingFamily,
+			weight: props.headingWeight,
+			lineHeight: 1.1
+		};
+		return {
+			family: props.bodyFamily,
+			weight: props.bodyWeight,
+			lineHeight: 1.25
+		};
+	},
+	buildProps(facts, copy, brand) {
+		const missing = [];
+		if (facts.project.npmPackage === void 0 && facts.project.url === void 0) missing.push({
+			fact: "project.npmPackage",
+			effect: "cta uses project name"
+		});
+		const showLogo = brand.logo !== void 0;
+		if (!showLogo) missing.push({
+			fact: "brand.logo",
+			effect: "logo hidden"
+		});
+		const version = facts.release?.version.value ?? "";
+		return {
+			props: {
+				name: brand.name,
+				version,
+				headline: copy.headline,
+				subheadline: copy.subheadline,
+				cta: copy.cta,
+				headingFamily: brand.fonts.heading.family,
+				bodyFamily: brand.fonts.body.family,
+				headingWeight: brand.fonts.heading.weight,
+				bodyWeight: brand.fonts.body.weight,
+				radius: brand.radius,
+				showCta: copy.cta.length > 0,
+				showLogo
+			},
+			missing
+		};
+	},
+	render(raw, ctx) {
+		const props = propsSchema$1.parse(raw);
+		const colors = themeColors(ctx.brand, ctx.theme);
+		const pad = ctx.format.safeZone;
+		const headline = ctx.fitted.headline;
+		const sub = ctx.fitted.subheadline;
+		const cta = ctx.fitted.cta;
+		const compact = ctx.format.height <= 640;
+		return /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				justifyContent: "space-between",
+				width: "100%",
+				height: "100%",
+				backgroundColor: colors.background,
+				padding: pad
+			},
+			children: [
+				/* @__PURE__ */ jsxs("div", {
+					style: {
+						display: "flex",
+						flexDirection: "row",
+						alignItems: "center",
+						gap: 20
+					},
+					children: [props.showLogo && ctx.logoSrc !== void 0 ? /* @__PURE__ */ jsx("img", {
+						src: ctx.logoSrc,
+						width: compact ? 56 : 72,
+						height: compact ? 56 : 72
+					}) : void 0, /* @__PURE__ */ jsxs("div", {
+						style: {
+							display: "flex",
+							flexDirection: "column",
+							gap: 8
+						},
+						children: [/* @__PURE__ */ jsx("div", {
+							style: {
+								fontFamily: props.headingFamily,
+								fontWeight: props.headingWeight,
+								fontSize: 28,
+								color: colors.foreground
+							},
+							children: props.name
+						}), props.version.length > 0 ? /* @__PURE__ */ jsx("div", {
+							style: {
+								display: "flex",
+								alignItems: "center",
+								backgroundColor: colors.card,
+								borderRadius: props.radius,
+								paddingTop: 6,
+								paddingBottom: 6,
+								paddingLeft: 14,
+								paddingRight: 14
+							},
+							children: /* @__PURE__ */ jsx("div", {
+								style: {
+									fontFamily: props.bodyFamily,
+									fontWeight: props.bodyWeight,
+									fontSize: 22,
+									color: colors.primary
+								},
+								children: `v${props.version}`
+							})
+						}) : void 0]
+					})]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					style: {
+						display: "flex",
+						flexDirection: "column",
+						gap: 16
+					},
+					children: [/* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.headingFamily,
+							fontWeight: props.headingWeight,
+							fontSize: headline?.fontSize ?? 64,
+							color: colors.foreground,
+							lineHeight: 1.1
+						},
+						children: headline?.text ?? props.headline
+					}), /* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.bodyFamily,
+							fontWeight: props.bodyWeight,
+							fontSize: sub?.fontSize ?? 28,
+							color: colors.muted,
+							lineHeight: 1.25
+						},
+						children: sub?.text ?? props.subheadline
+					})]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					style: {
+						display: "flex",
+						flexDirection: "row",
+						justifyContent: "space-between",
+						alignItems: "flex-end"
+					},
+					children: [props.showCta ? /* @__PURE__ */ jsx("div", {
+						style: {
+							display: "flex",
+							backgroundColor: colors.primary,
+							borderRadius: props.radius,
+							paddingTop: 14,
+							paddingBottom: 14,
+							paddingLeft: 24,
+							paddingRight: 24
+						},
+						children: /* @__PURE__ */ jsx("div", {
+							style: {
+								fontFamily: props.bodyFamily,
+								fontWeight: props.headingWeight,
+								fontSize: cta?.fontSize ?? 24,
+								color: colors.background
+							},
+							children: cta?.text ?? props.cta
+						})
+					}) : /* @__PURE__ */ jsx("div", {}), ctx.attribution ? /* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.bodyFamily,
+							fontWeight: props.bodyWeight,
+							fontSize: 18,
+							color: colors.muted
+						},
+						children: "made with shipseal.dev"
+					}) : void 0]
+				})
+			]
+		});
+	}
+};
+
+//#endregion
+//#region src/templates/release-highlights.tsx
+const propsSchema = z.object({
+	name: z.string(),
+	version: z.string(),
+	highlights: z.array(z.string()),
+	headingFamily: z.string(),
+	bodyFamily: z.string(),
+	headingWeight: z.number(),
+	bodyWeight: z.number(),
+	radius: z.number()
+});
+const releaseHighlights = {
+	id: "release-highlights",
+	events: ["release"],
+	formats: ["x", "linkedin"],
+	propsSchema,
+	slots(format) {
+		const width = format.width - 2 * format.safeZone - 48;
+		const slots = {};
+		for (let index = 0; index < 4; index += 1) slots[`highlight-${String(index)}`] = {
+			maxLines: 2,
+			maxFontSize: 32,
+			minFontSize: 24,
+			step: 2,
+			box: { width }
+		};
+		return slots;
+	},
+	slotText(raw) {
+		const props = propsSchema.parse(raw);
+		const text = {};
+		props.highlights.forEach((line, index) => {
+			text[`highlight-${String(index)}`] = line;
+		});
+		return text;
+	},
+	slotFont(raw) {
+		const props = propsSchema.parse(raw);
+		return {
+			family: props.bodyFamily,
+			weight: props.bodyWeight,
+			lineHeight: 1.25
+		};
+	},
+	buildProps(facts, copy, brand) {
+		const missing = [];
+		if (copy.highlights.length === 0) missing.push({
+			fact: "release.features",
+			effect: "highlights list empty"
+		});
+		return {
+			props: {
+				name: brand.name,
+				version: facts.release?.version.value ?? "",
+				highlights: copy.highlights,
+				headingFamily: brand.fonts.heading.family,
+				bodyFamily: brand.fonts.body.family,
+				headingWeight: brand.fonts.heading.weight,
+				bodyWeight: brand.fonts.body.weight,
+				radius: brand.radius
+			},
+			missing
+		};
+	},
+	render(raw, ctx) {
+		const props = propsSchema.parse(raw);
+		const colors = themeColors(ctx.brand, ctx.theme);
+		const pad = ctx.format.safeZone;
+		const title = props.version.length > 0 ? `What's new in v${props.version}` : "What's new";
+		return /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				width: "100%",
+				height: "100%",
+				backgroundColor: colors.background,
+				padding: pad,
+				gap: 28
+			},
+			children: [
+				/* @__PURE__ */ jsxs("div", {
+					style: {
+						display: "flex",
+						flexDirection: "column",
+						gap: 8
+					},
+					children: [/* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.bodyFamily,
+							fontWeight: props.bodyWeight,
+							fontSize: 22,
+							color: colors.primary
+						},
+						children: props.name
+					}), /* @__PURE__ */ jsx("div", {
+						style: {
+							fontFamily: props.headingFamily,
+							fontWeight: props.headingWeight,
+							fontSize: 48,
+							color: colors.foreground
+						},
+						children: title
+					})]
+				}),
+				/* @__PURE__ */ jsx("div", {
+					style: {
+						display: "flex",
+						flexDirection: "column",
+						gap: 16
+					},
+					children: props.highlights.map((line, index) => {
+						const fitted = ctx.fitted[`highlight-${String(index)}`];
+						const breaking = line.startsWith("Breaking:");
+						return /* @__PURE__ */ jsxs("div", {
+							style: {
+								display: "flex",
+								flexDirection: "row",
+								alignItems: "flex-start",
+								gap: 16,
+								backgroundColor: colors.card,
+								borderRadius: props.radius,
+								padding: 18
+							},
+							children: [/* @__PURE__ */ jsx("div", { style: {
+								width: 12,
+								height: 12,
+								borderRadius: 6,
+								backgroundColor: breaking ? colors.accent : colors.primary,
+								marginTop: 10
+							} }), /* @__PURE__ */ jsx("div", {
+								style: {
+									fontFamily: props.bodyFamily,
+									fontWeight: props.bodyWeight,
+									fontSize: fitted?.fontSize ?? 28,
+									color: colors.foreground,
+									lineHeight: 1.25
+								},
+								children: fitted?.text ?? line
+							})]
+						}, String(index));
+					})
+				}),
+				ctx.attribution ? /* @__PURE__ */ jsx("div", {
+					style: {
+						fontFamily: props.bodyFamily,
+						fontWeight: props.bodyWeight,
+						fontSize: 18,
+						color: colors.muted,
+						marginTop: "auto"
+					},
+					children: "made with shipseal.dev"
+				}) : void 0
+			]
+		});
+	}
+};
+
+//#endregion
+//#region src/templates/registry.ts
+const templates = [
+	releaseHero,
+	releaseHighlights,
+	codeCard,
+	milestone,
+	bench
+];
+function getTemplate(id) {
+	const found = templates.find((template) => template.id === id);
+	if (found === void 0) throw new ShipsealError("template.unknown", `Unknown template "${id}".`, `Use one of: ${templates.map((template) => template.id).join(", ")}.`);
+	return found;
+}
+
+//#endregion
+//#region src/core/generate.ts
+async function generate(input) {
+	const templateIds = templateIdsFor(input.event, input.config);
+	const formatIds = input.config.formats ?? [
+		"og",
+		"github-social",
+		"x",
+		"linkedin"
+	];
+	const imageFormat = input.config.output?.imageFormat ?? "png";
+	const attribution = input.config.attribution !== false;
+	const files = [];
+	const warnings = [];
+	const missing = [];
+	const recordedMissing = /* @__PURE__ */ new Set();
+	const omitThemeSuffix = input.themes.length === 1;
+	for (const templateId of templateIds) {
+		const template = getTemplate(templateId);
+		if (!template.events.includes(input.event.kind)) continue;
+		for (const formatId of formatIds) {
+			if (!template.formats.includes(formatId)) continue;
+			const format = FORMATS[formatId];
+			for (const theme of input.themes) {
+				const copy = await copyForTemplate(template.id, input.copy, input.facts, theme);
+				const built = template.buildProps(input.facts, copy, input.brand);
+				const props = template.propsSchema.parse(built.props);
+				if (!recordedMissing.has(template.id)) {
+					recordedMissing.add(template.id);
+					for (const item of built.missing) missing.push({
+						template: template.id,
+						fact: item.fact,
+						effect: item.effect
+					});
+				}
+				const { fitted, truncated } = await fitSlots(input.renderer, template, props, format);
+				for (const slot of truncated) warnings.push({
+					type: "fit-warning",
+					template: template.id,
+					format: formatId,
+					slot,
+					action: "truncated"
+				});
+				const logo = logoForTheme(input.logos, theme);
+				const ctx = {
+					format,
+					theme,
+					brand: input.brand,
+					fitted,
+					attribution
+				};
+				if (logo !== void 0) ctx.logoSrc = "shipseal-logo";
+				const jsx = template.render(props, ctx);
+				const node = await input.renderer.fromJsx(jsx);
+				const renderOpts = {
+					width: format.width,
+					height: format.height,
+					format: imageFormat
+				};
+				if (logo !== void 0) renderOpts.images = [{
+					src: "shipseal-logo",
+					data: logo
+				}];
+				const bytes = await input.renderer.render(node, renderOpts);
+				const fileName = outputName(template.id, formatId, theme, omitThemeSuffix, imageFormat);
+				files.push({
+					fileName,
+					template: template.id,
+					format: formatId,
+					theme,
+					width: format.width,
+					height: format.height,
+					bytes,
+					sha256: createHash("sha256").update(bytes).digest("hex")
+				});
+			}
+		}
+	}
+	return {
+		files,
+		warnings,
+		missing,
+		facts: input.facts,
+		copy: input.copy,
+		copyMode: input.copyMode,
+		generatedAt: input.generatedAt,
+		computed: computedFromFacts(input.facts)
+	};
+}
+function templateIdsFor(event, config) {
+	if (event.kind === "milestone") return ["milestone"];
+	if (event.kind === "bench") return ["bench"];
+	return config.release?.templates ?? [
+		"release-hero",
+		"release-highlights",
+		"code-card"
+	];
+}
+function computedFromFacts(facts) {
+	const out = {};
+	if (facts.bench === void 0) return out;
+	facts.bench.metrics.forEach((metric, index) => {
+		const change = percentChange(metric.before.value, metric.after.value, metric.better.value);
+		const prefix = `bench.metrics[${String(index)}]`;
+		out[`${prefix}.percent`] = {
+			value: change.signed,
+			computedFrom: [
+				`${prefix}.before`,
+				`${prefix}.after`,
+				`${prefix}.better`
+			]
+		};
+	});
+	return out;
+}
+async function fitSlots(renderer, template, props, format) {
+	const specs = template.slots(format);
+	const texts = template.slotText(props);
+	const fitted = {};
+	const truncated = [];
+	for (const [slot, spec] of Object.entries(specs)) {
+		const text = texts[slot];
+		if (text === void 0) continue;
+		const font = template.slotFont(props, slot);
+		const fitFont = {
+			family: font.family,
+			lineHeight: font.lineHeight,
+			weight: font.weight
+		};
+		if (font.whiteSpace !== void 0) fitFont.whiteSpace = font.whiteSpace;
+		const result = await fitText(renderer, text, spec, fitFont);
+		fitted[slot] = result;
+		if (result.truncated) truncated.push(slot);
+	}
+	return {
+		fitted,
+		truncated
+	};
+}
+function outputName(template, format, theme, omitTheme, imageFormat) {
+	return `${template}-${format}${omitTheme ? "" : `-${theme}`}.${imageFormat}`;
+}
+function logoForTheme(logos, theme) {
+	if (logos === void 0) return;
+	if (theme === "dark") return logos.dark ?? logos.light;
+	return logos.light ?? logos.dark;
+}
+async function copyForTemplate(templateId, copy, facts, theme) {
+	if (templateId !== "code-card") return copy;
+	const snippet = facts.release?.codeSnippet?.value;
+	if (snippet === void 0) return {
+		...copy,
+		codeLines: emptyCodeLines()
+	};
+	return {
+		...copy,
+		codeLines: await highlightCode(snippet.code, snippet.lang, theme)
+	};
+}
+
+//#endregion
+//#region src/facts/merge.ts
+function mergeFacts(parts) {
+	const project = {};
+	const release = {};
+	const metrics = {};
+	const milestone = {};
+	let bench;
+	for (const part of parts) {
+		fillObject(project, part.project);
+		mergeRelease(release, part.release);
+		fillObject(metrics, part.metrics);
+		fillObject(milestone, part.milestone);
+		if (part.bench !== void 0) bench = part.bench;
+	}
+	if (project.name === void 0) throw new ShipsealError("facts.missing-name", "Could not determine the project name.", "Add a name field to package.json, or an H1 in README.md.");
+	const facts = { project: { name: project.name } };
+	if (project.tagline !== void 0) facts.project.tagline = project.tagline;
+	if (project.url !== void 0) facts.project.url = project.url;
+	if (project.repo !== void 0) facts.project.repo = project.repo;
+	if (project.npmPackage !== void 0) facts.project.npmPackage = project.npmPackage;
+	if (project.license !== void 0) facts.project.license = project.license;
+	if (isCompleteRelease(release)) {
+		facts.release = {
+			version: release.version,
+			tag: release.tag,
+			date: release.date,
+			features: release.features ?? [],
+			fixes: release.fixes ?? [],
+			breaking: release.breaking ?? []
+		};
+		if (release.previousVersion !== void 0) facts.release.previousVersion = release.previousVersion;
+		if (release.commitCount !== void 0) facts.release.commitCount = release.commitCount;
+		if (release.contributors !== void 0) facts.release.contributors = release.contributors;
+		if (release.codeSnippet !== void 0) facts.release.codeSnippet = release.codeSnippet;
+	}
+	if (Object.keys(metrics).length > 0) facts.metrics = metrics;
+	if (bench !== void 0) facts.bench = bench;
+	if (milestone.metric !== void 0 && milestone.threshold !== void 0) facts.milestone = {
+		metric: milestone.metric,
+		threshold: milestone.threshold
+	};
+	return facts;
+}
+function mergeRelease(target, overlay) {
+	if (overlay === void 0) return;
+	fillObject(target, overlay, [
+		"features",
+		"fixes",
+		"breaking"
+	]);
+	replaceList(target, overlay, "features");
+	replaceList(target, overlay, "fixes");
+	replaceList(target, overlay, "breaking");
+}
+function replaceList(target, overlay, key) {
+	const next = overlay[key];
+	if (next !== void 0) target[key] = next;
+}
+function fillObject(target, overlay, skip = []) {
+	if (overlay === void 0) return;
+	const skipped = new Set(skip);
+	for (const key of Object.keys(overlay)) {
+		if (skipped.has(key)) continue;
+		const value = overlay[key];
+		if (value !== void 0 && target[key] === void 0) target[key] = value;
+	}
+}
+function isCompleteRelease(release) {
+	return release.version !== void 0 && release.tag !== void 0 && release.date !== void 0;
+}
+
+//#endregion
+//#region src/facts/fact.ts
+function fact(value, provenance) {
+	const fetchedAt = provenance.fetchedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		value,
+		provenance: {
+			source: provenance.source,
+			ref: provenance.ref,
+			fetchedAt
+		}
+	};
+}
+
+//#endregion
+//#region src/sources/bench-file.ts
+const metricSchema = z.object({
+	label: z.string().min(1),
+	before: z.number().finite(),
+	after: z.number().finite(),
+	unit: z.string().min(1),
+	better: z.enum(["lower", "higher"])
+});
+const benchFileSchema = z.object({
+	title: z.string().min(1),
+	metrics: z.array(metricSchema).min(1).max(3),
+	note: z.string().optional()
+});
+async function collectBenchFile(cwd, filePath = ".shipseal/bench.json") {
+	const resolved = isAbsolute(filePath) ? filePath : join(cwd, filePath);
+	let raw;
+	try {
+		raw = await readFile(resolved, "utf8");
+	} catch (error) {
+		throw new ShipsealError("bench.missing-file", `Benchmark file not found: ${filePath}.`, "Write .shipseal/bench.json (title, metrics with before/after/unit/better), or pass --file <path>.", { cause: error });
+	}
+	let json;
+	try {
+		json = JSON.parse(raw);
+	} catch (error) {
+		throw new ShipsealError("bench.invalid-json", `Benchmark file is not valid JSON: ${filePath}.`, "Fix the JSON syntax, then retry.", { cause: error });
+	}
+	const parsed = benchFileSchema.safeParse(json);
+	if (!parsed.success) throw new ShipsealError("bench.invalid-shape", `Benchmark file is missing required fields: ${filePath}.`, "Each metric needs label, before, after, unit, and better (\"lower\" or \"higher\"). At most 3 metrics.");
+	const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const ref = filePath;
+	const bench = {
+		title: fact(parsed.data.title, {
+			source: "bench-file",
+			ref: `${ref}#title`,
+			fetchedAt
+		}),
+		metrics: parsed.data.metrics.map((metric, index) => ({
+			label: fact(metric.label, {
+				source: "bench-file",
+				ref: `${ref}#metrics[${String(index)}].label`,
+				fetchedAt
+			}),
+			before: fact(metric.before, {
+				source: "bench-file",
+				ref: `${ref}#metrics[${String(index)}].before`,
+				fetchedAt
+			}),
+			after: fact(metric.after, {
+				source: "bench-file",
+				ref: `${ref}#metrics[${String(index)}].after`,
+				fetchedAt
+			}),
+			unit: fact(metric.unit, {
+				source: "bench-file",
+				ref: `${ref}#metrics[${String(index)}].unit`,
+				fetchedAt
+			}),
+			better: fact(metric.better, {
+				source: "bench-file",
+				ref: `${ref}#metrics[${String(index)}].better`,
+				fetchedAt
+			})
+		}))
+	};
+	if (parsed.data.note !== void 0) bench.note = fact(parsed.data.note, {
+		source: "bench-file",
+		ref: `${ref}#note`,
+		fetchedAt
+	});
+	return { bench };
+}
+
+//#endregion
+//#region src/sources/changelog.ts
+async function collectChangelog(cwd, version, changelogPath = "CHANGELOG.md") {
+	if (version === void 0) return {};
+	let markdown;
+	try {
+		markdown = await readFile(join(cwd, changelogPath), "utf8");
+	} catch {
+		return {};
+	}
+	const section = findVersionSection(markdown, version);
+	if (section === void 0) return {};
+	const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const features = [];
+	const fixes = [];
+	const breaking = [];
+	for (const group of parseGroups(section.body)) {
+		const bucket = bucketForHeading(group.heading);
+		if (bucket === void 0) continue;
+		for (const item of group.items) {
+			const cleaned = cleanChangelogItem(item);
+			if (cleaned.length === 0) continue;
+			const entry = fact(cleaned, {
+				source: "changelog",
+				ref: `${changelogPath} ${section.heading} ${group.heading}: ${item}`,
+				fetchedAt
+			});
+			if (bucket === "features") features.push(entry);
+			else if (bucket === "fixes") fixes.push(entry);
+			else breaking.push(entry);
+		}
+	}
+	const out = { release: {
+		version: fact(version.replace(/^v/, ""), {
+			source: "changelog",
+			ref: `${changelogPath} ${section.heading}`,
+			fetchedAt
+		}),
+		tag: fact(version.startsWith("v") ? version : `v${version}`, {
+			source: "changelog",
+			ref: `${changelogPath} ${section.heading}`,
+			fetchedAt
+		}),
+		features,
+		fixes,
+		breaking
+	} };
+	if (section.date !== void 0) out.release = {
+		...out.release,
+		date: fact(section.date, {
+			source: "changelog",
+			ref: `${changelogPath} ${section.heading}`,
+			fetchedAt
+		})
+	};
+	return out;
+}
+function findVersionSection(markdown, version) {
+	const needle = version.replace(/^v/, "");
+	const matches = [...markdown.matchAll(/^##\s+(.+)$/gm)];
+	for (let index = 0; index < matches.length; index += 1) {
+		const match = matches[index];
+		if (match === void 0) continue;
+		const heading = match[1];
+		if (heading === void 0 || !headingIncludesVersion(heading, needle)) continue;
+		const start = (match.index ?? 0) + match[0].length;
+		const end = matches[index + 1]?.index ?? markdown.length;
+		const date = extractDate(heading);
+		const body = markdown.slice(start, end);
+		if (date === void 0) return {
+			heading,
+			body
+		};
+		return {
+			heading,
+			body,
+			date
+		};
+	}
+}
+function cleanChangelogItem(item) {
+	return item.replace(/^\s*[-*]\s*/, "").replace(/\[`[a-f0-9]{7,40}`]\([^)]+\)/gi, "").replace(/^[a-f0-9]{7,40}:\s*/i, "").replace(/\(#\d+\)/g, "").replace(/\[#\d+]\([^)]+\)/g, "").replace(/Thanks\s+\[@[\w-]+]\([^)]+\)!?\s*-?\s*/gi, "").replace(/\[@[\w-]+]\([^)]+\)/g, "").replace(/\(@[\w-]+\)/g, "").replace(/\s+by\s+@[\w-]+/gi, "").replace(/@[\w-]+/g, "").replace(/^Thanks\s*!?\s*-?\s*/i, "").replace(/^\s*[-*]\s*/, "").replace(/\s+/g, " ").trim().replace(/\.$/, "");
+}
+function headingIncludesVersion(heading, version) {
+	const unwrapped = heading.replace(/[[\]]/g, " ");
+	return new RegExp(`(?:^|\\s)v?${escapeRegExp(version)}(?:\\s|$)`).test(unwrapped);
+}
+function extractDate(heading) {
+	return /(\d{4}-\d{2}-\d{2})/.exec(heading)?.[1];
+}
+function parseGroups(body) {
+	const groups = [];
+	const matches = [...body.matchAll(/^###\s+(.+)$/gm)];
+	if (matches.length === 0) return [{
+		heading: "Added",
+		items: listItems(body)
+	}];
+	for (let index = 0; index < matches.length; index += 1) {
+		const match = matches[index];
+		if (match === void 0) continue;
+		const heading = match[1];
+		if (heading === void 0) continue;
+		const start = (match.index ?? 0) + match[0].length;
+		const end = matches[index + 1]?.index ?? body.length;
+		groups.push({
+			heading,
+			items: listItems(body.slice(start, end))
+		});
+	}
+	return groups;
+}
+function listItems(block) {
+	const items = [];
+	let current;
+	for (const raw of block.split("\n")) {
+		const trimmed = raw.trim();
+		if (trimmed.startsWith("- ") || trimmed.startsWith("* ")) {
+			if (current !== void 0) items.push(current);
+			current = trimmed;
+			continue;
+		}
+		if (current !== void 0 && trimmed.length > 0 && !trimmed.startsWith("#")) current = `${current} ${trimmed}`;
+	}
+	if (current !== void 0) items.push(current);
+	return items;
+}
+function bucketForHeading(heading) {
+	const key = heading.trim().toLowerCase();
+	if (key === "added" || key === "changed" || key === "minor changes" || key === "features") return "features";
+	if (key === "fixed" || key === "patch changes" || key === "security" || key === "fixes") return "fixes";
+	if (key === "removed" || key === "major changes" || key === "breaking" || key === "breaking changes") return "breaking";
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+//#endregion
+//#region src/sources/git.ts
+const execFileAsync$3 = promisify(execFile);
+async function collectGit(cwd, event) {
+	if (await git(cwd, ["rev-parse", "--is-inside-work-tree"]) !== "true") return {};
+	const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const tag = event.tag ?? await gitCurrentTag(cwd);
+	if (tag === void 0) return {};
+	if (await git(cwd, [
+		"rev-parse",
+		"--verify",
+		`${tag}^{commit}`
+	]) === void 0) return {};
+	const version = versionFromTag(tag);
+	const tags = await gitLines(cwd, ["tag", "--sort=-v:refname"]);
+	const tagIndex = tags.indexOf(tag);
+	const previousTag = event.previousTag ?? (tagIndex >= 0 ? tags[tagIndex + 1] : tags.find((candidate) => candidate !== tag));
+	const range = previousTag === void 0 ? tag : `${previousTag}..${tag}`;
+	const commits = (await git(cwd, [
+		"log",
+		range,
+		"--pretty=format:%s	%an	%ae	%h	%cI"
+	]) ?? "").split("\n").filter((line) => line.length > 0);
+	const features = [];
+	const fixes = [];
+	const breaking = [];
+	const contributors = /* @__PURE__ */ new Map();
+	for (const line of commits) {
+		const [subject, author, email, hash] = line.split("	");
+		if (subject === void 0 || hash === void 0) continue;
+		const parsed = parseConventional(subject);
+		const display = parsed.display;
+		const ref = `git log ${range} ${hash}`;
+		const item = fact(display, {
+			source: "git",
+			ref,
+			fetchedAt
+		});
+		if (parsed.breaking) breaking.push(item);
+		else if (parsed.type === "feat") features.push(item);
+		else if (parsed.type === "fix" || parsed.type === "perf") fixes.push(item);
+		if (email !== void 0 && author !== void 0 && !isBot(author, email)) contributors.set(email, author);
+	}
+	const date = (await git(cwd, [
+		"log",
+		"-1",
+		"--format=%cI",
+		tag
+	]) ?? fetchedAt).slice(0, 10);
+	const names = [...contributors.values()];
+	const release = {
+		version: fact(version, {
+			source: "git",
+			ref: `git tag ${tag}`,
+			fetchedAt
+		}),
+		tag: fact(tag, {
+			source: "git",
+			ref: `git tag ${tag}`,
+			fetchedAt
+		}),
+		date: fact(date, {
+			source: "git",
+			ref: `git log -1 --format=%cI ${tag}`,
+			fetchedAt
+		}),
+		features,
+		fixes,
+		breaking,
+		commitCount: fact(commits.length, {
+			source: "git",
+			ref: `git rev-list --count ${range}`,
+			fetchedAt
+		})
+	};
+	if (previousTag !== void 0) release.previousVersion = fact(versionFromTag(previousTag), {
+		source: "git",
+		ref: `git tag ${previousTag}`,
+		fetchedAt
+	});
+	if (names.length > 0) release.contributors = fact(names, {
+		source: "git",
+		ref: `git log ${range} unique authors`,
+		fetchedAt
+	});
+	return { release };
+}
+function parseConventional(subject) {
+	const match = /^(?<type>\w+)(?<scope>\([^)]+\))?(?<bang>!)?:\s*(?<rest>.+)$/.exec(subject);
+	if (match === null || match.groups === void 0) return {
+		type: void 0,
+		display: displaySubject(subject),
+		breaking: false
+	};
+	const type = match.groups.type;
+	const rest = match.groups.rest ?? subject;
+	const breaking = match.groups.bang === "!" || /BREAKING CHANGE:/.test(subject);
+	return {
+		type,
+		display: displaySubject(rest),
+		breaking
+	};
+}
+function versionFromTag(tag) {
+	const at = tag.lastIndexOf("@");
+	if (at >= 0 && at < tag.length - 1) return tag.slice(at + 1).replace(/^v/, "");
+	return tag.replace(/^v/, "");
+}
+async function gitCurrentTag(cwd) {
+	return git(cwd, [
+		"describe",
+		"--tags",
+		"--abbrev=0"
+	]);
+}
+async function git(cwd, args) {
+	try {
+		const { stdout } = await execFileAsync$3("git", args, { cwd });
+		const trimmed = stdout.trim();
+		return trimmed.length === 0 ? void 0 : trimmed;
+	} catch {
+		return;
+	}
+}
+async function gitLines(cwd, args) {
+	const out = await git(cwd, args);
+	return out === void 0 ? [] : out.split("\n").filter((line) => line.length > 0);
+}
+function isBot(author, email) {
+	const haystack = `${author} ${email}`.toLowerCase();
+	return author.endsWith("[bot]") || haystack.includes("dependabot") || haystack.includes("renovate") || haystack.includes("github-actions");
+}
+function displaySubject(text) {
+	const cleaned = cleanChangelogItem(text);
+	const first = cleaned.at(0);
+	if (first === void 0) return cleaned;
+	return first.toUpperCase() + cleaned.slice(1);
+}
+
+//#endregion
+//#region src/sources/github.ts
+const API_VERSION = "2022-11-28";
+const API_ROOT$1 = "https://api.github.com";
+const repoSchema = z.object({
+	stargazers_count: z.number().int().nonnegative(),
+	description: z.string().nullable().optional(),
+	homepage: z.string().nullable().optional(),
+	license: z.object({ spdx_id: z.string().nullable() }).nullable().optional()
+});
+const releaseSchema = z.object({ body: z.string().nullable().optional() });
+const contributorsSchema = z.array(z.unknown());
+async function collectGithub(options) {
+	const slug = parseRepo(options.repo);
+	if (slug === void 0) return {};
+	const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const cache = options.cache ?? /* @__PURE__ */ new Map();
+	const repoResponse = await githubGet(`${API_ROOT$1}/repos/${slug.owner}/${slug.repo}`, options.token, fetchImpl, cache);
+	if (repoResponse === void 0) return {};
+	const repo = repoSchema.parse(repoResponse.json);
+	const out = {
+		metrics: { stars: fact(repo.stargazers_count, {
+			source: "github-api",
+			ref: `GET /repos/${slug.owner}/${slug.repo} stargazers_count`,
+			fetchedAt
+		}) },
+		project: {}
+	};
+	if (repo.description !== void 0 && repo.description !== null && repo.description.length > 0) out.project = {
+		...out.project,
+		tagline: fact(repo.description, {
+			source: "github-api",
+			ref: `GET /repos/${slug.owner}/${slug.repo} description`,
+			fetchedAt
+		})
+	};
+	if (repo.homepage !== void 0 && repo.homepage !== null && repo.homepage.length > 0) out.project = {
+		...out.project,
+		url: fact(repo.homepage, {
+			source: "github-api",
+			ref: `GET /repos/${slug.owner}/${slug.repo} homepage`,
+			fetchedAt
+		})
+	};
+	const license = repo.license?.spdx_id;
+	if (license !== void 0 && license !== null && license !== "NOASSERTION") out.project = {
+		...out.project,
+		license: fact(license, {
+			source: "github-api",
+			ref: `GET /repos/${slug.owner}/${slug.repo} license.spdx_id`,
+			fetchedAt
+		})
+	};
+	if (options.tag !== void 0) {
+		const releaseResponse = await githubGet(`${API_ROOT$1}/repos/${slug.owner}/${slug.repo}/releases/tags/${encodeURIComponent(options.tag)}`, options.token, fetchImpl, cache, { notFoundOk: true });
+		if (releaseResponse !== void 0) {
+			const features = featuresFromReleaseBody(releaseSchema.parse(releaseResponse.json).body ?? "", options.tag, fetchedAt);
+			if (features.length > 0) out.release = { features };
+		}
+	}
+	const contributors = await githubGet(`${API_ROOT$1}/repos/${slug.owner}/${slug.repo}/contributors?per_page=1&anon=true`, options.token, fetchImpl, cache, { notFoundOk: true });
+	if (contributors !== void 0) {
+		contributorsSchema.parse(contributors.json);
+		const listed = Array.isArray(contributors.json) ? contributors.json.length : 0;
+		const fromLink = lastPageFromLink(contributors.link);
+		out.metrics = {
+			...out.metrics,
+			contributorCount: fact(fromLink ?? listed, {
+				source: "github-api",
+				ref: `GET /repos/${slug.owner}/${slug.repo}/contributors`,
+				fetchedAt
+			})
+		};
+	}
+	return out;
+}
+function parseRepo(value) {
+	const trimmed = value.trim().replace(/\.git$/, "");
+	const match = /^(?:https?:\/\/github\.com\/)?([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(trimmed);
+	if (match === null || match[1] === void 0 || match[2] === void 0) return;
+	return {
+		owner: match[1],
+		repo: match[2]
+	};
+}
+function featuresFromReleaseBody(body, tag, fetchedAt) {
+	return body.split("\n").map((line) => line.replace(/^\s*[-*]\s*/, "").trim()).filter((line) => line.length > 0 && !line.startsWith("#")).slice(0, 8).map((line) => fact(line.replace(/\.$/, ""), {
+		source: "github-api",
+		ref: `GET /repos/.../releases/tags/${tag} body`,
+		fetchedAt
+	}));
+}
+async function githubGet(url, token, fetchImpl, cache, opts = {}) {
+	const cached = cache.get(url);
+	if (cached !== void 0) return cached;
+	const headers = {
+		Accept: "application/vnd.github+json",
+		"X-GitHub-Api-Version": API_VERSION,
+		"User-Agent": "shipseal"
+	};
+	if (token !== void 0 && token.length > 0) headers.Authorization = `Bearer ${token}`;
+	let response;
+	try {
+		response = await fetchImpl(url, { headers });
+	} catch (error) {
+		throw new ShipsealError("github.network", "Could not reach the GitHub API.", "Check network access, then retry. Unauthenticated calls are optional; facts still come from git and package.json.", { cause: error });
+	}
+	if (response.status === 404 && opts.notFoundOk === true) return;
+	if (response.status === 403 || response.status === 429) throw new ShipsealError("github.rate-limit", "GitHub API rate limit exceeded.", "Set GITHUB_TOKEN in the environment to raise the limit, then retry.");
+	if (!response.ok) throw new ShipsealError("github.http", `GitHub API returned HTTP ${String(response.status)} for ${url}.`, "Confirm the repository exists and GITHUB_TOKEN can read it.");
+	const entry = {
+		json: await response.json(),
+		link: response.headers.get("link")
+	};
+	cache.set(url, entry);
+	return entry;
+}
+function lastPageFromLink(link) {
+	if (link === null) return;
+	const match = /[?&]page=(\d+)>;\s*rel="last"/.exec(link);
+	if (match === null || match[1] === void 0) return;
+	return Number.parseInt(match[1], 10);
+}
+
+//#endregion
+//#region src/sources/npm.ts
+const API_ROOT = "https://api.npmjs.org/downloads/point/last-week";
+const pointSchema = z.object({
+	downloads: z.number().int().nonnegative(),
+	start: z.string().optional(),
+	end: z.string().optional(),
+	package: z.string().optional()
+});
+async function collectNpm(options) {
+	const name = options.npmPackage.trim();
+	if (name.length === 0) return {};
+	const url = `${API_ROOT}/${encodeURIComponent(name)}`;
+	const cache = options.cache ?? /* @__PURE__ */ new Map();
+	const json = cache.get(url) ?? await npmGet(url, options.fetchImpl ?? fetch, cache);
+	if (json === void 0) return {};
+	const point = pointSchema.parse(json);
+	return { metrics: { weeklyDownloads: fact(point.downloads, {
+		source: "npm-api",
+		ref: `GET /downloads/point/last-week/${name} downloads`,
+		fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}) } };
+}
+async function npmGet(url, fetchImpl, cache) {
+	let response;
+	try {
+		response = await fetchImpl(url, { headers: {
+			Accept: "application/json",
+			"User-Agent": "shipseal"
+		} });
+	} catch (error) {
+		throw new ShipsealError("npm.network", "Could not reach the npm downloads API.", "Check network access, then retry. Weekly downloads are optional; other facts still render.", { cause: error });
+	}
+	if (response.status === 404) return;
+	if (response.status === 403 || response.status === 429) throw new ShipsealError("npm.rate-limit", "npm downloads API rate limit exceeded.", "Wait and retry. Milestone cards can still use stars and contributors without downloads.");
+	if (!response.ok) throw new ShipsealError("npm.http", `npm downloads API returned HTTP ${String(response.status)} for ${url}.`, "Confirm the package name in package.json is published on npm.");
+	const json = await response.json();
+	cache.set(url, json);
+	return json;
+}
+
+//#endregion
+//#region src/sources/package-json.ts
+const pkgSchema = z.object({
+	name: z.string().optional(),
+	description: z.string().optional(),
+	version: z.string().optional(),
+	homepage: z.string().optional(),
+	license: z.string().optional(),
+	repository: z.union([z.string(), z.object({ url: z.string().optional() })]).optional()
+});
+async function collectPackageJson(cwd, packagePath = "package.json") {
+	const path = join(cwd, packagePath);
+	let raw;
+	try {
+		raw = await readFile(path, "utf8");
+	} catch {
+		return {};
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return {};
+	}
+	const pkg = pkgSchema.safeParse(parsed);
+	if (!pkg.success) return {};
+	const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const project = { name: fact(stripScope$1(pkg.data.name ?? basenameFromPath(cwd)), {
+		source: "package-json",
+		ref: `${packagePath}#name`,
+		fetchedAt
+	}) };
+	if (pkg.data.description !== void 0 && pkg.data.description.length > 0) project.tagline = fact(pkg.data.description, {
+		source: "package-json",
+		ref: `${packagePath}#description`,
+		fetchedAt
+	});
+	const url = pkg.data.homepage ?? repositoryUrl$1(pkg.data.repository);
+	if (url !== void 0) project.url = fact(url, {
+		source: "package-json",
+		ref: pkg.data.homepage !== void 0 ? `${packagePath}#homepage` : `${packagePath}#repository`,
+		fetchedAt
+	});
+	const repo = repoSlug(pkg.data.repository);
+	if (repo !== void 0) project.repo = fact(repo, {
+		source: "package-json",
+		ref: `${packagePath}#repository`,
+		fetchedAt
+	});
+	if (pkg.data.name !== void 0) project.npmPackage = fact(pkg.data.name, {
+		source: "package-json",
+		ref: `${packagePath}#name`,
+		fetchedAt
+	});
+	if (pkg.data.license !== void 0) project.license = fact(pkg.data.license, {
+		source: "package-json",
+		ref: `${packagePath}#license`,
+		fetchedAt
+	});
+	const out = { project };
+	if (pkg.data.version !== void 0) out.release = { version: fact(pkg.data.version.replace(/^v/, ""), {
+		source: "package-json",
+		ref: `${packagePath}#version`,
+		fetchedAt
+	}) };
+	return out;
+}
+function stripScope$1(name) {
+	const parts = name.split("/");
+	return parts[parts.length - 1] ?? name;
+}
+function basenameFromPath(cwd) {
+	const parts = cwd.split(/[/\\]/).filter((part) => part.length > 0);
+	return parts[parts.length - 1] ?? "project";
+}
+function repositoryUrl$1(repository) {
+	if (typeof repository === "string") return normalizeGitUrl$1(repository);
+	if (repository?.url !== void 0) return normalizeGitUrl$1(repository.url);
+}
+function repoSlug(repository) {
+	const url = repositoryUrl$1(repository);
+	if (url === void 0) return;
+	return /github\.com[/:]([^/]+\/[^/]+)$/.exec(url.replace(/\.git$/, ""))?.[1];
+}
+const SHORTHAND = /^(?:github:)?([\w.-]+\/[\w.-]+)$/;
+function normalizeGitUrl$1(url) {
+	const shorthand = SHORTHAND.exec(url);
+	if (shorthand?.[1] !== void 0) return `https://github.com/${shorthand[1].replace(/\.git$/, "")}`;
+	const ssh = /^git@([^:]+):(.+)$/.exec(url);
+	if (ssh !== null && ssh[1] !== void 0 && ssh[2] !== void 0) return `https://${ssh[1]}/${ssh[2].replace(/\.git$/, "")}`;
+	return url.replace(/^git\+/, "").replace(/\.git$/, "");
+}
+
+//#endregion
+//#region src/sources/readme.ts
+async function collectReadme(cwd) {
+	let markdown;
+	try {
+		markdown = await readFile(join(cwd, "README.md"), "utf8");
+	} catch {
+		return {};
+	}
+	const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const out = {};
+	const h1 = extractH1(markdown);
+	const tagline = extractTagline(markdown);
+	const snippet = extractFirstCodeFence(markdown);
+	const project = {};
+	if (h1 !== void 0) project.name = fact(h1, {
+		source: "readme",
+		ref: "README.md H1",
+		fetchedAt
+	});
+	if (tagline !== void 0) project.tagline = fact(tagline, {
+		source: "readme",
+		ref: "README.md first paragraph",
+		fetchedAt
+	});
+	if (project.name !== void 0 || project.tagline !== void 0) out.project = project;
+	if (snippet !== void 0) out.release = { codeSnippet: fact(snippet, {
+		source: "readme",
+		ref: "README.md first fenced code block",
+		fetchedAt
+	}) };
+	return out;
+}
+async function collectConfiguredSnippet(cwd, spec) {
+	const parsed = parseSnippetSpec(spec);
+	if (parsed === void 0) return {};
+	let contents;
+	try {
+		contents = await readFile(join(cwd, parsed.path), "utf8");
+	} catch {
+		return {};
+	}
+	const slice = contents.split(/\r?\n/).slice(parsed.start - 1, parsed.end).join("\n");
+	const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+	return { release: { codeSnippet: fact({
+		code: slice,
+		lang: langFromPath(parsed.path)
+	}, {
+		source: "user-config",
+		ref: spec,
+		fetchedAt
+	}) } };
+}
+/**
+* Strip fenced code and HTML before reading prose out of a README.
+*
+* Skipping blocks that merely *start* with a fence is not enough. A `#` comment inside a YAML
+* example reads as a markdown H1, and a blank line inside a fence makes its body look like a
+* paragraph. Shipseal's own README hit both: the detected name became
+* ".github/workflows/shipseal.yml" and the tagline became a chunk of workflow YAML.
+*/
+function stripNonProse(markdown) {
+	return markdown.replace(/```[\s\S]*?```/g, "").replace(/~~~[\s\S]*?~~~/g, "").replace(/<[^>]+>/g, "");
+}
+function extractH1(markdown) {
+	const heading = /^#\s+(.+)$/m.exec(stripNonProse(markdown))?.[1];
+	if (heading === void 0) return;
+	return heading.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").trim();
+}
+function extractTagline(markdown) {
+	const prose = stripNonProse(markdown);
+	const h1 = /^#\s+.+$/m.exec(prose);
+	const start = h1 === null ? 0 : (h1.index ?? 0) + h1[0].length;
+	for (const block of prose.slice(start).split(/\n\s*\n/)) {
+		const cleaned = stripBadges(block).trim();
+		if (cleaned.length >= 20 && !cleaned.startsWith("#") && !cleaned.startsWith("```")) return cleaned;
+	}
+}
+function extractFirstCodeFence(markdown) {
+	const match = /```([a-zA-Z0-9+-]+)\n([\s\S]*?)```/.exec(markdown);
+	if (match === null || match[1] === void 0 || match[2] === void 0) return;
+	return {
+		lang: match[1],
+		code: match[2].replace(/\n$/, "")
+	};
+}
+function parseSnippetSpec(spec) {
+	const match = /^(?<path>.+)#L(?<start>\d+)(?:-L(?<end>\d+))?$/.exec(spec);
+	if (match === null || match.groups === void 0) return;
+	const path = match.groups.path;
+	const start = Number.parseInt(match.groups.start ?? "0", 10);
+	const end = Number.parseInt(match.groups.end ?? match.groups.start ?? "0", 10);
+	if (path === void 0 || start < 1 || end < start) return;
+	return {
+		path,
+		start,
+		end
+	};
+}
+function langFromPath(path) {
+	const ext = extname(path).replace(".", "");
+	if (ext === "ts") return "ts";
+	if (ext === "tsx") return "tsx";
+	if (ext === "js" || ext === "mjs" || ext === "cjs") return "js";
+	if (ext === "jsx") return "jsx";
+	return ext.length > 0 ? ext : "text";
+}
+function stripBadges(text) {
+	return text.replace(/\[!\[[^\]]*]\([^)]+\)]\([^)]+\)/g, "").replace(/!\[[^\]]*]\([^)]+\)/g, "").replace(/<img[^>]*>/gi, "").replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+}
+
+//#endregion
+//#region src/sources/collect.ts
+async function collectFacts(options) {
+	const pkg = await collectPackageJson(options.cwd, options.packagePath ?? "package.json");
+	const tag = options.event.kind === "release" ? options.event.tag : void 0;
+	const previousTag = options.event.kind === "release" ? options.event.previousTag : void 0;
+	const gitEvent = {};
+	if (tag !== void 0) gitEvent.tag = tag;
+	if (previousTag !== void 0) gitEvent.previousTag = previousTag;
+	const git = await collectGit(options.cwd, gitEvent);
+	const version = git.release?.version?.value ?? pkg.release?.version?.value ?? (tag === void 0 ? void 0 : versionFromTag(tag));
+	const changelog = await collectBestChangelog(options.cwd, version, options.changelogPath ?? "CHANGELOG.md", options.packagePath);
+	const readme = await collectReadme(options.cwd);
+	const parts = [
+		pkg,
+		git,
+		readme,
+		changelog,
+		options.snippet !== void 0 && options.snippet !== null && options.snippet.length > 0 ? await collectConfiguredSnippet(options.cwd, options.snippet) : {}
+	];
+	if (options.event.kind === "bench") parts.push(await collectBenchFile(options.cwd, options.benchFile ?? ".shipseal/bench.json"));
+	if (options.skipNetwork !== true) {
+		const repo = pkg.project?.repo?.value ?? gitRepoFromParts(pkg, readme);
+		if (repo !== void 0) {
+			const githubOpts = { repo };
+			const githubTag = git.release?.tag?.value ?? tag;
+			if (githubTag !== void 0) githubOpts.tag = githubTag;
+			if (options.githubToken !== void 0) githubOpts.token = options.githubToken;
+			if (options.fetchImpl !== void 0) githubOpts.fetchImpl = options.fetchImpl;
+			const github = await collectGithub(githubOpts);
+			const githubWithoutFeatures = {};
+			if (github.project !== void 0) githubWithoutFeatures.project = github.project;
+			if (github.metrics !== void 0) githubWithoutFeatures.metrics = github.metrics;
+			parts.push(githubWithoutFeatures);
+			const mergedPreview = mergeFacts(parts);
+			if (options.event.kind === "release" && (mergedPreview.release?.features.length ?? 0) === 0 && github.release?.features !== void 0 && github.release.features.length > 0) parts.push({ release: { features: github.release.features } });
+		}
+		const npmPackage = pkg.project?.npmPackage?.value;
+		if (npmPackage !== void 0) {
+			const npmOpts = { npmPackage };
+			if (options.fetchImpl !== void 0) npmOpts.fetchImpl = options.fetchImpl;
+			parts.push(await collectNpm(npmOpts));
+		}
+	}
+	const facts = mergeFacts(parts);
+	if (options.event.kind === "release" && facts.release === void 0) throw new ShipsealError("facts.missing-release", "Could not collect release facts.", "Create a git tag, pass --tag, or add a matching version section to CHANGELOG.md.");
+	return facts;
+}
+async function collectBestChangelog(cwd, version, changelogPath, packagePath) {
+	const paths = [changelogPath];
+	if (packagePath !== void 0) {
+		const sibling = join(dirname(packagePath), "CHANGELOG.md");
+		if (!paths.includes(sibling)) paths.push(sibling);
+	}
+	return (await Promise.all(paths.map((path) => collectChangelog(cwd, version, path)))).find((facts) => changelogHasNotes(facts)) ?? {};
+}
+function changelogHasNotes(facts) {
+	const release = facts.release;
+	if (release === void 0) return false;
+	return (release.features?.length ?? 0) > 0 || (release.fixes?.length ?? 0) > 0 || (release.breaking?.length ?? 0) > 0;
+}
+function gitRepoFromParts(pkg, readme) {
+	return pkg.project?.repo?.value ?? pkg.project?.url?.value ?? readme.project?.url?.value;
+}
+
+//#endregion
+//#region src/render/takumi.ts
+const GEIST_MONO_FAMILY = "Geist Mono";
+const FONT_REL = join("assets", "fonts", "GeistMono[wght].ttf");
+async function createTakumiRenderer() {
+	const renderer = new Renderer();
+	const fontPath = join(resolvePackageRoot(), FONT_REL);
+	const data = await readFile(fontPath);
+	await renderer.registerFont({
+		name: GEIST_MONO_FAMILY,
+		data,
+		generic: "monospace"
+	});
+	return new TakumiRenderer(renderer);
+}
+function resolvePackageRoot(from = import.meta.url) {
+	let dir = dirname(fileURLToPath(from));
+	for (;;) {
+		if (existsSync(join(dir, "package.json")) && existsSync(join(dir, FONT_REL))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) throw new ShipsealError("render.font-missing", `Could not find vendored font ${FONT_REL}.`, "Reinstall shipseal so assets/fonts/GeistMono[wght].ttf is present next to package.json.");
+		dir = parent;
+	}
+}
+function countLines(node) {
+	const ys = /* @__PURE__ */ new Set();
+	const walk = (current) => {
+		for (const run of current.runs) ys.add(Math.round(run.y));
+		for (const child of current.children) walk(child);
+	};
+	walk(node);
+	return ys.size;
+}
+function testCardNode() {
+	return container({
+		style: {
+			width: "100%",
+			height: "100%",
+			display: "flex",
+			flexDirection: "column",
+			justifyContent: "center",
+			padding: 64,
+			backgroundColor: "#0b0b0c"
+		},
+		children: [text("Shipseal", {
+			fontFamily: "Geist",
+			fontSize: 72,
+			fontWeight: 700,
+			color: "#fafafa"
+		}), text("Every release, sealed and ready to share", {
+			fontFamily: GEIST_MONO_FAMILY,
+			fontSize: 28,
+			fontWeight: 400,
+			color: "#a1a1aa"
+		})]
+	});
+}
+var TakumiRenderer = class {
+	renderer;
+	constructor(renderer) {
+		this.renderer = renderer;
+	}
+	async fromJsx(element) {
+		const result = await fromJsx(asReactElementLike(element));
+		return pack(result.node, result.css);
+	}
+	async render(node, opts) {
+		const packed = unpack(node);
+		const extras = { css: opts.css ?? packed.css };
+		if (opts.images !== void 0) extras.images = opts.images;
+		const buffer = await renderWithFormat(this.renderer, packed.node, opts, extras);
+		return Uint8Array.from(buffer);
+	}
+	async measure(node, opts) {
+		const packed = unpack(node);
+		const measured = await this.renderer.measure(packed.node, measureOpts(opts));
+		return {
+			lines: countLines(measured),
+			width: measured.width,
+			height: measured.height
+		};
+	}
+	async measureText(value, opts) {
+		const measured = await this.renderer.measure(asNode(textMeasureNode(value, opts)));
+		return {
+			lines: countLines(measured),
+			width: measured.width,
+			height: measured.height
+		};
+	}
+};
+function renderWithFormat(renderer, node, opts, extras) {
+	const width = opts.width;
+	const height = opts.height;
+	const css = extras.css;
+	const images = extras.images;
+	if (opts.format === "webp") {
+		if (images !== void 0) return renderer.render(node, {
+			width,
+			height,
+			format: "webp",
+			css,
+			images
+		});
+		return renderer.render(node, {
+			width,
+			height,
+			format: "webp",
+			css
+		});
+	}
+	if (opts.format === "jpeg") {
+		if (images !== void 0) return renderer.render(node, {
+			width,
+			height,
+			format: "jpeg",
+			css,
+			images
+		});
+		return renderer.render(node, {
+			width,
+			height,
+			format: "jpeg",
+			css
+		});
+	}
+	if (images !== void 0) return renderer.render(node, {
+		width,
+		height,
+		format: "png",
+		css,
+		images
+	});
+	return renderer.render(node, {
+		width,
+		height,
+		format: "png",
+		css
+	});
+}
+function measureOpts(opts) {
+	const out = {};
+	if (opts?.width !== void 0) out.width = opts.width;
+	if (opts?.height !== void 0) out.height = opts.height;
+	return out;
+}
+function textMeasureNode(value, opts) {
+	const style = {
+		fontFamily: opts.fontFamily,
+		fontSize: opts.fontSize,
+		lineHeight: opts.lineHeight,
+		whiteSpace: opts.whiteSpace ?? "normal",
+		maxWidth: opts.maxWidth
+	};
+	if (opts.fontWeight !== void 0) style.fontWeight = opts.fontWeight;
+	return text(value, style);
+}
+function asNode(node) {
+	return unpack(node).node;
+}
+function pack(node, css = []) {
+	return {
+		__shipseal: true,
+		node,
+		css
+	};
+}
+function unpack(node) {
+	if (isPacked(node)) return node;
+	if (isTakumiNode(node)) return {
+		__shipseal: true,
+		node,
+		css: []
+	};
+	throw new ShipsealError("render.invalid-node", "render/measure received a value that is not a Takumi node tree.", "Pass a node built by the renderer adapter (fromJsx, measureText, or testCardNode).");
+}
+function isPacked(node) {
+	return typeof node === "object" && node !== null && "__shipseal" in node;
+}
+function isTakumiNode(node) {
+	return typeof node === "object" && node !== null && "type" in node;
+}
+function asReactElementLike(element) {
+	if (typeof element !== "object" || element === null || !("type" in element)) throw new ShipsealError("render.invalid-jsx", "fromJsx received a value that is not a JSX element.", "Return JSX from a template render function.");
+	const record = element;
+	return {
+		type: "type" in record ? record.type : void 0,
+		props: "props" in record ? record.props : null,
+		key: "key" in record && typeof record.key === "string" ? record.key : null
+	};
+}
+
+//#endregion
+//#region src/copy/number-guard.ts
+function allowedNumbers(facts) {
+	const allowed = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (typeof value === "number" && Number.isFinite(value)) {
+			addNumber(allowed, value);
+			return;
+		}
+		if (typeof value === "string") {
+			for (const match of value.match(/\d+(?:\.\d+)*/g) ?? []) allowed.add(match);
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const item of value) visit(item);
+			return;
+		}
+		if (typeof value === "object" && value !== null) {
+			if ("value" in value && "provenance" in value) {
+				visit(value.value);
+				return;
+			}
+			for (const nested of Object.values(value)) visit(nested);
+		}
+	};
+	visit(facts);
+	return allowed;
+}
+function unsourcedDigits(text, allowed) {
+	const found = [];
+	const withoutGrouped = text.replace(/\d{1,3}(?:,\d{3})+/g, (match) => {
+		const compact = match.replaceAll(",", "");
+		if (!allowed.has(match) && !allowed.has(compact)) found.push(match);
+		return " ";
+	});
+	for (const match of withoutGrouped.match(/\d+(?:\.\d+)*/g) ?? []) if (!allowed.has(match)) found.push(match);
+	return found;
+}
+function guardCopy(copy, facts) {
+	const allowed = allowedNumbers(facts);
+	const slots = [
+		["headline", copy.headline],
+		["subheadline", copy.subheadline],
+		["cta", copy.cta]
+	];
+	if (copy.milestoneLine !== void 0) slots.push(["milestoneLine", copy.milestoneLine]);
+	copy.highlights.forEach((line, index) => {
+		slots.push([`highlights[${String(index)}]`, line]);
+	});
+	for (const [slot, text] of slots) {
+		const digits = unsourcedDigits(text, allowed);
+		if (digits.length > 0) return {
+			ok: false,
+			slot,
+			digits
+		};
+	}
+	return { ok: true };
+}
+function addNumber(allowed, value) {
+	allowed.add(String(value));
+	if (Number.isInteger(value)) allowed.add(value.toLocaleString("en-US"));
+}
+
+//#endregion
+//#region src/copy/llm.ts
+const llmCopySchema = z.object({
+	headline: z.string(),
+	subheadline: z.string(),
+	highlights: z.array(z.string()).max(4),
+	cta: z.string()
+});
+async function llmCopy(facts, options, fallback = deterministicCopy(facts)) {
+	const payload = factsForLlm(facts);
+	let lastError;
+	const retries = Math.max(0, options.maxRetries);
+	for (let attempt = 0; attempt <= retries; attempt += 1) {
+		let parsed;
+		try {
+			const raw = await requestCopy(payload, options);
+			parsed = llmCopySchema.parse(JSON.parse(raw));
+		} catch (error) {
+			lastError = error instanceof Error ? error.message : "LLM request failed";
+			continue;
+		}
+		const expanded = expandPlaceholders(parsed, facts);
+		const styled = {
+			headline: stripStyle(expanded.headline).slice(0, COPY_LIMITS.headline),
+			subheadline: stripStyle(expanded.subheadline).slice(0, COPY_LIMITS.subheadline),
+			highlights: expanded.highlights.map((line) => stripStyle(line).slice(0, COPY_LIMITS.highlight)),
+			cta: stripStyle(expanded.cta).slice(0, COPY_LIMITS.cta)
+		};
+		const guarded = guardCopy(styled, facts);
+		if (!guarded.ok) {
+			lastError = `Number guard rejected ${guarded.slot}: ${guarded.digits.join(", ")}`;
+			continue;
+		}
+		return {
+			copy: styled,
+			mode: "llm"
+		};
+	}
+	return {
+		copy: fallback,
+		mode: "deterministic",
+		warning: lastError ?? "LLM copy failed; using deterministic copy"
+	};
+}
+function factsForLlm(facts) {
+	return {
+		project: {
+			name: facts.project.name.value,
+			tagline: facts.project.tagline?.value,
+			npmPackage: facts.project.npmPackage?.value,
+			url: facts.project.url?.value
+		},
+		release: facts.release === void 0 ? void 0 : {
+			version: "{version}",
+			features: facts.release.features.map((item) => item.value),
+			fixes: facts.release.fixes.map((item) => item.value),
+			breaking: facts.release.breaking.map((item) => item.value)
+		},
+		metrics: {
+			stars: facts.metrics?.stars === void 0 ? void 0 : "{stars}",
+			weeklyDownloads: facts.metrics?.weeklyDownloads === void 0 ? void 0 : "{weeklyDownloads}",
+			contributorCount: facts.metrics?.contributorCount === void 0 ? void 0 : "{contributorCount}"
+		}
+	};
+}
+function expandPlaceholders(copy, facts) {
+	const map = {
+		"{version}": facts.release?.version.value ?? "",
+		"{stars}": facts.metrics?.stars === void 0 ? "" : formatCount(facts.metrics.stars.value),
+		"{weeklyDownloads}": facts.metrics?.weeklyDownloads === void 0 ? "" : formatCount(facts.metrics.weeklyDownloads.value),
+		"{contributorCount}": facts.metrics?.contributorCount === void 0 ? "" : formatCount(facts.metrics.contributorCount.value)
+	};
+	const expand = (text) => {
+		let out = text;
+		for (const [token, value] of Object.entries(map)) out = out.replaceAll(token, value);
+		return out;
+	};
+	return {
+		headline: expand(copy.headline),
+		subheadline: expand(copy.subheadline),
+		highlights: copy.highlights.map(expand),
+		cta: expand(copy.cta)
+	};
+}
+function stripStyle(text) {
+	return text.replaceAll("—", ":").replaceAll("–", "-").replaceAll("!", ".");
+}
+function formatCount(value) {
+	return value.toLocaleString("en-US");
+}
+async function requestCopy(facts, options) {
+	const base = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+	const response = await (options.fetchImpl ?? fetch)(`${base}/chat/completions`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${options.apiKey}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({
+			model: options.model,
+			response_format: { type: "json_object" },
+			messages: [{
+				role: "system",
+				content: "Write short release-card copy as JSON with keys headline, subheadline, highlights, cta. No em dashes, no exclamation marks. Use placeholders like {version} for numbers. Never invent numbers."
+			}, {
+				role: "user",
+				content: JSON.stringify(facts)
+			}]
+		})
+	});
+	if (!response.ok) throw new ShipsealError("copy.llm-http", `LLM provider returned HTTP ${String(response.status)}.`, "Check SHIPSEAL_LLM_API_KEY, copy.model, and SHIPSEAL_LLM_BASE_URL.");
+	const json = await response.json();
+	const first = z.object({ choices: z.array(z.object({ message: z.object({ content: z.string() }) })).min(1) }).parse(json).choices[0];
+	if (first === void 0) throw new ShipsealError("copy.llm-empty", "LLM returned no choices.", "Retry, or run with --no-copy.");
+	return first.message.content;
+}
+
+//#endregion
+//#region src/outputs/manifest.ts
+function buildManifest(input) {
+	return {
+		shipseal: input.shipsealVersion,
+		event: input.event,
+		generatedAt: input.result.generatedAt,
+		brand: {
+			name: input.brand.name,
+			theme: input.brand.theme,
+			source: ".shipseal/brand.json"
+		},
+		copy: { mode: input.result.copyMode },
+		files: input.result.files.map((file) => ({
+			path: file.fileName,
+			template: file.template,
+			format: file.format,
+			width: file.width,
+			height: file.height,
+			bytes: file.bytes.byteLength,
+			sha256: file.sha256
+		})),
+		facts: flattenFacts(input.result.facts),
+		computed: input.result.computed,
+		warnings: input.result.warnings,
+		missing: input.result.missing
+	};
+}
+function flattenFacts(facts) {
+	const out = {};
+	const walk = (prefix, value) => {
+		if (isFact(value)) {
+			out[prefix] = {
+				value: value.value,
+				source: value.provenance.source,
+				ref: value.provenance.ref,
+				fetchedAt: value.provenance.fetchedAt
+			};
+			return;
+		}
+		if (Array.isArray(value)) {
+			value.forEach((item, index) => {
+				walk(`${prefix}[${String(index)}]`, item);
+			});
+			return;
+		}
+		if (typeof value === "object" && value !== null) for (const [key, nested] of Object.entries(value)) walk(prefix.length === 0 ? key : `${prefix}.${key}`, nested);
+	};
+	walk("project", facts.project);
+	if (facts.release !== void 0) walk("release", facts.release);
+	if (facts.metrics !== void 0) walk("metrics", facts.metrics);
+	if (facts.bench !== void 0) walk("bench", facts.bench);
+	if (facts.milestone !== void 0) walk("milestone", facts.milestone);
+	return out;
+}
+function isFact(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("value" in value) || !("provenance" in value)) return false;
+	const provenance = value.provenance;
+	return typeof provenance === "object" && provenance !== null && "source" in provenance && "ref" in provenance && "fetchedAt" in provenance;
+}
+
+//#endregion
+//#region src/outputs/files.ts
+async function writePack(input) {
+	const dir = join(input.outDir, input.eventId);
+	await mkdir(dir, { recursive: true });
+	await Promise.all(input.result.files.map((file) => writeFile(join(dir, file.fileName), file.bytes)));
+	const manifest = buildManifest({
+		result: input.result,
+		event: input.event,
+		brand: input.brand,
+		shipsealVersion: input.shipsealVersion
+	});
+	await writeFile(join(dir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+	return {
+		dir,
+		manifest
+	};
+}
+function resolveOutputDir(cwd, configured) {
+	return isAbsolute(configured) ? configured : join(cwd, configured);
+}
+function eventId(event, generatedAt = "") {
+	if (event.kind === "release") return event.tag;
+	if (event.kind === "milestone") return `milestone-${event.metric}-${String(event.threshold)}`;
+	const day = generatedAt.slice(0, 10);
+	return /^\d{4}-\d{2}-\d{2}$/.test(day) ? `bench-${day}` : "bench";
+}
+
+//#endregion
+//#region src/outputs/github-release.ts
+const execFileAsync$2 = promisify(execFile);
+async function uploadReleaseAssets(options) {
+	if (options.files.length === 0) return;
+	const exec = options.exec ?? execFileAsync$2;
+	const args = [
+		"release",
+		"upload",
+		options.tag,
+		...options.files,
+		"--clobber"
+	];
+	if (options.repo !== void 0) args.push("--repo", options.repo);
+	const env = { ...process.env };
+	if (options.token !== void 0) {
+		env.GH_TOKEN = options.token;
+		env.GITHUB_TOKEN = options.token;
+	}
+	try {
+		await exec("gh", args, { env });
+	} catch (error) {
+		throw new ShipsealError("github.upload", `Could not upload assets to GitHub release ${options.tag}.`, "Confirm gh is installed, GITHUB_TOKEN can write contents, and the release exists.", { cause: error });
+	}
+}
+async function appendJobSummary(path, manifest, dir) {
+	await appendFile(path, `${jobSummaryMarkdown(manifest, dir)}\n`, "utf8");
+}
+function jobSummaryMarkdown(manifest, dir) {
+	const lines = [
+		"## Shipseal",
+		"",
+		`Generated **${String(manifest.files.length)}** files in \`${dir}\`.`,
+		""
+	];
+	const repo = process.env.GITHUB_REPOSITORY;
+	const tag = manifest.event.kind === "release" ? manifest.event.tag : void 0;
+	if (repo !== void 0 && tag !== void 0) for (const file of manifest.files) {
+		const url = `https://github.com/${repo}/releases/download/${tag}/${file.path}`;
+		lines.push(`![${file.path}](${url})`, "");
+	}
+	else {
+		lines.push("| File | Template | Format |", "|---|---|---|");
+		for (const file of manifest.files) lines.push(`| ${file.path} | ${file.template} | ${file.format} |`);
+		lines.push("");
+	}
+	lines.push("### Facts", "");
+	for (const [key, entry] of Object.entries(manifest.facts)) lines.push(`- \`${key}\`: ${JSON.stringify(entry.value)} (${entry.source})`);
+	if (Object.keys(manifest.computed).length > 0) {
+		lines.push("", "### Computed", "");
+		for (const [key, entry] of Object.entries(manifest.computed)) lines.push(`- \`${key}\`: ${JSON.stringify(entry.value)}`);
+	}
+	if (manifest.warnings.length > 0) {
+		lines.push("", "### Warnings", "");
+		for (const warning of manifest.warnings) lines.push(`- ${warning.template} ${warning.format} ${warning.slot}: ${warning.action}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/commands/shared.ts
+function overlayFormats(config, flags) {
+	const overlay = { ...config };
+	if (flags.formats !== void 0) overlay.formats = parseFormats(flags.formats);
+	if (flags.out !== void 0) overlay.outputDir = flags.out;
+	return mergeConfig(DEFAULT_CONFIG, overlay);
+}
+function parseFormats(list) {
+	const formats = [];
+	for (const part of list.split(",")) {
+		const id = part.trim();
+		if (id.length === 0) continue;
+		const match = FORMAT_IDS.find((format) => format === id);
+		if (match === void 0) throw new ShipsealError("release.bad-format", `Unknown format "${id}".`, `Use a comma-separated list from: ${FORMAT_IDS.join(", ")}.`);
+		formats.push(match);
+	}
+	return formats;
+}
+function resolveThemes(flag, brandTheme) {
+	if (flag === "both") return ["dark", "light"];
+	if (flag === "dark" || flag === "light") return [flag];
+	return [brandTheme];
+}
+async function resolveCopy(facts, config, noCopy, fallback) {
+	if (noCopy || config.copy?.llm !== true) return {
+		copy: fallback,
+		copyMode: "deterministic"
+	};
+	const apiKey = process.env.SHIPSEAL_LLM_API_KEY;
+	if (apiKey === void 0 || apiKey.length === 0) throw new ShipsealError("copy.missing-key", "copy.llm is enabled but SHIPSEAL_LLM_API_KEY is not set.", "Set SHIPSEAL_LLM_API_KEY, or pass --no-copy for deterministic copy.");
+	const llmOpts = {
+		apiKey,
+		model: config.copy.model ?? "gpt-4o-mini",
+		maxRetries: config.copy.maxRetries ?? 2
+	};
+	if (process.env.SHIPSEAL_LLM_BASE_URL !== void 0) llmOpts.baseUrl = process.env.SHIPSEAL_LLM_BASE_URL;
+	const result = await llmCopy(facts, llmOpts, fallback);
+	const out = {
+		copy: result.copy,
+		copyMode: result.mode
+	};
+	if (result.warning !== void 0) out.warning = result.warning;
+	return out;
+}
+async function loadLogos(cwd, brand) {
+	if (brand.logo === void 0) return;
+	const logos = { light: await readLogo(cwd, brand.logo.light) };
+	if (brand.logo.dark !== void 0) logos.dark = await readLogo(cwd, brand.logo.dark);
+	return logos;
+}
+async function readLogo(cwd, path) {
+	const resolved = isAbsolute(path) ? path : join(cwd, path);
+	return new Uint8Array(await readFile(resolved));
+}
+function readShipsealVersion() {
+	const raw = JSON.parse(readFileSync(join(resolvePackageRoot(), "package.json"), "utf8"));
+	if (typeof raw === "object" && raw !== null && "version" in raw && typeof raw.version === "string") return raw.version;
+	return "0.0.0";
+}
+function collectEnv(flags) {
+	const out = { skipNetwork: flags.dryRun === true && process.env.GITHUB_TOKEN === void 0 };
+	if (process.env.GITHUB_TOKEN !== void 0) out.githubToken = process.env.GITHUB_TOKEN;
+	if (flags.package !== void 0) out.packagePath = flags.package;
+	if (flags.fetchImpl !== void 0) out.fetchImpl = flags.fetchImpl;
+	return out;
+}
+async function finishPack(input) {
+	const generatedAt = input.result.generatedAt;
+	const written = await writePack({
+		outDir: resolveOutputDir(input.flags.cwd, input.flags.out ?? input.config.outputDir ?? ".shipseal/output"),
+		eventId: eventId(input.event, generatedAt),
+		result: input.result,
+		event: input.event,
+		brand: input.brand,
+		shipsealVersion: readShipsealVersion()
+	});
+	if (input.flags.upload === true && input.event.kind === "release") {
+		const files = input.result.files.map((file) => join(written.dir, file.fileName));
+		const uploadOpts = {
+			tag: input.event.tag,
+			files
+		};
+		if (process.env.GITHUB_REPOSITORY !== void 0) uploadOpts.repo = process.env.GITHUB_REPOSITORY;
+		if (process.env.GITHUB_TOKEN !== void 0) uploadOpts.token = process.env.GITHUB_TOKEN;
+		await uploadReleaseAssets(uploadOpts);
+	}
+	const summaryPath = process.env.GITHUB_STEP_SUMMARY;
+	if (summaryPath !== void 0 && summaryPath.length > 0) await appendJobSummary(summaryPath, written.manifest, written.dir);
+	const exitCode = input.flags.strict === true && input.result.warnings.length > 0 ? 2 : 0;
+	const done = {
+		dryRun: false,
+		facts: input.facts,
+		copy: input.copy,
+		copyMode: input.copyMode,
+		dir: written.dir,
+		manifest: written.manifest,
+		warnings: input.result.warnings,
+		exitCode
+	};
+	if (input.copyWarning !== void 0) done.copyWarning = input.copyWarning;
+	return done;
+}
+
+//#endregion
+//#region src/commands/bench.ts
+async function runBench(flags) {
+	const cwd = flags.cwd;
+	const config = overlayFormats(await loadConfig(cwd), flags);
+	const brand = await loadBrand(cwd);
+	const file = flags.file ?? config.bench?.file ?? ".shipseal/bench.json";
+	const event = {
+		kind: "bench",
+		file
+	};
+	const env = collectEnv(flags);
+	const collectOpts = {
+		cwd,
+		event,
+		skipNetwork: true,
+		benchFile: file
+	};
+	if (env.packagePath !== void 0) collectOpts.packagePath = env.packagePath;
+	const facts = await collectFacts(collectOpts);
+	const resolved = await resolveCopy(facts, config, flags.copy === false, benchCopy(facts));
+	if (flags.dryRun === true) {
+		const dry = {
+			dryRun: true,
+			facts,
+			copy: resolved.copy,
+			copyMode: resolved.copyMode,
+			warnings: [],
+			exitCode: 0
+		};
+		if (resolved.warning !== void 0) dry.copyWarning = resolved.warning;
+		return dry;
+	}
+	const renderer = await createTakumiRenderer();
+	const generateInput = {
+		event,
+		facts,
+		brand,
+		config,
+		copy: resolved.copy,
+		copyMode: resolved.copyMode,
+		renderer,
+		themes: resolveThemes(flags.themes, brand.theme),
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const logos = await loadLogos(cwd, brand);
+	if (logos !== void 0) generateInput.logos = logos;
+	const packInput = {
+		flags,
+		config,
+		event,
+		result: await generate(generateInput),
+		brand,
+		copy: resolved.copy,
+		copyMode: resolved.copyMode,
+		facts
+	};
+	if (resolved.warning !== void 0) packInput.copyWarning = resolved.warning;
+	return finishPack(packInput);
+}
+
+//#endregion
+//#region src/commands/doctor.ts
+const execFileAsync$1 = promisify(execFile);
+const MIN_NODE_MAJOR = 22;
+async function runDoctor(cwd) {
+	const checks = [];
+	checks.push(checkNode());
+	checks.push(await checkGit(cwd));
+	checks.push(await checkShallow(cwd));
+	checks.push(await checkBrand(cwd));
+	checks.push(await checkFont());
+	checks.push(await checkLogo(cwd));
+	checks.push(checkGithubToken());
+	checks.push(await checkRender());
+	return {
+		ok: checks.every((check) => check.status !== "fail"),
+		checks
+	};
+}
+function checkNode() {
+	const version = process.versions.node;
+	if (Number.parseInt(version.split(".")[0] ?? "0", 10) >= MIN_NODE_MAJOR) return {
+		name: "node",
+		status: "pass",
+		message: `Node.js ${version}`
+	};
+	return {
+		name: "node",
+		status: "fail",
+		message: `Node.js ${version} is below the minimum of ${MIN_NODE_MAJOR}.`,
+		fix: `Install Node.js ${MIN_NODE_MAJOR} or newer.`
+	};
+}
+async function checkGit(cwd) {
+	try {
+		const { stdout } = await execFileAsync$1("git", ["--version"], { cwd });
+		return {
+			name: "git",
+			status: "pass",
+			message: stdout.trim()
+		};
+	} catch {
+		return {
+			name: "git",
+			status: "fail",
+			message: "git is not available on PATH.",
+			fix: "Install git and ensure it is on PATH."
+		};
+	}
+}
+async function checkShallow(cwd) {
+	try {
+		const { stdout } = await execFileAsync$1("git", ["rev-parse", "--is-shallow-repository"], { cwd });
+		if (stdout.trim() === "true") return {
+			name: "clone-depth",
+			status: "fail",
+			message: "This git clone is shallow, so release facts will be incomplete.",
+			fix: "Re-clone with a full history, or in GitHub Actions set fetch-depth: 0."
+		};
+		return {
+			name: "clone-depth",
+			status: "pass",
+			message: "Full git history is available."
+		};
+	} catch {
+		return {
+			name: "clone-depth",
+			status: "info",
+			message: "Could not determine whether the clone is shallow."
+		};
+	}
+}
+async function checkBrand(cwd) {
+	const path = join(cwd, ".shipseal", "brand.json");
+	if (!existsSync(path)) return {
+		name: "brand.json",
+		status: "fail",
+		message: ".shipseal/brand.json is missing.",
+		fix: "Run shipseal init to detect a brand kit."
+	};
+	try {
+		const raw = JSON.parse(await readFile(path, "utf8"));
+		const parsed = brandSchema.safeParse(raw);
+		if (!parsed.success) return {
+			name: "brand.json",
+			status: "fail",
+			message: "brand.json did not match the v1 schema.",
+			fix: parsed.error.issues.map((issue) => issue.message).join("; ")
+		};
+		return {
+			name: "brand.json",
+			status: "pass",
+			message: `Brand ${parsed.data.name} is valid.`
+		};
+	} catch (error) {
+		if (error instanceof SyntaxError) return {
+			name: "brand.json",
+			status: "fail",
+			message: "brand.json is not valid JSON.",
+			fix: "Fix the JSON syntax, or re-run shipseal init --force."
+		};
+		throw error;
+	}
+}
+async function checkFont() {
+	try {
+		const root = resolvePackageRoot();
+		const fontPath = join(root, "assets", "fonts", "GeistMono[wght].ttf");
+		if (!existsSync(fontPath)) return {
+			name: "fonts",
+			status: "fail",
+			message: "Vendored Geist Mono file is missing.",
+			fix: "Reinstall shipseal so assets/fonts/GeistMono[wght].ttf is present."
+		};
+		return {
+			name: "fonts",
+			status: "pass",
+			message: `Geist Mono found at ${fontPath}`
+		};
+	} catch {
+		return {
+			name: "fonts",
+			status: "fail",
+			message: "Could not resolve the vendored Geist Mono font.",
+			fix: "Reinstall shipseal so assets/fonts/GeistMono[wght].ttf is present."
+		};
+	}
+}
+async function checkLogo(cwd) {
+	const path = join(cwd, ".shipseal", "brand.json");
+	if (!existsSync(path)) return {
+		name: "logo",
+		status: "info",
+		message: "Skipped; brand.json is missing."
+	};
+	const raw = JSON.parse(await readFile(path, "utf8"));
+	const parsed = brandSchema.safeParse(raw);
+	if (!parsed.success || parsed.data.logo === void 0) return {
+		name: "logo",
+		status: "info",
+		message: "No logo path in brand.json."
+	};
+	const light = join(cwd, parsed.data.logo.light);
+	if (!existsSync(light)) return {
+		name: "logo",
+		status: "fail",
+		message: `Logo file ${parsed.data.logo.light} is not readable.`,
+		fix: "Point brand.json logo.light at an existing SVG or PNG, or re-run init."
+	};
+	return {
+		name: "logo",
+		status: "pass",
+		message: `Logo readable at ${parsed.data.logo.light}`
+	};
+}
+function checkGithubToken() {
+	if (process.env.GITHUB_TOKEN !== void 0 && process.env.GITHUB_TOKEN.length > 0) return {
+		name: "GITHUB_TOKEN",
+		status: "info",
+		message: "GITHUB_TOKEN is set."
+	};
+	return {
+		name: "GITHUB_TOKEN",
+		status: "info",
+		message: "GITHUB_TOKEN is not set. Unauthenticated GitHub API calls have a low rate limit."
+	};
+}
+async function checkRender() {
+	try {
+		const png = await (await createTakumiRenderer()).render(testCardNode(), {
+			width: FORMATS.og.width,
+			height: FORMATS.og.height,
+			format: "png"
+		});
+		if (png.length < 8 || png[0] !== 137 || png[1] !== 80) return {
+			name: "takumi",
+			status: "fail",
+			message: "Takumi rendered bytes that are not a PNG.",
+			fix: "File an issue with the doctor output and your OS/arch."
+		};
+		return {
+			name: "takumi",
+			status: "pass",
+			message: `Rendered a ${FORMATS.og.width}x${FORMATS.og.height} test card (${png.length} bytes).`
+		};
+	} catch (error) {
+		return {
+			name: "takumi",
+			status: "fail",
+			message: error instanceof Error ? error.message : "Takumi failed to render a test card.",
+			fix: "Check that the native Takumi binary installed for this platform."
+		};
+	}
+}
+
+//#endregion
+//#region src/brand/color.ts
+const HEX = /^#([\da-f]{3}|[\da-f]{6}|[\da-f]{8})$/i;
+function parseCssColor(value) {
+	const trimmed = value.trim();
+	const hex = normalizeHex(trimmed);
+	if (hex !== void 0) return hex;
+	const oklch = parseOklch(trimmed);
+	if (oklch !== void 0) return oklchToHex(oklch.l, oklch.c, oklch.h);
+	const rgb = parseRgb(trimmed);
+	if (rgb !== void 0) return rgbToHex(rgb[0], rgb[1], rgb[2]);
+	const hsl = parseHsl(trimmed);
+	if (hsl !== void 0) return rgbToHex(...hslToRgb(hsl[0], hsl[1], hsl[2]));
+}
+function normalizeHex(value) {
+	const match = HEX.exec(value.trim());
+	if (match === null) return;
+	const raw = match[1];
+	if (raw === void 0) return;
+	if (raw.length === 3) return `#${raw[0]}${raw[0]}${raw[1]}${raw[1]}${raw[2]}${raw[2]}`.toLowerCase();
+	return `#${raw.slice(0, 6).toLowerCase()}`;
+}
+function oklchToHex(l, c, h) {
+	const hr = h * Math.PI / 180;
+	const a = c * Math.cos(hr);
+	const b = c * Math.sin(hr);
+	const coneL = l + .3963377774 * a + .2158037573 * b;
+	const coneM = l - .1055613458 * a - .0638541728 * b;
+	const coneS = l - .0894841775 * a - 1.291485548 * b;
+	const l3 = coneL * coneL * coneL;
+	const m3 = coneM * coneM * coneM;
+	const s3 = coneS * coneS * coneS;
+	const r = 4.0767416621 * l3 - 3.3077115913 * m3 + .2309699292 * s3;
+	const g = -1.2684380046 * l3 + 2.6097574011 * m3 - .3413193965 * s3;
+	const bLin = -.0041960863 * l3 - .7034186147 * m3 + 1.707614701 * s3;
+	return rgbToHex(srgbEncode(r) * 255, srgbEncode(g) * 255, srgbEncode(bLin) * 255);
+}
+function contrastRatio(hexA, hexB) {
+	const a = relativeLuminance(hexA);
+	const b = relativeLuminance(hexB);
+	const [hi, lo] = a > b ? [a, b] : [b, a];
+	return (hi + .05) / (lo + .05);
+}
+const LARGE_TEXT_CONTRAST = 3;
+function ensureForegroundContrast(background, foreground) {
+	if (contrastRatio(background, foreground) >= 3) return {
+		foreground,
+		adjusted: false
+	};
+	const light = "#fafafa";
+	const dark = "#0b0b0c";
+	return {
+		foreground: contrastRatio(background, light) >= contrastRatio(background, dark) ? light : dark,
+		adjusted: true
+	};
+}
+function readableOnBackground(background, candidate) {
+	return contrastRatio(background, candidate) >= 3;
+}
+function srgbEncode(channel) {
+	const abs = Math.abs(channel);
+	const encoded = abs <= .0031308 ? 12.92 * abs : 1.055 * abs ** (1 / 2.4) - .055;
+	return Math.sign(channel) * encoded;
+}
+function rgbToHex(r, g, b) {
+	return `#${toByte(r)}${toByte(g)}${toByte(b)}`;
+}
+function toByte(n) {
+	return Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0");
+}
+function relativeLuminance(hex) {
+	const rgb = hexToRgb(hex);
+	if (rgb === void 0) return 0;
+	const lin = rgb.map((channel) => {
+		const s = channel / 255;
+		return s <= .04045 ? s / 12.92 : ((s + .055) / 1.055) ** 2.4;
+	});
+	return .2126 * (lin[0] ?? 0) + .7152 * (lin[1] ?? 0) + .0722 * (lin[2] ?? 0);
+}
+function isNeutralHex(hex) {
+	const rgb = hexToRgb(hex);
+	if (rgb === void 0) return true;
+	return Math.max(rgb[0], rgb[1], rgb[2]) - Math.min(rgb[0], rgb[1], rgb[2]) < 16;
+}
+function hexToRgb(hex) {
+	const normalized = normalizeHex(hex);
+	if (normalized === void 0) return;
+	return [
+		Number.parseInt(normalized.slice(1, 3), 16),
+		Number.parseInt(normalized.slice(3, 5), 16),
+		Number.parseInt(normalized.slice(5, 7), 16)
+	];
+}
+function parseOklch(value) {
+	const match = /^oklch\(\s*([^/)]+?)(?:\s*\/\s*[^)]+)?\s*\)$/i.exec(value);
+	if (match === null) return;
+	const body = match[1];
+	if (body === void 0) return;
+	const parts = splitCssArgs(body);
+	if (parts.length < 3) return;
+	const l = parseLightness(parts[0] ?? "");
+	const c = parseNumber(parts[1] ?? "");
+	const h = parseHue(parts[2] ?? "");
+	if (l === void 0 || c === void 0 || h === void 0) return;
+	return {
+		l,
+		c,
+		h
+	};
+}
+function parseRgb(value) {
+	const match = /^rgba?\(\s*([^/)]+?)(?:\s*\/\s*[^)]+)?\s*\)$/i.exec(value);
+	if (match === null) return;
+	const parts = splitCssArgs(match[1] ?? "");
+	if (parts.length < 3) return;
+	const r = parseRgbChannel(parts[0] ?? "");
+	const g = parseRgbChannel(parts[1] ?? "");
+	const b = parseRgbChannel(parts[2] ?? "");
+	if (r === void 0 || g === void 0 || b === void 0) return;
+	return [
+		r,
+		g,
+		b
+	];
+}
+function parseHsl(value) {
+	const match = /^hsla?\(\s*([^/)]+?)(?:\s*\/\s*[^)]+)?\s*\)$/i.exec(value);
+	if (match === null) return;
+	const parts = splitCssArgs(match[1] ?? "");
+	if (parts.length < 3) return;
+	const h = parseHue(parts[0] ?? "");
+	const s = parsePercent(parts[1] ?? "");
+	const l = parsePercent(parts[2] ?? "");
+	if (h === void 0 || s === void 0 || l === void 0) return;
+	return [
+		h,
+		s,
+		l
+	];
+}
+function hslToRgb(h, s, l) {
+	const sat = s / 100;
+	const light = l / 100;
+	const c = (1 - Math.abs(2 * light - 1)) * sat;
+	const hp = (h % 360 + 360) % 360 / 60;
+	const x = c * (1 - Math.abs(hp % 2 - 1));
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	if (hp < 1) {
+		r = c;
+		g = x;
+	} else if (hp < 2) {
+		r = x;
+		g = c;
+	} else if (hp < 3) {
+		g = c;
+		b = x;
+	} else if (hp < 4) {
+		g = x;
+		b = c;
+	} else if (hp < 5) {
+		r = x;
+		b = c;
+	} else {
+		r = c;
+		b = x;
+	}
+	const m = light - c / 2;
+	return [
+		(r + m) * 255,
+		(g + m) * 255,
+		(b + m) * 255
+	];
+}
+function splitCssArgs(body) {
+	return body.split(/[\s,]+/).map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function parseLightness(token) {
+	if (token.endsWith("%")) {
+		const n = Number.parseFloat(token.slice(0, -1));
+		return Number.isFinite(n) ? n / 100 : void 0;
+	}
+	return parseNumber(token);
+}
+function parseHue(token) {
+	if (token === "none") return 0;
+	if (token.endsWith("deg")) return parseNumber(token.slice(0, -3));
+	if (token.endsWith("rad")) {
+		const n = parseNumber(token.slice(0, -3));
+		return n === void 0 ? void 0 : n * 180 / Math.PI;
+	}
+	if (token.endsWith("turn")) {
+		const n = parseNumber(token.slice(0, -4));
+		return n === void 0 ? void 0 : n * 360;
+	}
+	if (token.endsWith("grad")) {
+		const n = parseNumber(token.slice(0, -4));
+		return n === void 0 ? void 0 : n * .9;
+	}
+	return parseNumber(token);
+}
+function parsePercent(token) {
+	if (!token.endsWith("%")) return parseNumber(token);
+	return parseNumber(token.slice(0, -1));
+}
+function parseRgbChannel(token) {
+	if (token.endsWith("%")) {
+		const n = parseNumber(token.slice(0, -1));
+		return n === void 0 ? void 0 : n / 100 * 255;
+	}
+	return parseNumber(token);
+}
+function parseNumber(token) {
+	if (token === "none") return 0;
+	const n = Number.parseFloat(token);
+	return Number.isFinite(n) ? n : void 0;
+}
+
+//#endregion
+//#region src/brand/css-vars.ts
+const PROP = /--(primary|brand|accent|background|foreground|muted-foreground|muted)\s*:\s*([^;]+);/g;
+function extractCssRootColors(css) {
+	const fromRoot = extractBlockColors(css, /:root\s*\{/g);
+	const fromDark = extractBlockColors(css, /\.dark\s*\{/g);
+	return mapFoundColors({
+		...fromRoot,
+		...fromDark
+	});
+}
+function extractBlockColors(css, blockRe) {
+	const found = {};
+	blockRe.lastIndex = 0;
+	let match;
+	while ((match = blockRe.exec(css)) !== null) {
+		const open = css.indexOf("{", match.index);
+		if (open === -1) break;
+		const close = matchingBrace$1(css, open);
+		if (close === -1) break;
+		const body = css.slice(open + 1, close);
+		PROP.lastIndex = 0;
+		let prop;
+		while ((prop = PROP.exec(body)) !== null) {
+			const name = prop[1];
+			const raw = prop[2];
+			if (name === void 0 || raw === void 0) continue;
+			const hex = parseCssColor(raw.trim());
+			if (hex !== void 0) found[name] = hex;
+		}
+	}
+	return found;
+}
+function mapFoundColors(found) {
+	const out = {};
+	const background = found.background;
+	if (background !== void 0) out.background = background;
+	const foreground = found.foreground;
+	if (foreground !== void 0) out.foreground = foreground;
+	const muted = found["muted-foreground"] ?? found.muted;
+	if (muted !== void 0) out.muted = muted;
+	const primary = found.primary ?? found.brand;
+	if (primary !== void 0) out.primary = primary;
+	if (found.accent !== void 0) out.accent = found.accent;
+	return out;
+}
+function matchingBrace$1(source, openIndex) {
+	let depth = 0;
+	for (let i = openIndex; i < source.length; i += 1) {
+		const ch = source[i];
+		if (ch === "{") depth += 1;
+		else if (ch === "}") {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+
+//#endregion
+//#region src/brand/dtcg.ts
+function extractDtcgColors(tokens) {
+	const found = {};
+	walk(tokens, [], found);
+	const out = {};
+	const background = found.background ?? found.bg;
+	if (background !== void 0) out.background = background;
+	const foreground = found.foreground ?? found.fg;
+	if (foreground !== void 0) out.foreground = foreground;
+	if (found.muted !== void 0) out.muted = found.muted;
+	const primary = found.primary ?? found.brand;
+	if (primary !== void 0) out.primary = primary;
+	const accent = found.accent ?? found.secondary;
+	if (accent !== void 0) out.accent = accent;
+	return out;
+}
+function walk(node, path, found) {
+	if (!isRecord(node)) return;
+	if (node.$type === "color") {
+		const hex = colorValue(node.$value);
+		const leaf = path[path.length - 1];
+		if (hex !== void 0 && leaf !== void 0 && found[leaf] === void 0) found[leaf] = hex;
+		return;
+	}
+	for (const [key, value] of Object.entries(node)) {
+		if (key.startsWith("$")) continue;
+		walk(value, [...path, key], found);
+	}
+}
+function colorValue(value) {
+	if (typeof value === "string") return parseCssColor(value);
+	if (isRecord(value) && typeof value.hex === "string") return parseCssColor(value.hex);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/brand/logo.ts
+const DIRECTORIES = [
 	"",
-	"This release exists to reserve the package name. No commands are implemented.",
-	`Follow progress at https://shipseal.dev`,
-	""
-].join("\n"));
+	"assets",
+	"assets/brand",
+	"public",
+	"public/brand",
+	".github",
+	"docs",
+	"static",
+	"branding"
+];
+const ICON_NAMES = ["icon.svg", "icon.png"];
+const NAMES = [
+	"logo.svg",
+	"logo.png",
+	"logo-light.svg",
+	"logo-light.png"
+];
+const FALLBACKS = [...ICON_NAMES, "favicon.svg"];
+function findLogo(cwd) {
+	for (const dir of DIRECTORIES) for (const name of NAMES) {
+		const relative = dir === "" ? name : join(dir, name);
+		if (existsSync(join(cwd, relative))) return relative;
+	}
+	for (const dir of DIRECTORIES) for (const name of FALLBACKS) {
+		const relative = dir === "" ? name : join(dir, name);
+		if (existsSync(join(cwd, relative))) return relative;
+	}
+}
+function findLogoPair(cwd) {
+	const light = findLogo(cwd);
+	if (light === void 0) return;
+	const darkNames = ["logo-dark.svg", "logo-dark.png"];
+	for (const dir of DIRECTORIES) for (const name of darkNames) {
+		const relative = dir === "" ? name : join(dir, name);
+		if (existsSync(join(cwd, relative))) return {
+			light,
+			dark: relative
+		};
+	}
+	return { light };
+}
+
+//#endregion
+//#region src/brand/png.ts
+const SIGNATURE = Buffer.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+/** Channels per pixel for each PNG colour type. Index is the colour type. */
+const CHANNELS = {
+	0: 1,
+	2: 3,
+	3: 1,
+	4: 2,
+	6: 4
+};
+function decodePng(buffer) {
+	if (buffer.length < 8 || !buffer.subarray(0, 8).equals(SIGNATURE)) return;
+	let width = 0;
+	let height = 0;
+	let bitDepth = 0;
+	let colorType = 0;
+	let interlace = 0;
+	let palette;
+	let paletteAlpha;
+	const idat = [];
+	let offset = 8;
+	while (offset + 8 <= buffer.length) {
+		const length = buffer.readUInt32BE(offset);
+		const type = buffer.toString("ascii", offset + 4, offset + 8);
+		const start = offset + 8;
+		const end = start + length;
+		if (end > buffer.length) return;
+		if (type === "IHDR") {
+			width = buffer.readUInt32BE(start);
+			height = buffer.readUInt32BE(start + 4);
+			bitDepth = buffer[start + 8] ?? 0;
+			colorType = buffer[start + 9] ?? 0;
+			interlace = buffer[start + 12] ?? 0;
+		} else if (type === "PLTE") palette = buffer.subarray(start, end);
+		else if (type === "tRNS") paletteAlpha = buffer.subarray(start, end);
+		else if (type === "IDAT") idat.push(buffer.subarray(start, end));
+		else if (type === "IEND") break;
+		offset = end + 4;
+	}
+	const channels = CHANNELS[colorType];
+	if (width === 0 || height === 0 || channels === void 0 || interlace !== 0 || bitDepth !== 8 && bitDepth !== 16 || idat.length === 0 || colorType === 3 && palette === void 0) return;
+	if (width * height > 64e6) return;
+	let raw;
+	try {
+		raw = inflateSync(Buffer.concat(idat));
+	} catch {
+		return;
+	}
+	const bytesPerSample = bitDepth / 8;
+	const bpp = channels * bytesPerSample;
+	const stride = width * bpp;
+	if (raw.length < height * (stride + 1)) return;
+	const unfiltered = unfilter(raw, height, stride, bpp);
+	if (unfiltered === void 0) return;
+	return {
+		width,
+		height,
+		pixels: toRgba(unfiltered, width, height, colorType, bytesPerSample, palette, paletteAlpha)
+	};
+}
+/** Reverse the per-scanline filters defined in the PNG spec. */
+function unfilter(raw, height, stride, bpp) {
+	const out = Buffer.alloc(height * stride);
+	let pos = 0;
+	for (let y = 0; y < height; y++) {
+		const filter = raw[pos];
+		pos += 1;
+		if (filter === void 0 || filter > 4) return;
+		const rowStart = y * stride;
+		const prevStart = rowStart - stride;
+		for (let x = 0; x < stride; x++) {
+			const value = raw[pos + x] ?? 0;
+			const a = x >= bpp ? out[rowStart + x - bpp] ?? 0 : 0;
+			const b = y > 0 ? out[prevStart + x] ?? 0 : 0;
+			const c = x >= bpp && y > 0 ? out[prevStart + x - bpp] ?? 0 : 0;
+			let restored;
+			switch (filter) {
+				case 1:
+					restored = value + a;
+					break;
+				case 2:
+					restored = value + b;
+					break;
+				case 3:
+					restored = value + Math.floor((a + b) / 2);
+					break;
+				case 4:
+					restored = value + paeth(a, b, c);
+					break;
+				default: restored = value;
+			}
+			out[rowStart + x] = restored & 255;
+		}
+		pos += stride;
+	}
+	return out;
+}
+function paeth(a, b, c) {
+	const p = a + b - c;
+	const pa = Math.abs(p - a);
+	const pb = Math.abs(p - b);
+	const pc = Math.abs(p - c);
+	if (pa <= pb && pa <= pc) return a;
+	return pb <= pc ? b : c;
+}
+function toRgba(data, width, height, colorType, bytesPerSample, palette, paletteAlpha) {
+	const pixels = new Uint8Array(width * height * 4);
+	const bpp = (CHANNELS[colorType] ?? 4) * bytesPerSample;
+	for (let i = 0; i < width * height; i++) {
+		const at = (channel) => data[i * bpp + channel * bytesPerSample] ?? 0;
+		const out = i * 4;
+		switch (colorType) {
+			case 0: {
+				const g = at(0);
+				pixels[out] = g;
+				pixels[out + 1] = g;
+				pixels[out + 2] = g;
+				pixels[out + 3] = 255;
+				break;
+			}
+			case 2:
+				pixels[out] = at(0);
+				pixels[out + 1] = at(1);
+				pixels[out + 2] = at(2);
+				pixels[out + 3] = 255;
+				break;
+			case 3: {
+				const index = at(0);
+				pixels[out] = palette?.[index * 3] ?? 0;
+				pixels[out + 1] = palette?.[index * 3 + 1] ?? 0;
+				pixels[out + 2] = palette?.[index * 3 + 2] ?? 0;
+				pixels[out + 3] = paletteAlpha?.[index] ?? 255;
+				break;
+			}
+			case 4: {
+				const g = at(0);
+				pixels[out] = g;
+				pixels[out + 1] = g;
+				pixels[out + 2] = g;
+				pixels[out + 3] = at(1);
+				break;
+			}
+			default:
+				pixels[out] = at(0);
+				pixels[out + 1] = at(1);
+				pixels[out + 2] = at(2);
+				pixels[out + 3] = at(3);
+		}
+	}
+	return pixels;
+}
+/**
+* Most common non-neutral colour in a logo, as a hex string.
+*
+* Nearly transparent pixels are ignored so a transparent background does not win, and greys
+* are ignored because a logo's black wordmark is not its brand colour. Colours are bucketed
+* into 16 levels per channel so anti-aliased edges group with the solid fill they belong to,
+* then the winning bucket reports the average of the real pixels inside it rather than the
+* bucket centre, which would drift the hue.
+*/
+function dominantNonNeutralColor(png) {
+	const buckets = /* @__PURE__ */ new Map();
+	for (let i = 0; i < png.pixels.length; i += 4) {
+		if ((png.pixels[i + 3] ?? 0) < 128) continue;
+		const r = png.pixels[i] ?? 0;
+		const g = png.pixels[i + 1] ?? 0;
+		const b = png.pixels[i + 2] ?? 0;
+		if (Math.max(r, g, b) - Math.min(r, g, b) < 16) continue;
+		const key = r >> 4 << 8 | g >> 4 << 4 | b >> 4;
+		const bucket = buckets.get(key);
+		if (bucket === void 0) buckets.set(key, {
+			count: 1,
+			r,
+			g,
+			b
+		});
+		else {
+			bucket.count += 1;
+			bucket.r += r;
+			bucket.g += g;
+			bucket.b += b;
+		}
+	}
+	let best;
+	for (const bucket of buckets.values()) if (best === void 0 || bucket.count > best.count) best = bucket;
+	if (best === void 0) return;
+	const channel = (total) => Math.round(total / best.count).toString(16).padStart(2, "0");
+	return `#${channel(best.r)}${channel(best.g)}${channel(best.b)}`;
+}
+
+//#endregion
+//#region src/brand/tailwind.ts
+const COLOR_PROP = /--color-([a-zA-Z0-9-]+)\s*:\s*([^;]+);/g;
+const CUSTOM_PROP = /--([a-zA-Z0-9-]+)\s*:\s*([^;]+);/g;
+const SKIP_PREFIXES = /* @__PURE__ */ new Set([
+	"chart",
+	"sidebar",
+	"ring",
+	"border",
+	"input",
+	"destructive"
+]);
+function extractTailwindV4Colors(css) {
+	const blocks = themeBlocks(css);
+	const custom = collectCustomProperties(css);
+	const fromTheme = {};
+	for (const block of blocks) {
+		COLOR_PROP.lastIndex = 0;
+		let match;
+		while ((match = COLOR_PROP.exec(block)) !== null) {
+			const name = match[1];
+			const raw = match[2];
+			if (name === void 0 || raw === void 0 || shouldSkip(name)) continue;
+			fromTheme[name] = raw.trim();
+		}
+	}
+	const resolved = {};
+	for (const [name, raw] of Object.entries(fromTheme)) {
+		const hex = resolveToHex(raw, custom, 0);
+		if (hex !== void 0) resolved[name] = hex;
+	}
+	return mapBrandColors(resolved);
+}
+function extractTailwindV3Colors(source) {
+	const found = {};
+	const re = /\b(primary|brand|accent|background|foreground|muted|secondary)\b\s*:\s*["'`]([^"'`]+)["'`]/g;
+	let match;
+	while ((match = re.exec(source)) !== null) {
+		const name = match[1];
+		const raw = match[2];
+		if (name === void 0 || raw === void 0) continue;
+		const hex = parseCssColor(raw);
+		if (hex !== void 0) found[name] = hex;
+	}
+	return mapBrandColors(found);
+}
+function themeBlocks(css) {
+	const blocks = [];
+	const re = /@theme(?:\s+inline)?\s*\{/g;
+	let match;
+	while ((match = re.exec(css)) !== null) {
+		const open = css.indexOf("{", match.index);
+		if (open === -1) break;
+		const close = matchingBrace(css, open);
+		if (close === -1) break;
+		blocks.push(css.slice(open + 1, close));
+	}
+	return blocks;
+}
+function matchingBrace(source, openIndex) {
+	let depth = 0;
+	for (let i = openIndex; i < source.length; i += 1) {
+		const ch = source[i];
+		if (ch === "{") depth += 1;
+		else if (ch === "}") {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+function collectCustomProperties(css) {
+	const props = /* @__PURE__ */ new Map();
+	CUSTOM_PROP.lastIndex = 0;
+	let match;
+	while ((match = CUSTOM_PROP.exec(css)) !== null) {
+		const name = match[1];
+		const value = match[2];
+		if (name !== void 0 && value !== void 0) props.set(`--${name}`, value.trim());
+	}
+	return props;
+}
+function resolveToHex(raw, custom, depth) {
+	if (depth > 3) return;
+	const direct = parseCssColor(raw);
+	if (direct !== void 0) return direct;
+	const varMatch = /^var\(\s*(--[a-zA-Z0-9-]+)\s*(?:,[^)]+)?\)$/.exec(raw);
+	if (varMatch === null) return;
+	const ref = varMatch[1];
+	if (ref === void 0) return;
+	const next = custom.get(ref);
+	if (next === void 0) return;
+	return resolveToHex(next, custom, depth + 1);
+}
+function shouldSkip(name) {
+	const root = name.split("-")[0];
+	return root !== void 0 && SKIP_PREFIXES.has(root);
+}
+function mapBrandColors(found) {
+	const out = {};
+	const background = found.background ?? found.bg;
+	if (background !== void 0) out.background = background;
+	const foreground = found.foreground ?? found.fg;
+	if (foreground !== void 0) out.foreground = foreground;
+	const muted = found["muted-foreground"] ?? found.muted;
+	if (muted !== void 0) out.muted = muted;
+	const primary = found.primary ?? found.brand;
+	if (primary !== void 0) out.primary = primary;
+	const accent = found.accent ?? found.secondary;
+	if (accent !== void 0) out.accent = accent;
+	return out;
+}
+
+//#endregion
+//#region src/brand/detect.ts
+const execFileAsync = promisify(execFile);
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"dist",
+	"coverage",
+	".shipseal",
+	".next",
+	"build"
+]);
+const packageSchema = z.object({
+	private: z.boolean().optional(),
+	name: z.string().optional(),
+	description: z.string().optional(),
+	homepage: z.string().optional(),
+	repository: z.union([z.string(), z.object({ url: z.string().optional() })]).optional()
+});
+async function detectBrand(cwd) {
+	const sources = [];
+	const notes = [];
+	const pkg = await readPackage(cwd);
+	const readme = await readMaybe(join(cwd, "README.md"));
+	const name = detectName(pkg, readme, cwd, sources);
+	const tagline = detectTagline(pkg, readme, sources);
+	const url = await detectUrl(pkg, cwd, sources);
+	const logo = findLogoPair(cwd);
+	if (logo !== void 0) sources.push({
+		field: "logo",
+		source: logo.light
+	});
+	const colors = await detectColors(cwd, logo?.light, sources, notes);
+	const contrast = ensureForegroundContrast(colors.background, colors.foreground);
+	if (contrast.adjusted) {
+		colors.foreground = contrast.foreground;
+		notes.push(`Foreground failed WCAG AA large-text contrast (3:1) against background, so it was set to ${contrast.foreground}.`);
+		upsertSource(sources, "colors.foreground", "contrast adjustment");
+	}
+	applyReadableMuted(colors, sources, notes);
+	applyReadableAccent(colors, sources, notes);
+	const brand = {
+		version: 1,
+		name,
+		colors,
+		fonts: {
+			heading: { ...DEFAULT_BRAND_FONTS.heading },
+			body: { ...DEFAULT_BRAND_FONTS.body },
+			mono: { ...DEFAULT_BRAND_FONTS.mono }
+		},
+		radius: 16,
+		theme: "dark",
+		style: "minimal",
+		tokens: null
+	};
+	if (tagline !== void 0) brand.tagline = tagline;
+	if (url !== void 0) brand.url = url;
+	if (logo !== void 0) brand.logo = logo.dark === void 0 ? { light: logo.light } : {
+		light: logo.light,
+		dark: logo.dark
+	};
+	sources.push({
+		field: "fonts",
+		source: "built-in Geist / vendored Geist Mono"
+	});
+	return {
+		brand,
+		sources,
+		notes
+	};
+}
+function detectName(pkg, readme, cwd, sources) {
+	if (pkg?.name !== void 0 && pkg.private !== true) {
+		const fromPkg = stripScope(pkg.name);
+		const h1 = readme === void 0 ? void 0 : extractH1(readme);
+		if (h1 !== void 0 && h1.toLowerCase() === fromPkg.toLowerCase() && h1 !== fromPkg) {
+			sources.push({
+				field: "name",
+				source: "README.md H1"
+			});
+			return h1;
+		}
+		sources.push({
+			field: "name",
+			source: "package.json#name"
+		});
+		return fromPkg;
+	}
+	const h1 = readme === void 0 ? void 0 : extractH1(readme);
+	if (h1 !== void 0) {
+		sources.push({
+			field: "name",
+			source: "README.md H1"
+		});
+		return h1;
+	}
+	sources.push({
+		field: "name",
+		source: "directory name"
+	});
+	const fromDir = basename(cwd);
+	return fromDir.length > 0 ? fromDir : "project";
+}
+function detectTagline(pkg, readme, sources) {
+	if (pkg?.description !== void 0 && pkg.description.trim().length > 0) {
+		sources.push({
+			field: "tagline",
+			source: "package.json#description"
+		});
+		return pkg.description.trim();
+	}
+	if (readme !== void 0) {
+		const tagline = extractTagline(readme);
+		if (tagline !== void 0) {
+			sources.push({
+				field: "tagline",
+				source: "README.md first paragraph"
+			});
+			return tagline;
+		}
+	}
+}
+async function detectUrl(pkg, cwd, sources) {
+	if (pkg?.homepage !== void 0 && pkg.homepage.length > 0) {
+		sources.push({
+			field: "url",
+			source: "package.json#homepage"
+		});
+		return pkg.homepage;
+	}
+	const repo = repositoryUrl(pkg?.repository);
+	if (repo !== void 0) {
+		sources.push({
+			field: "url",
+			source: "package.json#repository"
+		});
+		return repo;
+	}
+	const remote = await gitRemote(cwd);
+	if (remote !== void 0) {
+		sources.push({
+			field: "url",
+			source: "git remote origin"
+		});
+		return remote;
+	}
+}
+async function detectColors(cwd, logoPath, sources, notes) {
+	const merged = {};
+	const files = await listFiles(cwd, 4);
+	const cssFiles = files.filter((file) => file.endsWith(".css"));
+	const cssContents = await Promise.all(cssFiles.map(async (file) => ({
+		file,
+		css: await readMaybe(file)
+	})));
+	for (const { file, css } of cssContents) {
+		if (css === void 0) continue;
+		const fromTheme = extractTailwindV4Colors(css);
+		const fromRoot = extractCssRootColors(css);
+		const rel = relative(cwd, file);
+		applyColors(merged, fromTheme, sources, `Tailwind v4 @theme in ${rel}`);
+		applyColors(merged, fromRoot, sources, `:root variables in ${rel}`);
+	}
+	const configFiles = files.filter((file) => basename(file).startsWith("tailwind.config."));
+	const configContents = await Promise.all(configFiles.map(async (file) => ({
+		file,
+		source: await readMaybe(file)
+	})));
+	for (const { file, source } of configContents) {
+		if (source === void 0) continue;
+		applyColors(merged, extractTailwindV3Colors(source), sources, `Tailwind config ${relative(cwd, file)}`);
+	}
+	const tokenFile = files.find((file) => file.endsWith(".tokens.json"));
+	if (tokenFile !== void 0) {
+		const raw = await readMaybe(tokenFile);
+		if (raw !== void 0) try {
+			const parsed = JSON.parse(raw);
+			applyColors(merged, extractDtcgColors(parsed), sources, relative(cwd, tokenFile));
+		} catch (error) {
+			if (error instanceof SyntaxError) notes.push(`Could not parse design tokens file ${relative(cwd, tokenFile)}.`);
+			else throw error;
+		}
+	}
+	if (merged.primary === void 0 && logoPath !== void 0) {
+		const fromPng = logoPath.endsWith(".png") ? await dominantLogoColor(join(cwd, logoPath)) : void 0;
+		if (fromPng !== void 0) {
+			merged.primary = fromPng;
+			sources.push({
+				field: "colors.primary",
+				source: `dominant colour in ${logoPath}`
+			});
+		}
+		const svg = logoPath.endsWith(".svg") ? await readMaybe(join(cwd, logoPath)) : void 0;
+		if (svg !== void 0) {
+			const fromLogo = firstNonNeutralSvgColor(svg);
+			if (fromLogo !== void 0) {
+				merged.primary = fromLogo;
+				sources.push({
+					field: "colors.primary",
+					source: `SVG fill in ${logoPath}`
+				});
+			}
+		}
+	}
+	const fellBack = [
+		"background",
+		"foreground",
+		"muted",
+		"primary",
+		"accent"
+	].filter((field) => merged[field] === void 0);
+	if (fellBack.length > 0) notes.push(`Using built-in defaults for ${fellBack.map((f) => `colors.${f}`).join(", ")}. Nothing in this project set them. Edit .shipseal/brand.json to use your own.`);
+	return {
+		background: merged.background ?? DEFAULT_BRAND_COLORS.background,
+		foreground: merged.foreground ?? DEFAULT_BRAND_COLORS.foreground,
+		muted: merged.muted ?? DEFAULT_BRAND_COLORS.muted,
+		primary: merged.primary ?? DEFAULT_BRAND_COLORS.primary,
+		accent: merged.accent ?? DEFAULT_BRAND_COLORS.accent
+	};
+}
+function applyReadableMuted(colors, sources, notes) {
+	if (colors.muted === void 0 || readableOnBackground(colors.background, colors.muted)) return;
+	colors.muted = DEFAULT_BRAND_COLORS.muted;
+	notes.push(`Muted text color failed WCAG AA large-text contrast (3:1) against background, so it was set to ${DEFAULT_BRAND_COLORS.muted}.`);
+	upsertSource(sources, "colors.muted", "contrast adjustment");
+}
+function applyReadableAccent(colors, sources, notes) {
+	if (colors.accent === void 0 || readableOnBackground(colors.background, colors.accent)) return;
+	colors.accent = colors.primary ?? DEFAULT_BRAND_COLORS.primary;
+	notes.push("Accent failed contrast against background, so it uses the primary color.");
+	upsertSource(sources, "colors.accent", "contrast adjustment");
+}
+function applyColors(target, incoming, sources, source) {
+	for (const key of [
+		"background",
+		"foreground",
+		"muted",
+		"primary",
+		"accent"
+	]) {
+		const value = incoming[key];
+		if (value !== void 0 && target[key] === void 0) {
+			target[key] = value;
+			sources.push({
+				field: `colors.${key}`,
+				source
+			});
+		}
+	}
+}
+function upsertSource(sources, field, source) {
+	const existing = sources.find((entry) => entry.field === field);
+	if (existing !== void 0) {
+		existing.source = source;
+		return;
+	}
+	sources.push({
+		field,
+		source
+	});
+}
+async function readPackage(cwd) {
+	const raw = await readMaybe(join(cwd, "package.json"));
+	if (raw === void 0) return;
+	try {
+		const parsed = JSON.parse(raw);
+		const result = packageSchema.safeParse(parsed);
+		return result.success ? result.data : void 0;
+	} catch (error) {
+		if (error instanceof SyntaxError) return;
+		throw error;
+	}
+}
+async function gitRemote(cwd) {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"remote",
+			"get-url",
+			"origin"
+		], { cwd });
+		return normalizeGitUrl(stdout.trim());
+	} catch (error) {
+		if (error instanceof Error) return;
+		throw error;
+	}
+}
+async function listFiles(root, maxDepth) {
+	const out = [];
+	const walk = async (dir, depth) => {
+		if (depth < 0) return;
+		let entries;
+		try {
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		const nested = [];
+		for (const entry of entries) {
+			if (entry.name.startsWith(".") && entry.name !== ".github") continue;
+			const path = join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if (SKIP_DIRS.has(entry.name)) continue;
+				nested.push(walk(path, depth - 1));
+			} else out.push(path);
+		}
+		await Promise.all(nested);
+	};
+	await walk(root, maxDepth);
+	return out;
+}
+async function readMaybe(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch {
+		return;
+	}
+}
+function stripScope(name) {
+	const parts = name.split("/");
+	return parts[parts.length - 1] ?? name;
+}
+function repositoryUrl(repository) {
+	if (typeof repository === "string") return normalizeGitUrl(repository);
+	if (repository?.url !== void 0) return normalizeGitUrl(repository.url);
+}
+function normalizeGitUrl(url) {
+	const ssh = /^git@([^:]+):(.+)$/.exec(url);
+	if (ssh !== null && ssh[1] !== void 0 && ssh[2] !== void 0) return `https://${ssh[1]}/${ssh[2].replace(/\.git$/, "")}`;
+	return url.replace(/^git\+/, "").replace(/\.git$/, "");
+}
+/**
+* Dominant non-neutral colour of a PNG logo, or undefined when the file cannot be read or
+* carries no colour. Detection reports the colour as not found rather than falling back to a
+* built-in default that would be presented to the user as "your brand".
+*/
+async function dominantLogoColor(path) {
+	let buffer;
+	try {
+		buffer = await readFile(path);
+	} catch {
+		return;
+	}
+	const png = decodePng(buffer);
+	if (png === void 0) return;
+	return dominantNonNeutralColor(png);
+}
+function firstNonNeutralSvgColor(svg) {
+	const re = /(?:fill|stroke)="([^"]+)"/g;
+	let match;
+	while ((match = re.exec(svg)) !== null) {
+		const raw = match[1];
+		if (raw === void 0 || raw === "none" || raw === "currentColor") continue;
+		const hex = parseCssColor(raw);
+		if (hex !== void 0 && !isNeutralHex(hex)) return hex;
+	}
+}
+
+//#endregion
+//#region src/commands/init.ts
+async function runInit(options) {
+	const detection = await detectBrand(options.cwd);
+	const brandDir = join(options.cwd, ".shipseal");
+	const brandPath = join(brandDir, "brand.json");
+	const configPath = join(brandDir, "config.json");
+	if (!options.force && (existsSync(brandPath) || existsSync(configPath))) throw new ShipsealError("init.exists", ".shipseal/brand.json or config.json already exists.", "Re-run with --force to overwrite, or edit the files by hand.");
+	if (!options.yes) {
+		if (!await confirmInit(detection)) throw new ShipsealError("init.cancelled", "Init cancelled; no files were written.", "Re-run shipseal init and confirm, or pass --yes to accept detections.");
+	}
+	const brand = brandSchema.parse(detection.brand);
+	const config = configSchema.parse(DEFAULT_CONFIG);
+	await mkdir(brandDir, { recursive: true });
+	await writeFile(brandPath, `${JSON.stringify(brand, null, 2)}\n`, "utf8");
+	await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+	await ensureGitignore(options.cwd);
+	const sampleDir = join(brandDir, "output", "sample");
+	await mkdir(sampleDir, { recursive: true });
+	const samplePath = join(sampleDir, "release-hero-og.png");
+	const png = await (await createTakumiRenderer()).render(testCardNode(), {
+		width: FORMATS.og.width,
+		height: FORMATS.og.height,
+		format: "png"
+	});
+	await writeFile(samplePath, png);
+	return {
+		brandPath,
+		configPath,
+		samplePath,
+		detection
+	};
+}
+async function confirmInit(detection) {
+	if (!stdin.isTTY) throw new ShipsealError("init.unattended", "stdin is not a TTY, so init cannot ask for confirmation.", "Re-run with --yes to accept the detected brand and write files.");
+	stdout.write("Detected brand:\n");
+	for (const field of detection.sources) stdout.write(`  ${field.field}: from ${field.source}\n`);
+	for (const note of detection.notes) stdout.write(`  note: ${note}\n`);
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	try {
+		const answer = await rl.question("Write .shipseal/brand.json and config.json? [y/N] ");
+		return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+	} finally {
+		rl.close();
+	}
+}
+async function ensureGitignore(cwd) {
+	const path = join(cwd, ".gitignore");
+	const entry = ".shipseal/output/";
+	if (!existsSync(path)) {
+		await writeFile(path, `${entry}\n`, "utf8");
+		return;
+	}
+	const current = await readFile(path, "utf8");
+	if (current.split(/\r?\n/).some((line) => line.trim() === entry || line.trim() === ".shipseal/output")) return;
+	const prefix = current.endsWith("\n") || current.length === 0 ? "" : "\n";
+	await writeFile(path, `${current}${prefix}${entry}\n`, "utf8");
+}
+
+//#endregion
+//#region src/commands/milestone.ts
+async function runMilestone(flags) {
+	const cwd = flags.cwd;
+	const config = overlayFormats(await loadConfig(cwd), flags);
+	const brand = await loadBrand(cwd);
+	const placeholder = {
+		kind: "milestone",
+		metric: "stars",
+		threshold: 0
+	};
+	const env = collectEnv(flags);
+	const collectOpts = {
+		cwd,
+		event: placeholder,
+		skipNetwork: env.skipNetwork
+	};
+	if (env.packagePath !== void 0) collectOpts.packagePath = env.packagePath;
+	if (env.githubToken !== void 0) collectOpts.githubToken = env.githubToken;
+	if (env.fetchImpl !== void 0) collectOpts.fetchImpl = env.fetchImpl;
+	const collected = await collectFacts(collectOpts);
+	const selected = selectMilestone(collected, config, parseMetric(flags.metric), parseThreshold(flags.threshold));
+	if (selected === void 0) return {
+		dryRun: flags.dryRun === true,
+		skipped: true,
+		message: "No milestone threshold crossed. Nothing to generate.",
+		facts: collected,
+		warnings: [],
+		exitCode: 0
+	};
+	const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const metricKey = selected.metric === "downloads" ? "downloads" : selected.metric;
+	const facts = {
+		...collected,
+		milestone: {
+			metric: fact(selected.metric, {
+				source: "user-config",
+				ref: "shipseal milestone --metric",
+				fetchedAt
+			}),
+			threshold: fact(selected.threshold, {
+				source: "user-config",
+				ref: `config.json milestones.${metricKey}`,
+				fetchedAt
+			})
+		}
+	};
+	const event = {
+		kind: "milestone",
+		metric: selected.metric,
+		threshold: selected.threshold
+	};
+	const fallback = milestoneCopy(facts, selected.metric, selected.threshold);
+	const resolved = await resolveCopy(facts, config, flags.copy === false, fallback);
+	if (flags.dryRun === true) {
+		const dry = {
+			dryRun: true,
+			skipped: false,
+			facts,
+			copy: resolved.copy,
+			copyMode: resolved.copyMode,
+			warnings: [],
+			exitCode: 0
+		};
+		if (resolved.warning !== void 0) dry.copyWarning = resolved.warning;
+		return dry;
+	}
+	const renderer = await createTakumiRenderer();
+	const generateInput = {
+		event,
+		facts,
+		brand,
+		config,
+		copy: resolved.copy,
+		copyMode: resolved.copyMode,
+		renderer,
+		themes: resolveThemes(flags.themes, brand.theme),
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const logos = await loadLogos(cwd, brand);
+	if (logos !== void 0) generateInput.logos = logos;
+	const packInput = {
+		flags,
+		config,
+		event,
+		result: await generate(generateInput),
+		brand,
+		copy: resolved.copy,
+		copyMode: resolved.copyMode,
+		facts
+	};
+	if (resolved.warning !== void 0) packInput.copyWarning = resolved.warning;
+	return {
+		...await finishPack(packInput),
+		skipped: false
+	};
+}
+function highestCrossed(thresholds, current) {
+	return thresholds.filter((item) => current >= item).toSorted((a, b) => b - a)[0];
+}
+function selectMilestone(facts, config, metric, threshold) {
+	const metrics = metric === void 0 ? [
+		"stars",
+		"downloads",
+		"contributors"
+	] : [metric];
+	const candidates = [];
+	for (const item of metrics) {
+		const current = currentValue(facts, item);
+		if (current === void 0) {
+			if (metric !== void 0) throw missingMetric(item);
+			continue;
+		}
+		const list = thresholdsFor(config, item);
+		if (threshold !== void 0) {
+			if (metric !== void 0 || list.includes(threshold)) return {
+				metric: item,
+				threshold
+			};
+			continue;
+		}
+		const crossed = highestCrossed(list, current);
+		if (crossed !== void 0) candidates.push({
+			metric: item,
+			threshold: crossed
+		});
+	}
+	return candidates.toSorted((a, b) => b.threshold - a.threshold || metrics.indexOf(a.metric) - metrics.indexOf(b.metric))[0];
+}
+function currentValue(facts, metric) {
+	if (metric === "stars") return facts.metrics?.stars?.value;
+	if (metric === "downloads") return facts.metrics?.weeklyDownloads?.value;
+	return facts.metrics?.contributorCount?.value;
+}
+function thresholdsFor(config, metric) {
+	if (metric === "stars") return config.milestones?.stars ?? [];
+	if (metric === "downloads") return config.milestones?.downloads ?? [];
+	return config.milestones?.contributors ?? [];
+}
+function parseMetric(value) {
+	if (value === void 0) return;
+	if (value === "stars" || value === "downloads" || value === "contributors") return value;
+	throw new ShipsealError("milestone.bad-metric", `Unknown metric "${value}".`, "Use --metric stars, --metric downloads, or --metric contributors.");
+}
+function parseThreshold(value) {
+	if (value === void 0) return;
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new ShipsealError("milestone.bad-threshold", `Invalid threshold "${value}".`, "Pass a positive integer, for example --threshold 1000.");
+	return parsed;
+}
+function missingMetric(metric) {
+	if (metric === "stars") return new ShipsealError("milestone.missing-stars", "Could not read GitHub stars for this repo.", "Set GITHUB_TOKEN, or confirm package.json repository points at a public GitHub repo.");
+	if (metric === "downloads") return new ShipsealError("milestone.missing-downloads", "Could not read npm weekly downloads for this package.", "Confirm package.json name is published on npm, then retry without --dry-run.");
+	return new ShipsealError("milestone.missing-contributors", "Could not read the GitHub contributor count for this repo.", "Set GITHUB_TOKEN, or confirm package.json repository points at a public GitHub repo.");
+}
+
+//#endregion
+//#region src/commands/release.ts
+async function runRelease(flags) {
+	const cwd = flags.cwd;
+	const config = overlayReleaseConfig(await loadConfig(cwd), flags);
+	const brand = await loadBrand(cwd);
+	const tag = flags.tag ?? await gitCurrentTag(cwd);
+	if (tag === void 0) throw new ShipsealError("release.no-tag", "No git tag found for this release.", "Create a git tag, or pass --tag vX.Y.Z.");
+	const event = flags.from === void 0 ? {
+		kind: "release",
+		tag
+	} : {
+		kind: "release",
+		tag,
+		previousTag: flags.from
+	};
+	const env = collectEnv(flags);
+	const collectOpts = {
+		cwd,
+		event,
+		skipNetwork: env.skipNetwork
+	};
+	if (env.packagePath !== void 0) collectOpts.packagePath = env.packagePath;
+	if (config.release?.changelogPath !== void 0) collectOpts.changelogPath = config.release.changelogPath;
+	if (config.release?.snippet !== void 0) collectOpts.snippet = config.release.snippet;
+	if (env.githubToken !== void 0) collectOpts.githubToken = env.githubToken;
+	if (env.fetchImpl !== void 0) collectOpts.fetchImpl = env.fetchImpl;
+	const facts = await collectFacts(collectOpts);
+	const noCopy = flags.copy === false;
+	const resolved = await resolveCopy(facts, config, noCopy, deterministicCopy(facts, config.release?.maxHighlights));
+	if (flags.dryRun === true) {
+		const dry = {
+			dryRun: true,
+			facts,
+			copy: resolved.copy,
+			copyMode: resolved.copyMode,
+			warnings: [],
+			exitCode: 0
+		};
+		if (resolved.warning !== void 0) dry.copyWarning = resolved.warning;
+		return dry;
+	}
+	const renderer = await createTakumiRenderer();
+	const generateInput = {
+		event,
+		facts,
+		brand,
+		config,
+		copy: resolved.copy,
+		copyMode: resolved.copyMode,
+		renderer,
+		themes: resolveThemes(flags.themes, brand.theme),
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const logos = await loadLogos(cwd, brand);
+	if (logos !== void 0) generateInput.logos = logos;
+	const packInput = {
+		flags,
+		config,
+		event,
+		result: await generate(generateInput),
+		brand,
+		copy: resolved.copy,
+		copyMode: resolved.copyMode,
+		facts
+	};
+	if (resolved.warning !== void 0) packInput.copyWarning = resolved.warning;
+	return finishPack(packInput);
+}
+function overlayReleaseConfig(config, flags) {
+	const overlay = overlayFormats(config, flags);
+	if (flags.templates === void 0) return overlay;
+	return mergeConfig(DEFAULT_CONFIG, {
+		...overlay,
+		release: {
+			...overlay.release,
+			templates: flags.templates.split(",").map((item) => item.trim()).filter((item) => item.length > 0)
+		}
+	});
+}
+
+//#endregion
+//#region src/cli.ts
+async function runCli(argv = process.argv) {
+	process.exitCode = 0;
+	const cli = cac("shipseal");
+	cli.option("--cwd <path>", "Working directory", { default: process.cwd() });
+	cli.option("--json", "Machine-readable JSON output");
+	cli.option("--quiet", "Suppress non-error output");
+	cli.option("--verbose", "Verbose output");
+	cli.command("init", "Detect brand and write .shipseal/brand.json + config.json").option("--yes", "Accept detections without prompting").option("--force", "Overwrite existing brand.json and config.json").action(async (flags) => {
+		const result = await runInit({
+			cwd: stringFlag(flags.cwd, process.cwd()),
+			yes: flags.yes === true,
+			force: flags.force === true
+		});
+		if (flags.json === true) {
+			process.stdout.write(`${JSON.stringify(result.detection.brand, null, 2)}\n`);
+			return;
+		}
+		if (flags.quiet !== true) {
+			process.stdout.write(`Wrote ${result.brandPath}\n`);
+			process.stdout.write(`Wrote ${result.configPath}\n`);
+			process.stdout.write(`Sample card: ${result.samplePath}\n`);
+			for (const field of result.detection.sources) process.stdout.write(`  ${field.field}: ${field.source}\n`);
+			for (const note of result.detection.notes) process.stdout.write(`  note: ${note}\n`);
+		}
+	});
+	cli.command("doctor", "Check Node, git, brand, fonts, and Takumi").action(async (flags) => {
+		const result = await runDoctor(stringFlag(flags.cwd, process.cwd()));
+		if (flags.json === true) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+		else if (flags.quiet !== true) for (const check of result.checks) {
+			const mark = check.status === "pass" ? "ok" : check.status === "fail" ? "FAIL" : "info";
+			process.stdout.write(`[${mark}] ${check.name}: ${check.message}\n`);
+			if (check.fix !== void 0 && check.status === "fail") process.stdout.write(`      Fix: ${check.fix}\n`);
+		}
+		if (!result.ok) process.exitCode = 1;
+	});
+	cli.command("release", "Generate the release pack").option("--tag <tag>", "Release tag").option("--from <tag>", "Previous tag").option("--formats <list>", "Comma-separated formats").option("--templates <list>", "Comma-separated templates").option("--themes <dark|light|both>", "Themes to render").option("--copy", "Allow optional LLM copy (default: on when config.copy.llm is true)").option("--out <dir>", "Output directory").option("--strict", "Fit warnings exit with code 2").option("--dry-run", "Collect facts and print them; render nothing").option("--package <path>", "package.json path for monorepos").option("--upload", "Upload PNG files to the GitHub release").action(async (flags) => {
+		const releaseFlags = {
+			cwd: stringFlag(flags.cwd, process.cwd()),
+			strict: flags.strict === true,
+			dryRun: flags.dryRun === true
+		};
+		applySharedFlags(releaseFlags, flags);
+		const tag = optionalString(flags.tag);
+		if (tag !== void 0) releaseFlags.tag = tag;
+		const from = optionalString(flags.from);
+		if (from !== void 0) releaseFlags.from = from;
+		const templates = optionalString(flags.templates);
+		if (templates !== void 0) releaseFlags.templates = templates;
+		const result = await runRelease(releaseFlags);
+		process.exitCode = result.exitCode;
+		writeCommandOutput(flags, result);
+	});
+	cli.command("milestone", "Generate a milestone card for the highest crossed threshold").option("--metric <stars|downloads|contributors>", "Metric to check").option("--threshold <n>", "Force a specific threshold").option("--formats <list>", "Comma-separated formats").option("--themes <dark|light|both>", "Themes to render").option("--copy", "Allow optional LLM copy (default: on when config.copy.llm is true)").option("--out <dir>", "Output directory").option("--strict", "Fit warnings exit with code 2").option("--dry-run", "Collect facts and print them; render nothing").option("--package <path>", "package.json path for monorepos").action(async (flags) => {
+		const milestoneFlags = {
+			cwd: stringFlag(flags.cwd, process.cwd()),
+			strict: flags.strict === true,
+			dryRun: flags.dryRun === true
+		};
+		applySharedFlags(milestoneFlags, flags);
+		const metric = optionalString(flags.metric);
+		if (metric !== void 0) milestoneFlags.metric = metric;
+		const threshold = optionalString(flags.threshold);
+		if (threshold !== void 0) milestoneFlags.threshold = threshold;
+		const result = await runMilestone(milestoneFlags);
+		process.exitCode = result.exitCode;
+		if (flags.json === true) {
+			writeJson(resultToJson(result));
+			return;
+		}
+		if (flags.quiet === true) return;
+		if (result.skipped) {
+			process.stdout.write(`${result.message ?? "No milestone threshold crossed."}\n`);
+			return;
+		}
+		writeHumanResult(result);
+	});
+	cli.command("bench", "Generate benchmark cards from bench JSON").option("--file <path>", "Path to bench JSON").option("--formats <list>", "Comma-separated formats").option("--themes <dark|light|both>", "Themes to render").option("--copy", "Allow optional LLM copy (default: on when config.copy.llm is true)").option("--out <dir>", "Output directory").option("--strict", "Fit warnings exit with code 2").option("--dry-run", "Collect facts and print them; render nothing").option("--package <path>", "package.json path for monorepos").action(async (flags) => {
+		const benchFlags = {
+			cwd: stringFlag(flags.cwd, process.cwd()),
+			strict: flags.strict === true,
+			dryRun: flags.dryRun === true
+		};
+		applySharedFlags(benchFlags, flags);
+		const file = optionalString(flags.file);
+		if (file !== void 0) benchFlags.file = file;
+		const result = await runBench(benchFlags);
+		process.exitCode = result.exitCode;
+		writeCommandOutput(flags, result);
+	});
+	cli.help();
+	cli.version(readVersion());
+	try {
+		cli.parse(argv, { run: false });
+		await cli.runMatchedCommand();
+		return typeof process.exitCode === "number" ? process.exitCode : 0;
+	} catch (error) {
+		if (error instanceof ShipsealError) {
+			process.stderr.write(`${formatError(error)}\n`);
+			return 1;
+		}
+		if (error instanceof Error) {
+			process.stderr.write(`${error.message}\n`);
+			return 1;
+		}
+		throw error;
+	}
+}
+function stringFlag(value, fallback) {
+	return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+function optionalString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function applySharedFlags(target, flags) {
+	const formats = optionalString(flags.formats);
+	if (formats !== void 0) target.formats = formats;
+	const themes = optionalString(flags.themes);
+	if (themes !== void 0) target.themes = themes;
+	if (flags.copy === false) target.copy = false;
+	const out = optionalString(flags.out);
+	if (out !== void 0) target.out = out;
+	const pkg = optionalString(flags.package);
+	if (pkg !== void 0) target.package = pkg;
+	if (flags.upload === true) target.upload = true;
+}
+function writeCommandOutput(flags, result) {
+	if (flags.json === true) {
+		writeJson(resultToJson(result));
+		return;
+	}
+	if (flags.quiet === true) return;
+	writeHumanResult(result);
+}
+function resultToJson(result) {
+	const payload = {};
+	if (result.skipped === true) payload.skipped = true;
+	if (result.message !== void 0) payload.message = result.message;
+	if (result.dir !== void 0) payload.dir = result.dir;
+	if (result.manifest !== void 0) payload.manifest = result.manifest;
+	else payload.facts = result.facts;
+	return payload;
+}
+function writeHumanResult(result) {
+	if (result.skipped === true) {
+		process.stdout.write(`${result.message ?? "Nothing to generate."}\n`);
+		return;
+	}
+	if (result.dryRun) {
+		process.stdout.write(`${JSON.stringify(result.facts, null, 2)}\n`);
+		return;
+	}
+	if (result.dir !== void 0) process.stdout.write(`Wrote ${result.dir}\n`);
+	if (result.copyWarning !== void 0) process.stdout.write(`Copy: ${result.copyWarning}\n`);
+	for (const warning of result.warnings) process.stdout.write(`Warning: ${warning.template} ${warning.format} ${warning.slot} ${warning.action}\n`);
+}
+function writeJson(value) {
+	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+function readVersion() {
+	const raw = JSON.parse(readFileSync(join(resolvePackageRoot(), "package.json"), "utf8"));
+	if (typeof raw === "object" && raw !== null && "version" in raw && typeof raw.version === "string") return raw.version;
+	return "0.0.0";
+}
+if (shouldRun(process.argv[1])) runCli().then((code) => {
+	process.exit(code);
+});
+function shouldRun(invoked) {
+	if (invoked === void 0) return false;
+	const normalized = invoked.replaceAll("\\", "/");
+	return normalized.endsWith("/cli.js") || normalized.endsWith("/cli.ts") || normalized.endsWith("/shipseal");
+}
 
 //#endregion
-export {  };
+export { runCli };
 //# sourceMappingURL=cli.js.map