Cache     *feedCache

	Images    *imageCache

	renderSem chan struct{}

	OGImage         string

	mux.HandleFunc("GET /og.png", a.ogImageHandler)

package main

import (

	"container/list"

	"context"

	"sync"

	"time"

)

// feedCache is a small TTL cache of fetched feed results, keyed by feed URL.

// It keeps crawler-triggered requests (page + OG image) fast after the first

// fetch warms the entry.

type feedCache struct {

	mu      sync.Mutex

	ttl     time.Duration

	entries map[string]feedCacheEntry

}

type feedCacheEntry struct {

	res     *FetchResult

	expires time.Time

}

func newFeedCache(ttl time.Duration) *feedCache {

	return &feedCache{ttl: ttl, entries: map[string]feedCacheEntry{}}

}

// fetch returns a cached result when fresh, otherwise fetches and stores it.

// Concurrent misses for the same URL may each fetch; the last write wins.

func (c *feedCache) fetch(ctx context.Context, feedURL string) (*FetchResult, error) {

	c.mu.Lock()

	if e, ok := c.entries[feedURL]; ok && time.Now().Before(e.expires) {

		c.mu.Unlock()

		return e.res, nil

	}

	c.mu.Unlock()

	res, err := fetchFeed(ctx, feedURL, "", "")

	if err != nil {

		return nil, err

	}

	c.mu.Lock()

	c.entries[feedURL] = feedCacheEntry{res: res, expires: time.Now().Add(c.ttl)}

	c.mu.Unlock()

	return res, nil

}

// imageCache is an LRU + TTL cache of rendered PNG bytes, keyed by the shared

// URL set. It bounds memory (max entries) and lets repeated shares of the same

// link skip the CPU/allocation cost of re-rendering.

type imageCache struct {

	mu      sync.Mutex

	ttl     time.Duration

	max     int

	ll      *list.List // front = most recently used

	entries map[string]*list.Element

}

type imageEntry struct {

	key     string

	png     []byte

	expires time.Time

}

func newImageCache(ttl time.Duration, max int) *imageCache {

	return &imageCache{

		ttl:     ttl,

		max:     max,

		ll:      list.New(),

		entries: map[string]*list.Element{},

	}

}

func (c *imageCache) get(key string) ([]byte, bool) {

	c.mu.Lock()

	defer c.mu.Unlock()

	el, ok := c.entries[key]

	if !ok {

		return nil, false

	}

	ent := el.Value.(*imageEntry)

	if time.Now().After(ent.expires) {

		c.ll.Remove(el)

		delete(c.entries, key)

		return nil, false

	}

	c.ll.MoveToFront(el)

	return ent.png, true

}

func (c *imageCache) set(key string, png []byte) {

	c.mu.Lock()

	defer c.mu.Unlock()

	if el, ok := c.entries[key]; ok {

		ent := el.Value.(*imageEntry)

		ent.png = png

		ent.expires = time.Now().Add(c.ttl)

		c.ll.MoveToFront(el)

		return

	}

	el := c.ll.PushFront(&imageEntry{key: key, png: png, expires: time.Now().Add(c.ttl)})

	c.entries[key] = el

	for c.ll.Len() > c.max {

		oldest := c.ll.Back()

		if oldest == nil {

			break

		}

		c.ll.Remove(oldest)

		delete(c.entries, oldest.Value.(*imageEntry).key)

	}

}

func previewURLs(ctx context.Context, urls []string, perFeed int, cache *feedCache, log *slog.Logger) ([]FeedPreviewItem, map[string]string) {

			res, err := cache.fetch(ctx, feedURL)

	github.com/fogleman/gg v1.3.0

	golang.org/x/image v0.43.0

	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect

	golang.org/x/text v0.38.0 // indirect

github.com/fogleman/gg v1.3.0 h1:/7zJX8F6AaYQc57WQCyN9cAIz+4bCJGO9B+dyW29am8=

github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=

github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=

github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=

golang.org/x/image v0.43.0 h1:FLxcP4ec2350nTfOC8ysKtqYSIFbk/QGjw1ZHNP4tsY=

golang.org/x/image v0.43.0/go.mod h1:rrpelvGFt+kLPAjPM4HeWPgrl0FtafueU//e5N0qk/Q=

golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=

golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=

		OGImage:         a.BaseURL + "/static/og.png",

	urls := feedURLsFromRequest(r)

	data.OGImage = a.BaseURL + "/og.png?" + r.URL.RawQuery

	items, titles := previewURLs(ctx, urls, 0, a.Cache, a.Log)

}

// feedURLsFromRequest extracts and normalizes the feed URLs from the "url" or

// "urls" query param, capped at maxFeedURLs.

func feedURLsFromRequest(r *http.Request) []string {

	query := r.URL.Query().Get("url")

	if query == "" {

		query = r.URL.Query().Get("urls")

	}

	urls := splitAndTrim(query)

	if len(urls) > maxFeedURLs {

		urls = urls[:maxFeedURLs]

	}

	return urls

	"runtime"

	"time"

	renderSlots := runtime.NumCPU()

		Cache:     newFeedCache(5 * time.Minute),

		Images:    newImageCache(10*time.Minute, 512),

		renderSem: make(chan struct{}, renderSlots),

package main

import (

	"bytes"

	"context"

	"net/http"

	"sort"

	"strings"

	"sync"

	"time"

	"unicode/utf8"

	"github.com/fogleman/gg"

	"golang.org/x/image/font"

	"golang.org/x/image/font/opentype"

)

const (

	ogWidth  = 1200

	ogHeight = 630

	ogMargin = 80.0

)

var (

	fontOnce              sync.Once

	fontRegular, fontBold *opentype.Font

	fontErr               error

)

// loadFonts parses the embedded CommitMono OTFs once. They use CFF outlines,

// which the freetype loader gg ships with can't read, so we parse them with

// x/image/font/opentype (sfnt) instead.

func loadFonts() {

	fontOnce.Do(func() {

		rb, err := appFS.ReadFile("static/fonts/CommitMono-400-Regular.otf")

		if err != nil {

			fontErr = err

			return

		}

		bb, err := appFS.ReadFile("static/fonts/CommitMono-700-Regular.otf")

		if err != nil {

			fontErr = err

			return

		}

		if fontRegular, err = opentype.Parse(rb); err != nil {

			fontErr = err

			return

		}

		if fontBold, err = opentype.Parse(bb); err != nil {

			fontErr = err

			return

		}

	})

}

// newFace builds a font.Face at the given size. Faces are created per call

// because opentype faces are not safe for concurrent use.

func newFace(bold bool, size float64) (font.Face, error) {

	loadFonts()

	if fontErr != nil {

		return nil, fontErr

	}

	src := fontRegular

	if bold {

		src = fontBold

	}

	return opentype.NewFace(src, &opentype.FaceOptions{Size: size, DPI: 72, Hinting: font.HintingFull})

}

func (a *App) ogImageHandler(w http.ResponseWriter, r *http.Request) {

	urls := feedURLsFromRequest(r)

	key := ogCacheKey(urls)

	// Serve a previously rendered PNG without touching the render path.

	if png, ok := a.Images.get(key); ok {

		writePNG(w, png)

		return

	}

	ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second)

	defer cancel()

	title, desc := "Feeds", "Experience RSS feeds"

	if len(urls) > 0 {

		items, titles := previewURLs(ctx, urls, 0, a.Cache, a.Log)

		title, desc = feedMeta(urls, titles, len(items))

	}

	// Bound concurrent renders to cap CPU and peak memory (each render

	// allocates a ~3MB bitmap). Overloaded requests bail rather than pile up.

	select {

	case a.renderSem <- struct{}{}:

		defer func() { <-a.renderSem }()

	case <-ctx.Done():

		http.Error(w, "render busy", http.StatusServiceUnavailable)

		return

	}

	png, err := renderOGImage(title, desc)

	if err != nil {

		a.Log.Error("og render failed", "err", err)

		http.Error(w, "og render error", http.StatusInternalServerError)

		return

	}

	a.Images.set(key, png)

	writePNG(w, png)

}

// ogCacheKey normalizes a URL set into a stable cache key (order-independent).

func ogCacheKey(urls []string) string {

	sorted := append([]string(nil), urls...)

	sort.Strings(sorted)

	return strings.Join(sorted, "\n")

}

func writePNG(w http.ResponseWriter, png []byte) {

	w.Header().Set("Content-Type", "image/png")

	w.Header().Set("Cache-Control", "public, max-age=300")

	_, _ = w.Write(png)

}

// renderOGImage draws a 1200x630 social card with the feed title and a subtitle.

func renderOGImage(title, desc string) ([]byte, error) {

	dc := gg.NewContext(ogWidth, ogHeight)

	dc.SetHexColor("#ffffff")

	dc.Clear()

	// Top accent bar.

	dc.SetHexColor("#1a1a1a")

	dc.DrawRectangle(0, 0, ogWidth, 12)

	dc.Fill()

	// "FEEDS" wordmark.

	wordmark, err := newFace(true, 34)

	if err != nil {

		return nil, err

	}

	dc.SetFontFace(wordmark)

	dc.SetHexColor("#1a1a1a")

	dc.DrawString("FEEDS", ogMargin, 120)

	// Title, wrapped, truncated so it can't run into the subtitle.

	titleFace, err := newFace(true, 68)

	if err != nil {

		return nil, err

	}

	dc.SetFontFace(titleFace)

	dc.SetHexColor("#1a1a1a")

	dc.DrawStringWrapped(truncate(title, 90), ogMargin, 200, 0, 0, ogWidth-2*ogMargin, 1.35, gg.AlignLeft)

	// Subtitle pinned near the bottom.

	subFace, err := newFace(false, 34)

	if err != nil {

		return nil, err

	}

	dc.SetFontFace(subFace)

	dc.SetHexColor("#6b6b6b")

	dc.DrawString(desc, ogMargin, ogHeight-ogMargin)

	var buf bytes.Buffer

	if err := dc.EncodePNG(&buf); err != nil {

		return nil, err

	}

	return buf.Bytes(), nil

}

func truncate(s string, maxRunes int) string {

	if utf8.RuneCountInString(s) <= maxRunes {

		return s

	}

	runes := []rune(s)

	return string(runes[:maxRunes]) + "…"

}

    <meta property="og:image" content="{{.OGImage}}" />

    <meta name="twitter:image" content="{{.OGImage}}" />