@amjadiqbal/start-seo-kit 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,420 @@
+import { t as jsonLd } from "./json-ld-BkYFVGHw.js";
+// src/url.ts
+/** `https://example.com/` -> `https://example.com`. Throws on a value that is not an absolute http(s) URL. */
+function normalizeSiteUrl(siteUrl) {
+	let parsed;
+	try {
+		parsed = new URL(siteUrl);
+	} catch {
+		throw new TypeError(`start-seo-kit: siteUrl must be an absolute URL, got "${siteUrl}"`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new TypeError(`start-seo-kit: siteUrl must use http or https, got "${siteUrl}"`);
+	return `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}`;
+}
+/** Apply the router's trailing-slash convention to a path (the root `/` is left alone). */
+function applyTrailingSlash(path, trailingSlash = "never") {
+	const [pathname = "", rest = ""] = splitPath(path);
+	if (pathname === "/" || pathname === "") return `/${rest}`;
+	const trimmed = pathname.replace(/\/+$/, "");
+	return `${trailingSlash === "always" ? `${trimmed}/` : trimmed}${rest}`;
+}
+/**
+* Resolve a path or URL against the site. Absolute http(s) URLs are returned unchanged.
+* Pass `trailingSlash` for page URLs only; asset URLs (images) keep their path as given.
+*/
+function absoluteUrl(siteUrl, pathOrUrl, trailingSlash) {
+	if (/^https?:\/\//i.test(pathOrUrl)) return pathOrUrl;
+	if (pathOrUrl.startsWith("//")) return `https:${pathOrUrl}`;
+	const path = pathOrUrl.startsWith("/") ? pathOrUrl : `/${pathOrUrl}`;
+	return `${normalizeSiteUrl(siteUrl)}${trailingSlash ? applyTrailingSlash(path, trailingSlash) : path}`;
+}
+function splitPath(path) {
+	const i = path.search(/[?#]/);
+	return i === -1 ? [path, ""] : [path.slice(0, i), path.slice(i)];
+}
+// src/head.ts
+/**
+* Create a typed head builder bound to your site's defaults.
+*
+* ```ts
+* export const seo = defineSeo({ url: 'https://acme.dev', name: 'Acme', titleTemplate: '%s | Acme' })
+* // in a route
+* head: ({ loaderData }) => seo({ title: loaderData.post.title, path: `/posts/${loaderData.post.slug}` })
+* ```
+*/
+function defineSeo(config) {
+	const site = {
+		...config,
+		url: normalizeSiteUrl(config.url)
+	};
+	const fn = ((input = {}) => buildHead(site, input));
+	Object.defineProperty(fn, "site", {
+		value: Object.freeze(site),
+		enumerable: true
+	});
+	fn.url = (path) => absoluteUrl(site.url, path, site.trailingSlash ?? "never");
+	return fn;
+}
+/** Build head tags without a site config. Relative URLs are not allowed here. */
+function seo(input) {
+	const { siteUrl, ...rest } = input;
+	return buildHead({ url: siteUrl ? normalizeSiteUrl(siteUrl) : "" }, rest);
+}
+function buildHead(site, input) {
+	const meta = [];
+	const links = [];
+	const slash = site.trailingSlash ?? "never";
+	const page = (p) => resolve(site.url, p, slash);
+	const asset = (p) => resolve(site.url, p);
+	const template = input.titleTemplate === false ? void 0 : input.titleTemplate ?? site.titleTemplate;
+	const title = input.title !== void 0 ? template ? template.replace(/%s/g, input.title) : input.title : site.defaultTitle;
+	if (title) meta.push({ title });
+	const description = input.description ?? site.description;
+	if (description) meta.push({
+		name: "description",
+		content: description
+	});
+	const robots = input.noindex ? robotsContent({
+		...typeof input.robots === "object" ? input.robots : {},
+		index: false
+	}) : robotsContent(input.robots ?? site.robots);
+	if (robots) meta.push({
+		name: "robots",
+		content: robots
+	});
+	const canonical = input.canonical === false ? void 0 : input.canonical ?? input.path;
+	const canonicalUrl = canonical !== void 0 ? page(canonical) : void 0;
+	if (canonicalUrl) links.push({
+		rel: "canonical",
+		href: canonicalUrl
+	});
+	for (const [lang, href] of Object.entries(input.alternates ?? {})) links.push({
+		rel: "alternate",
+		hrefLang: lang,
+		href: page(href)
+	});
+	const socialTitle = input.socialTitle ?? input.title ?? site.defaultTitle;
+	const type = input.type ?? (input.article ? "article" : "website");
+	if (socialTitle) meta.push({
+		property: "og:title",
+		content: socialTitle
+	});
+	if (description) meta.push({
+		property: "og:description",
+		content: description
+	});
+	meta.push({
+		property: "og:type",
+		content: type
+	});
+	const ogUrl = canonicalUrl ?? (input.path !== void 0 ? page(input.path) : void 0);
+	if (ogUrl) meta.push({
+		property: "og:url",
+		content: ogUrl
+	});
+	if (site.name) meta.push({
+		property: "og:site_name",
+		content: site.name
+	});
+	const locale = input.locale ?? site.locale;
+	if (locale) meta.push({
+		property: "og:locale",
+		content: locale
+	});
+	const image = input.image === false ? void 0 : input.image ?? site.image;
+	const img = image === void 0 ? void 0 : typeof image === "string" ? { url: image } : image;
+	if (img) {
+		const url = asset(img.url);
+		meta.push({
+			property: "og:image",
+			content: url
+		});
+		if (url.startsWith("https://")) meta.push({
+			property: "og:image:secure_url",
+			content: url
+		});
+		if (img.type) meta.push({
+			property: "og:image:type",
+			content: img.type
+		});
+		if (img.width) meta.push({
+			property: "og:image:width",
+			content: String(img.width)
+		});
+		if (img.height) meta.push({
+			property: "og:image:height",
+			content: String(img.height)
+		});
+		if (img.alt) meta.push({
+			property: "og:image:alt",
+			content: img.alt
+		});
+	}
+	if (input.article) {
+		const a = input.article;
+		if (a.publishedTime) meta.push({
+			property: "article:published_time",
+			content: isoDate$1(a.publishedTime)
+		});
+		if (a.modifiedTime) meta.push({
+			property: "article:modified_time",
+			content: isoDate$1(a.modifiedTime)
+		});
+		if (a.expirationTime) meta.push({
+			property: "article:expiration_time",
+			content: isoDate$1(a.expirationTime)
+		});
+		if (a.author) meta.push({
+			property: "article:author",
+			content: a.author
+		});
+		if (a.section) meta.push({
+			property: "article:section",
+			content: a.section
+		});
+	}
+	const twitter = {
+		...site.twitter,
+		...input.twitter
+	};
+	meta.push({
+		name: "twitter:card",
+		content: twitter.card ?? (img ? "summary_large_image" : "summary")
+	});
+	if (twitter.site) meta.push({
+		name: "twitter:site",
+		content: twitter.site
+	});
+	if (twitter.creator) meta.push({
+		name: "twitter:creator",
+		content: twitter.creator
+	});
+	if (socialTitle) meta.push({
+		name: "twitter:title",
+		content: socialTitle
+	});
+	if (description) meta.push({
+		name: "twitter:description",
+		content: description
+	});
+	if (img) {
+		meta.push({
+			name: "twitter:image",
+			content: asset(img.url)
+		});
+		if (img.alt) meta.push({
+			name: "twitter:image:alt",
+			content: img.alt
+		});
+	}
+	const ld = input.jsonLd === void 0 ? [] : Array.isArray(input.jsonLd) ? input.jsonLd : [input.jsonLd];
+	for (const obj of ld) meta.push({ "script:ld+json": obj });
+	if (input.meta) meta.push(...input.meta);
+	if (input.links) links.push(...input.links);
+	return {
+		meta,
+		links
+	};
+}
+function resolve(siteUrl, pathOrUrl, slash) {
+	if (!siteUrl && !/^(https?:)?\/\//i.test(pathOrUrl)) throw new TypeError(`start-seo-kit: "${pathOrUrl}" is relative; use defineSeo({ url }) or pass siteUrl to resolve it`);
+	return absoluteUrl(siteUrl || "https://invalid.invalid", pathOrUrl, slash);
+}
+/** Serialize robots directives, e.g. `{ index: false, maxImagePreview: 'large' }` -> `noindex, follow, max-image-preview:large`. */
+function robotsContent(robots) {
+	if (robots === void 0) return void 0;
+	if (typeof robots === "string") return robots || void 0;
+	const parts = [];
+	if (robots.index !== void 0 || robots.follow !== void 0) parts.push(robots.index === false ? "noindex" : "index", robots.follow === false ? "nofollow" : "follow");
+	if (robots.noarchive) parts.push("noarchive");
+	if (robots.nosnippet) parts.push("nosnippet");
+	if (robots.noimageindex) parts.push("noimageindex");
+	if (robots.notranslate) parts.push("notranslate");
+	if (robots.maxSnippet !== void 0) parts.push(`max-snippet:${robots.maxSnippet}`);
+	if (robots.maxImagePreview) parts.push(`max-image-preview:${robots.maxImagePreview}`);
+	if (robots.maxVideoPreview !== void 0) parts.push(`max-video-preview:${robots.maxVideoPreview}`);
+	if (robots.unavailableAfter) parts.push(`unavailable_after:${isoDate$1(robots.unavailableAfter)}`);
+	return parts.length ? parts.join(", ") : void 0;
+}
+function isoDate$1(value) {
+	return value instanceof Date ? value.toISOString() : value;
+}
+// src/sitemap.ts
+/** Render a `<urlset>` sitemap. */
+function sitemapXml(entries, options) {
+	const site = normalizeSiteUrl(options.siteUrl);
+	const slash = options.trailingSlash ?? "never";
+	const list = [...entries];
+	const hasAlternates = list.some((e) => e.alternates && Object.keys(e.alternates).length);
+	const hasImages = list.some((e) => e.images?.length);
+	const out = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>", `<urlset ${[
+		"xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\"",
+		hasAlternates ? "xmlns:xhtml=\"http://www.w3.org/1999/xhtml\"" : "",
+		hasImages ? "xmlns:image=\"http://www.google.com/schemas/sitemap-image/1.1\"" : ""
+	].filter(Boolean).join(" ")}>`];
+	for (const e of list) {
+		out.push("  <url>", `    <loc>${xml(absoluteUrl(site, e.loc, slash))}</loc>`);
+		if (e.lastmod) out.push(`    <lastmod>${xml(isoDate(e.lastmod))}</lastmod>`);
+		if (e.changefreq) out.push(`    <changefreq>${e.changefreq}</changefreq>`);
+		if (e.priority !== void 0) out.push(`    <priority>${clampPriority(e.priority)}</priority>`);
+		for (const [lang, href] of Object.entries(e.alternates ?? {})) out.push(`    <xhtml:link rel="alternate" hreflang="${xml(lang)}" href="${xml(absoluteUrl(site, href, slash))}"/>`);
+		for (const image of e.images ?? []) {
+			const img = typeof image === "string" ? { url: image } : image;
+			out.push("    <image:image>", `      <image:loc>${xml(absoluteUrl(site, img.url))}</image:loc>`);
+			if (img.title) out.push(`      <image:title>${xml(img.title)}</image:title>`);
+			if (img.caption) out.push(`      <image:caption>${xml(img.caption)}</image:caption>`);
+			out.push("    </image:image>");
+		}
+		out.push("  </url>");
+	}
+	out.push("</urlset>", "");
+	return out.join("\n");
+}
+/** Render a `<sitemapindex>`. */
+function sitemapIndexXml(sitemaps, options) {
+	const site = normalizeSiteUrl(options.siteUrl);
+	const out = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>", "<sitemapindex xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">"];
+	for (const s of sitemaps) {
+		out.push("  <sitemap>", `    <loc>${xml(absoluteUrl(site, s.loc))}</loc>`);
+		if (s.lastmod) out.push(`    <lastmod>${xml(isoDate(s.lastmod))}</lastmod>`);
+		out.push("  </sitemap>");
+	}
+	out.push("</sitemapindex>", "");
+	return out.join("\n");
+}
+/** Dynamic sitemap (and sitemap index for large sites) served from TanStack Start server routes. */
+function createSitemap(options) {
+	const max = options.maxUrlsPerSitemap ?? 5e4;
+	const basePath = (options.basePath ?? "/sitemaps").replace(/\/+$/, "");
+	const headers = {
+		"Content-Type": "application/xml; charset=utf-8",
+		"Cache-Control": options.cacheControl ?? "public, max-age=3600"
+	};
+	for (const name of Object.keys(options.sources)) if (!/^[\w-]+$/.test(name)) throw new TypeError(`start-seo-kit: invalid sitemap source name "${name}"`);
+	const count = async (src) => Array.isArray(src) ? src.length : typeof src === "function" ? (await src()).length : await src.count();
+	const slice = async (src, offset, limit) => Array.isArray(src) ? src.slice(offset, offset + limit) : typeof src === "function" ? (await src()).slice(offset, offset + limit) : await src.entries({
+		offset,
+		limit
+	});
+	const all = async () => {
+		const out = [];
+		for (const src of Object.values(options.sources)) out.push(...await slice(src, 0, Number.MAX_SAFE_INTEGER));
+		return out;
+	};
+	return {
+		entries: all,
+		async index() {
+			const counts = await Promise.all(Object.entries(options.sources).map(async ([n, s]) => [
+				n,
+				await count(s),
+				s
+			]));
+			const total = counts.reduce((sum, [, c]) => sum + c, 0);
+			if (!(options.index === true || options.index !== false && total > max)) {
+				if (total > max) throw new RangeError(`start-seo-kit: ${total} URLs exceed maxUrlsPerSitemap (${max}); enable index`);
+				return new Response(sitemapXml(await all(), options), { headers });
+			}
+			const children = [];
+			for (const [name, c, src] of counts) {
+				const lastmod = !Array.isArray(src) && typeof src === "object" && src.lastmod ? await src.lastmod() : void 0;
+				for (let i = 0; i < Math.max(1, Math.ceil(c / max)); i++) children.push({
+					loc: `${basePath}/${name}-${i + 1}.xml`,
+					lastmod
+				});
+			}
+			return new Response(sitemapIndexXml(children, options), { headers });
+		},
+		async page({ request, params }) {
+			const name = params?.name ?? new URL(request.url).pathname.split("/").pop() ?? "";
+			const match = /^([\w-]+)-(\d+)\.xml$/.exec(name);
+			const src = match ? options.sources[match[1]] : void 0;
+			const n = match ? Number(match[2]) : 0;
+			if (!src || n < 1) return new Response("Not Found", { status: 404 });
+			const entries = await slice(src, (n - 1) * max, max);
+			if (!entries.length && n > 1) return new Response("Not Found", { status: 404 });
+			return new Response(sitemapXml(entries, options), { headers });
+		}
+	};
+}
+/**
+* Collect the static (parameter-free) page paths of your TanStack Router route tree.
+* Dynamic routes (`$id`, `$`) are skipped: list them from your data in another source.
+* Skipped too: server-only routes, paths with a file extension (`/sitemap.xml`), and routes with
+* `staticData: { sitemap: false }`. Per-route `staticData.sitemap` values (priority, changefreq) are applied.
+*/
+function routesFromTree(routeTree, options = {}) {
+	if (!routeTree || typeof routeTree !== "object") throw new TypeError("start-seo-kit: routesFromTree() got no route tree. If your sitemap module imports routeTree.gen and is itself imported by a route, that is a circular import: make the source lazy, e.g. `pages: () => routesFromTree(routeTree)`.");
+	const seen = /* @__PURE__ */ new Map();
+	const visit = (route) => {
+		const kids = route.children ? Object.values(route.children) : [];
+		const path = route.fullPath;
+		const opts = route.options ?? {};
+		const sitemap = opts.staticData?.sitemap;
+		const serverOnly = opts.server !== void 0 && opts.component === void 0;
+		if (path !== void 0 && !route.isRoot && sitemap !== false && !serverOnly) {
+			const normalized = path === "/" ? "/" : path.replace(/\/+$/, "") || "/";
+			const isStatic = !/(^|\/)(\$|\{)/.test(normalized) && !/\.[a-z0-9]+$/i.test(normalized);
+			const excluded = options.exclude?.some((x) => typeof x === "string" ? x === normalized : x.test(normalized));
+			if (isStatic && !excluded && !seen.has(normalized)) seen.set(normalized, {
+				...options.defaults,
+				...sitemap,
+				loc: normalized
+			});
+		}
+		for (const kid of kids) visit(kid);
+	};
+	visit(routeTree);
+	return [...seen.values()];
+}
+function clampPriority(p) {
+	return String(Math.round(Math.min(1, Math.max(0, p)) * 100) / 100);
+}
+function isoDate(value) {
+	return value instanceof Date ? value.toISOString() : value;
+}
+function xml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+// src/robots.ts
+/** Render a robots.txt body. */
+function robotsTxt(config = {}) {
+	const rules = config.disallowAll ? [{
+		userAgent: "*",
+		disallow: "/"
+	}] : config.rules ?? [{
+		userAgent: "*",
+		allow: "/"
+	}];
+	const lines = [];
+	for (const rule of rules) {
+		if (lines.length) lines.push("");
+		for (const ua of list(rule.userAgent)) lines.push(`User-agent: ${ua}`);
+		for (const path of list(rule.allow)) lines.push(`Allow: ${path}`);
+		for (const path of list(rule.disallow)) lines.push(`Disallow: ${path}`);
+		if (rule.crawlDelay !== void 0) lines.push(`Crawl-delay: ${rule.crawlDelay}`);
+	}
+	const sitemaps = config.sitemaps ?? [];
+	if (sitemaps.length) lines.push("");
+	for (const s of sitemaps) {
+		if (!config.siteUrl && !/^https?:\/\//i.test(s)) throw new TypeError(`start-seo-kit: sitemap "${s}" is relative; pass siteUrl`);
+		lines.push(`Sitemap: ${config.siteUrl ? absoluteUrl(normalizeSiteUrl(config.siteUrl), s) : s}`);
+	}
+	return `${lines.join("\n")}\n`;
+}
+/**
+* `GET` handler for a `/robots.txt` server route. Pass a function to decide per request
+* (for example, `disallowAll` when the host is a preview deployment).
+*/
+function createRobotsHandler(config, init = {}) {
+	return async (ctx) => {
+		const resolved = typeof config === "function" ? await config(ctx) : config;
+		return new Response(robotsTxt(resolved), { headers: {
+			"Content-Type": "text/plain; charset=utf-8",
+			"Cache-Control": init.cacheControl ?? "public, max-age=3600"
+		} });
+	};
+}
+function list(value) {
+	return value === void 0 ? [] : Array.isArray(value) ? value : [value];
+}
+export { absoluteUrl, createRobotsHandler, createSitemap, defineSeo, jsonLd, robotsContent, robotsTxt, routesFromTree, seo, sitemapIndexXml, sitemapXml };

package/dist/json-ld-BkYFVGHw.js

@@ -0,0 +1,122 @@
+// src/json-ld.ts
+const CONTEXT = "https://schema.org";
+/**
+* Typed builders for common schema.org types. Each returns a JSON-LD object with `@context`.
+* Product, Offer, Review and return/shipping policies live in `@amjadiqbal/start-seo-kit/commerce`.
+*/
+const jsonLd = {
+	person(p) {
+		return clean({
+			"@context": CONTEXT,
+			"@type": "Person",
+			"@id": p.id,
+			name: p.name,
+			url: p.url,
+			image: p.image,
+			jobTitle: p.jobTitle,
+			sameAs: p.sameAs
+		});
+	},
+	organization(o) {
+		return clean({
+			"@context": CONTEXT,
+			"@type": o.type ?? "Organization",
+			"@id": o.id,
+			name: o.name,
+			url: o.url,
+			logo: o.logo,
+			sameAs: o.sameAs,
+			email: o.email,
+			telephone: o.telephone
+		});
+	},
+	website(w) {
+		return clean({
+			"@context": CONTEXT,
+			"@type": "WebSite",
+			"@id": w.id,
+			name: w.name,
+			url: w.url,
+			inLanguage: w.inLanguage,
+			publisher: w.publisher === void 0 ? void 0 : ref(w.publisher, "Organization"),
+			potentialAction: w.searchUrlTemplate ? {
+				"@type": "SearchAction",
+				target: {
+					"@type": "EntryPoint",
+					urlTemplate: w.searchUrlTemplate
+				},
+				"query-input": "required name=search_term_string"
+			} : void 0
+		});
+	},
+	article(a) {
+		const authors = a.author === void 0 ? void 0 : (Array.isArray(a.author) ? a.author : [a.author]).map((x) => ref(x, "Person"));
+		return clean({
+			"@context": CONTEXT,
+			"@type": a.type ?? "Article",
+			"@id": a.id,
+			headline: a.headline,
+			description: a.description,
+			url: a.url,
+			mainEntityOfPage: a.url,
+			image: a.image,
+			datePublished: date(a.datePublished),
+			dateModified: date(a.dateModified),
+			author: authors && authors.length === 1 ? authors[0] : authors,
+			publisher: a.publisher === void 0 ? void 0 : ref(a.publisher, "Organization"),
+			keywords: a.keywords?.join(", ")
+		});
+	},
+	breadcrumbs(items) {
+		return {
+			"@context": CONTEXT,
+			"@type": "BreadcrumbList",
+			itemListElement: items.map((item, i) => clean({
+				"@type": "ListItem",
+				position: i + 1,
+				name: item.name,
+				item: item.url
+			}))
+		};
+	},
+	faq(items) {
+		return {
+			"@context": CONTEXT,
+			"@type": "FAQPage",
+			mainEntity: items.map((q) => ({
+				"@type": "Question",
+				name: q.question,
+				acceptedAnswer: {
+					"@type": "Answer",
+					text: q.answer
+				}
+			}))
+		};
+	},
+	/** Combine several nodes into one `@graph` document (their own `@context` is dropped). */
+	graph(...nodes) {
+		return {
+			"@context": CONTEXT,
+			"@graph": nodes.map(({ "@context": _ctx, ...rest }) => rest)
+		};
+	}
+};
+function ref(value, type) {
+	if (typeof value !== "string") {
+		const { "@context": _ctx, ...rest } = value;
+		return rest;
+	}
+	return /^https?:\/\//.test(value) ? { "@id": value } : {
+		"@type": type,
+		name: value
+	};
+}
+function date(value) {
+	return value instanceof Date ? value.toISOString() : value;
+}
+function clean(obj) {
+	const out = {};
+	for (const [k, v] of Object.entries(obj)) if (v !== void 0) out[k] = v;
+	return out;
+}
+export { jsonLd as t };

package/dist/og.d.ts

@@ -0,0 +1,64 @@
+import { a as ServerHandler, r as HandlerContext } from "./sitemap-DbEixSCi.js";
+type Awaitable<T> = T | Promise<T>;
+/** A satori element: a React element (JSX) or a plain `{ type, props }` object tree. */
+export type OgElement = {
+  type: unknown;
+  props: unknown;
+} | string;
+export interface OgFont {
+  name: string;
+  /** Font file contents (TTF, OTF or WOFF; not WOFF2). */
+  data: ArrayBuffer | Uint8Array;
+  weight?: 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
+  style?: 'normal' | 'italic';
+}
+/** What `@resvg/resvg-wasm`'s `initWasm` accepts: the `.wasm` bytes, a `Response`, a `WebAssembly.Module` or a URL. */
+export type WasmSource = ArrayBuffer | Uint8Array | Response | WebAssembly.Module | URL | string;
+export interface RenderOgOptions {
+  fonts: OgFont[];
+  /** Default 1200. */
+  width?: number;
+  /** Default 630. */
+  height?: number;
+  /** `png` (default, needs `@resvg/resvg-wasm`) or `svg` (satori only). */
+  format?: 'png' | 'svg';
+  /**
+   * The resvg `.wasm` for PNG output. On Node it is read from `node_modules` when left out.
+   * Where `node_modules` cannot be read, pass it yourself.
+   */
+  wasm?: WasmSource | (() => Awaitable<WasmSource>);
+}
+/** Render an element to PNG bytes (or an SVG string with `format: 'svg'`). */
+export declare function renderOgImage(element: OgElement, options: RenderOgOptions): Promise<Uint8Array | string>;
+export interface CreateOgImageOptions extends Omit<RenderOgOptions, 'fonts'> {
+  /** Fonts, or a function that loads them once (cached after the first request). */
+  fonts: OgFont[] | (() => Awaitable<OgFont[]>);
+  /** Build the image for a request. Return `null` for a 404. */
+  render: (ctx: HandlerContext & {
+    url: URL;
+  }) => Awaitable<OgElement | null>;
+  /** `Cache-Control` header. Default `public, max-age=86400, immutable`. */
+  cacheControl?: string;
+}
+/**
+ * `GET` handler for an Open Graph image server route, e.g. `src/routes/og/$slug.ts`.
+ * Point `seo({ image: '/og/my-post' })` at it.
+ */
+export declare function createOgImageHandler(options: CreateOgImageOptions): ServerHandler;
+export interface OgCardInput {
+  title: string;
+  description?: string;
+  /** Small label above the title, e.g. the site name. */
+  eyebrow?: string;
+  /** Footer text, e.g. the domain. */
+  footer?: string;
+  /** Font family name as registered in `fonts`. */
+  fontFamily?: string;
+  background?: string;
+  foreground?: string;
+  muted?: string;
+  accent?: string;
+}
+/** A ready-made 1200x630 card (title, description, label, footer) as a plain element tree; no JSX needed. */
+export declare function ogCard(input: OgCardInput): OgElement;
+export {};