index.ts#

Computes a stable template source identifier for cache keys.

For custom templates, hashes the file content so cache invalidates when the template changes. For the default template, returns a fixed string.

Creates a rolldown plugin that compiles Svelte SFCs using svelte/compiler.

Creates a rolldown plugin that compiles Vue SFCs using @vue/compiler-sfc.

How many pages to render at once when the caller does not say.

Rendering was serial by default, so a site paid one Chromium page render per page, end to end. Pages are cheap next to the browser itself, but they are not free — this stays well under the core count so a build machine keeps room for everything else.

Generates OG images for a batch of pages.

Manages the full lifecycle: resolve template → select renderer → render each page (with caching and concurrency).

All errors are non-fatal: failures are reported in results but never throw.

Loads @vizejs/vite-plugin as a rolldown plugin for Vue SFC compilation.

Whether id is a bare specifier, and so resolvable at runtime rather than something the template bundle has to inline.

Template bundles are written to <root>/.cache/og-images/ and imported from there, so Node resolves anything left external against the project's own node_modules. Relative and absolute imports still bundle, which is what a template actually needs — its own components travel with it.

A page entry with its cache key computed once.

Runs render over items, one at a time per session, in input order.

A shared cursor rather than fixed batches: a batch waits for its slowest member before the next one starts, so one heavy card idled every other worker until it finished. Results are written by index, so the order the caller gets back does not depend on which session finished first.

A single page entry for batch OG image generation.

Result of OG image generation for a single page.

Matches this package and every subpath it exports.

A template's natural runtime is whatever renders it, and for the framework-less kinds that is this package: renderToString, raw, when and each live at its root, and the JSX runtime under ./jsx-runtime. Inlining them instead drags the entire plugin — chokidar, fsevents and all — into the template bundle, which is what made importing it fail outright.

Renders a single page to PNG, with cache support.

Renders a single page to PNG using Satori, with cache support.

Resolves a React (.tsx/.jsx) template via SSR.

Bundles with rolldown (JSX transform), then wraps with react-dom/server renderToReadableStream for async Server Component support.

Resolves a Svelte SFC template via SSR.

Compiles the SFC with svelte/compiler (server mode + runes), bundles with rolldown, then wraps with svelte/server render().

Resolves the template function from options.

Dispatches by file extension:

• .vue → Vue SFC (SSR via vue/server-renderer)
• .svelte → Svelte SFC (SSR via svelte/server)
• .tsx/.jsx → React Server Component (SSR via react-dom/server)
• others → TypeScript template (direct function export)

Resolves a plain TypeScript template (existing behavior).

Resolves a Vue SFC template via SSR.

Compiles the SFC with @vue/compiler-sfc (or @vizejs/vite-plugin), bundles with rolldown, then wraps with createSSRApp + renderToString.

Serves every page from cache when all of them are present.

The probe is an existence check per key, not a read: on a partial hit this used to read and write every cached page before discovering the miss, then throw that work away and let the render loop redo it. Returns null when any page is missing, which is the signal that a renderer has to start.

Rolldown input options for a .ts template bundle.

A .ts template is the framework-less kind, so it has no single runtime to externalize the way the .vue, .svelte and .tsx paths do — anything from node_modules is better resolved at import time than inlined. Nothing on this path has a compiler plugin, so nothing here needed bundling to be loadable in the first place.

Attaches the cache key to each entry.

The key is a SHA-256 over the template source and the page props. It used to be recomputed three times per page — once to probe, once to read, once to write — over props that can be a whole frontmatter object.