@giancarlosgza/blog-layer 0.0.0-stage → 0.1.0

package/scripts/subset-icons.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * Material Symbols icon font subsetter for sites built on the blog layer.
+ * Run from the site root (`blog-layer-subset-icons`, e.g. in the site's `prebuild`).
+ *
+ * Scans the site, its local `layers/*`, this layer and `@giancarlosgza/blog-site-layer` (when the
+ * site installs it) — app/, shared/, server/ — plus the @colorffy/ui dist for every Material Symbols
+ * codepoint in use, both `` HTML entities and raw Private Use Area characters, and writes
+ * into the site:
+ *
+ *   public/icon-fonts/material-symbols-rounded-subset.woff2   tiny subset (~10-30 KB)
+ *   public/icon-fonts/material-symbols-rounded-full.woff2     full font, fallback only
+ *   app/assets/css/material-symbols.generated.css             @font-face pair (add it to the site's `css`)
+ *
+ * The fonts live under /icon-fonts/ (not /fonts/) because @nuxt/fonts owns the /fonts/ prefix
+ * and its dev-server middleware 404s any file it didn't render itself.
+ *
+ * The generated CSS declares the full font first (unicode-range: U+E000-F8FF) and the subset
+ * second, so browsers use the tiny subset for every known icon and only download the full font
+ * if an unknown codepoint (e.g. from runtime data) ever renders.
+ */
+
+import { copyFileSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, extname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import subsetFont from 'subset-font'
+
+const siteRoot = process.cwd()
+const layerRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const layerRequire = createRequire(join(layerRoot, 'package.json'))
+const siteRequire = createRequire(join(siteRoot, 'package.json'))
+
+function resolveFrom(specifier) {
+  try {
+    return siteRequire.resolve(specifier)
+  } catch {
+    return layerRequire.resolve(specifier)
+  }
+}
+
+function installedPackageDir(name) {
+  try {
+    return dirname(siteRequire.resolve(`${name}/package.json`))
+  } catch {
+    return null
+  }
+}
+
+function localLayerDirs() {
+  const layersDir = join(siteRoot, 'layers')
+  try {
+    return readdirSync(layersDir).map(entry => join(layersDir, entry)).filter(dir => statSync(dir).isDirectory())
+  } catch {
+    return []
+  }
+}
+
+const SOURCE_FONT = join(dirname(resolveFrom('@material-symbols/font-700/package.json')), 'material-symbols-rounded.woff2')
+const OUT_DIR = join(siteRoot, 'public/icon-fonts')
+const OUT_SUBSET = join(OUT_DIR, 'material-symbols-rounded-subset.woff2')
+const OUT_FULL = join(OUT_DIR, 'material-symbols-rounded-full.woff2')
+const OUT_CSS = join(siteRoot, 'app/assets/css/material-symbols.generated.css')
+
+const SOURCE_ROOTS = [siteRoot, ...localLayerDirs(), layerRoot, installedPackageDir('@giancarlosgza/blog-site-layer')]
+const SCAN_ROOTS = [
+  ...SOURCE_ROOTS.filter(Boolean).flatMap(root => ['app', 'shared', 'server'].map(dir => resolve(root, dir))),
+  dirname(resolveFrom('@colorffy/ui'))
+]
+const SCAN_EXTENSIONS = new Set(['.vue', '.ts', '.js', '.mjs', '.cjs', '.scss', '.css', '.json'])
+const SKIP_DIRS = new Set(['node_modules', '.nuxt', '.output'])
+
+const ENTITY_REGEX = /&#x([0-9a-f]{2,6});/gi
+// eslint-disable-next-line regexp/no-obscure-range -- the Private Use Area, where Material Symbols glyphs live
+const PUA_REGEX = /[-]/gu
+
+function collectFiles(dir, files = []) {
+  let entries
+  try {
+    entries = readdirSync(dir)
+  } catch {
+    return files
+  }
+  for (const entry of entries) {
+    const full = join(dir, entry)
+    const stats = statSync(full)
+    if (stats.isDirectory()) {
+      if (!SKIP_DIRS.has(entry))
+        collectFiles(full, files)
+    } else if (SCAN_EXTENSIONS.has(extname(entry))) {
+      files.push(full)
+    }
+  }
+  return files
+}
+
+function extractCodepoints(files) {
+  const codepoints = new Set()
+  for (const file of files) {
+    const content = readFileSync(file, 'utf8')
+    for (const match of content.matchAll(ENTITY_REGEX))
+      codepoints.add(Number.parseInt(match[1], 16))
+    for (const match of content.matchAll(PUA_REGEX))
+      codepoints.add(match[0].codePointAt(0))
+  }
+  // Only keep Private Use Area codepoints (where Material Symbols glyphs live)
+  return [...codepoints].filter(cp => cp >= 0xE000 && cp <= 0xF8FF).sort((a, b) => a - b)
+}
+
+const files = [...new Set(SCAN_ROOTS)].flatMap(dir => collectFiles(dir))
+const codepoints = extractCodepoints(files)
+
+if (codepoints.length === 0)
+  throw new Error('subset-icons: no Material Symbols codepoints found — scan roots misconfigured?')
+
+const sourceFont = readFileSync(SOURCE_FONT)
+const subsetText = String.fromCodePoint(...codepoints)
+const subsetBuffer = await subsetFont(sourceFont, subsetText, { targetFormat: 'woff2' })
+
+mkdirSync(OUT_DIR, { recursive: true })
+writeFileSync(OUT_SUBSET, subsetBuffer)
+copyFileSync(SOURCE_FONT, OUT_FULL)
+
+// Material Symbols ships asymmetric vertical metrics (hhea ascent 1056 vs descent 96 per 960 UPM),
+// so its em-centered glyphs render above the center of a `line-height: 1` box. Normalizing the
+// line-box metrics to ascent 100% / descent 0% puts the glyph on the box center.
+const METRIC_OVERRIDES = `    ascent-override: 100%;
+    descent-override: 0%;
+    line-gap-override: 0%;`
+
+const css = `/* AUTO-GENERATED by blog-layer-subset-icons — do not edit by hand.
+ * ${codepoints.length} icon codepoints found across ${files.length} scanned files.
+ * font-display: block avoids flashing raw codepoints while the (preloaded,
+ * tiny) subset loads. ascent/descent overrides center the glyphs vertically.
+ *
+ * Face order matters: the FULL fallback is declared first and keeps a
+ * unicode-range so it is ONLY downloaded when an icon outside the subset is
+ * rendered. The SUBSET is declared last (so it wins for every glyph it has)
+ * and has NO unicode-range, which makes it the line-box/strut font for the
+ * element, so its ascent/descent overrides reliably center the glyph. */
+@layer base.symbols {
+  @font-face {
+    font-family: "Material Symbols Rounded";
+    font-style: normal;
+    font-weight: 700;
+    font-display: block;
+${METRIC_OVERRIDES}
+    src: url("/icon-fonts/material-symbols-rounded-full.woff2") format("woff2");
+    unicode-range: U+E000-F8FF;
+  }
+
+  @font-face {
+    font-family: "Material Symbols Rounded";
+    font-style: normal;
+    font-weight: 700;
+    font-display: block;
+${METRIC_OVERRIDES}
+    src: url("/icon-fonts/material-symbols-rounded-subset.woff2") format("woff2");
+  }
+}
+`
+mkdirSync(dirname(OUT_CSS), { recursive: true })
+writeFileSync(OUT_CSS, css)
+
+const sizeKb = buffer => `${(buffer.length / 1024).toFixed(1)} KB`
+console.log(`subset-icons: ${codepoints.length} codepoints from ${files.length} files`)
+console.log(`subset-icons: subset ${sizeKb(subsetBuffer)} (full font ${sizeKb(sourceFont)}) -> public/icon-fonts/`)

package/server/api/blog/_sitemap-urls.ts

@@ -0,0 +1,38 @@
+import { getFirestore } from 'firebase-admin/firestore'
+
+/** Firestore reads behind the sitemap, cached for an hour (thrown errors are not cached). */
+const readSitemapUrls = defineCachedFunction(async () => {
+  const db = getFirestore()
+  const [posts, tagsSnapshot, authorsSnapshot, seriesSnapshot] = await Promise.all([
+    readPublishedPosts(publishedPostsQuery().orderBy('createdAt', 'desc').limit(SITEMAP_POST_LIMIT)),
+    db.collection('tags').get(),
+    db.collection('authors').get(),
+    db.collection('series').get()
+  ])
+
+  return buildSitemapUrls({
+    posts,
+    tags: tagsSnapshot.docs.map(item => toTag(item.id, item.data())),
+    authors: authorsSnapshot.docs.map(item => toAuthor(item.id, item.data())),
+    series: seriesSnapshot.docs.map(item => toSeries(item.id, item.data())),
+    basePath: useRuntimeConfig().public.blog.basePath
+  })
+}, {
+  name: 'sitemap-urls',
+  maxAge: 3600,
+  swr: true,
+  getKey: () => 'all'
+})
+
+/**
+ * Sitemap source for `@nuxtjs/sitemap`: post, tag, author and series URLs read with the
+ * Admin SDK (`server/utils/sitemap.ts`). Degrades to an empty list if Firestore fails.
+ */
+export default defineSitemapEventHandler(async () => {
+  try {
+    return await readSitemapUrls()
+  } catch (error) {
+    console.log('[sitemap] Firestore read failed', error)
+    return []
+  }
+})

package/server/api/blog/authors/[slug].get.ts

@@ -0,0 +1,42 @@
+import type { H3Event } from 'h3'
+import type { IAuthorPageResponse } from '#blog/shared/types/api'
+import { getFirestore } from 'firebase-admin/firestore'
+
+/** Query params, normalized once for both the handler and the cache key. */
+function readParams(event: H3Event) {
+  return {
+    slug: getRouterParam(event, 'slug', { decode: true })?.trim() ?? '',
+    page: parsePage(getQuery(event).page)
+  }
+}
+
+/** An author (by public slug) and their published posts, newest first. Query: `page` (default 1). */
+export default defineCachedEventHandler(async (event): Promise<IAuthorPageResponse> => {
+  const { slug, page } = readParams(event)
+  if (!slug)
+    notFound('Author not found')
+  if (page === null)
+    throw createError({ statusCode: 400, statusMessage: 'Invalid page' })
+
+  try {
+    const snapshot = await getFirestore().collection('authors').where('slug', '==', slug).limit(1).get()
+    const authorDoc = snapshot.docs[0]
+    if (!authorDoc)
+      notFound('Author not found')
+
+    const author = toAuthor(authorDoc.id, authorDoc.data())
+    const { items, hasMore } = await listPublishedPosts(page, POSTS_PAGE_SIZE, query =>
+      query.where('authorUuid', '==', authorDoc.id))
+    return { author, posts: items, hasMore }
+  } catch (error) {
+    failRead('author', error)
+  }
+}, {
+  name: 'blog-author',
+  maxAge: 300,
+  swr: true,
+  getKey: (event) => {
+    const { slug, page } = readParams(event)
+    return pagedCacheKey(slug, page)
+  }
+})

package/server/api/blog/featured.get.ts

@@ -0,0 +1,18 @@
+import type { IFeaturedPostsResponse } from '#blog/shared/types/api'
+
+/**
+ * Featured posts for the home hero (`featured == true`, published, max 3). Kept out of
+ * `/api/posts/*` so it can never shadow a post whose slug is "featured".
+ */
+export default defineCachedEventHandler(async (): Promise<IFeaturedPostsResponse> => {
+  try {
+    return { posts: await readFeaturedPosts() }
+  } catch (error) {
+    failRead('featured', error)
+  }
+}, {
+  name: 'blog-featured',
+  maxAge: 300,
+  swr: true,
+  getKey: () => 'home'
+})

package/server/api/blog/posts/[slug].get.ts

@@ -0,0 +1,116 @@
+import type { IAuthor } from '#blog/shared/models/author'
+import type { IPost } from '#blog/shared/models/post'
+import type { IPostPageResponse, IPostSeries } from '#blog/shared/types/api'
+import { getFirestore } from 'firebase-admin/firestore'
+
+/** Constants */
+const RELATED_LIMIT = 3
+// array-contains-any accepts at most 10 values.
+const RELATED_MAX_TAGS = 10
+
+/** Helpers */
+// Secondary reads degrade to empty (as the old page's timeouts did) instead of failing the article.
+function optional<T>(label: string, read: Promise<T>, fallback: T): Promise<T> {
+  return read.catch((error) => {
+    console.log(`[post] ${label} read failed`, error)
+    return fallback
+  })
+}
+
+async function readAuthor(uid: string | undefined): Promise<IAuthor | null> {
+  if (!uid)
+    return null
+
+  const snapshot = await getFirestore().collection('authors').doc(uid).get()
+  const data = snapshot.data()
+  return data ? toAuthor(snapshot.id, data) : null
+}
+
+async function readRelated(post: IPost, slug: string): Promise<IPost[]> {
+  const tags = (post.tags ?? []).slice(0, RELATED_MAX_TAGS)
+  if (!tags.length)
+    return []
+
+  // One extra so the current post can be dropped.
+  const posts = await readPublishedPosts(
+    publishedPostsQuery()
+      .where('tags', 'array-contains-any', tags)
+      .orderBy('createdAt', 'desc')
+      .limit(RELATED_LIMIT + 1)
+  )
+  return posts.filter(item => (item.id ?? item.slug) !== slug).slice(0, RELATED_LIMIT)
+}
+
+async function readSibling(createdAt: unknown, direction: 'older' | 'newer'): Promise<IPost | null> {
+  if (createdAt == null)
+    return null
+
+  const query = direction === 'older'
+    ? publishedPostsQuery().where('createdAt', '<', createdAt).orderBy('createdAt', 'desc')
+    : publishedPostsQuery().where('createdAt', '>', createdAt).orderBy('createdAt', 'asc')
+  const [sibling] = await readPublishedPosts(query.limit(1))
+  return sibling ?? null
+}
+
+async function readPostSeries(post: IPost, slug: string): Promise<IPostSeries | null> {
+  const seriesSlug = post.seriesSlug?.trim()
+  if (!seriesSlug || seriesSlug.includes('/'))
+    return null
+
+  const [series, posts] = await Promise.all([readSeries(seriesSlug), readSeriesPosts(seriesSlug)])
+  return series ? toPostSeries(series, posts, slug) : null
+}
+
+/**
+ * A published post with everything its page renders. The body is sanitized and anchored here,
+ * so the client never receives raw Firestore HTML and ships no sanitizer.
+ * 404 when the post is missing or unpublished; its body is only read once the post is public.
+ */
+export default defineCachedEventHandler(async (event): Promise<IPostPageResponse> => {
+  const slug = getRouterParam(event, 'slug', { decode: true })?.trim() ?? ''
+  // A "/" would address a subcollection path, not a post id.
+  if (!slug || slug.includes('/'))
+    notFound('Post not found')
+
+  try {
+    const db = getFirestore()
+    const postSnapshot = await db.collection('posts').doc(slug).get()
+    const data = postSnapshot.data()
+    const post = toPublishedPost(postSnapshot.id, data)
+    if (!post)
+      notFound('Post not found')
+
+    const [contentSnapshot, author, related, older, newer, series] = await Promise.all([
+      db.collection('postContents').doc(slug).get(),
+      readAuthor(post.authorUuid),
+      optional('related', readRelated(post, slug), []),
+      // Compared against the stored value (ms number or legacy Timestamp), not the serialized one.
+      optional('older', readSibling(data?.createdAt, 'older'), null),
+      optional('newer', readSibling(data?.createdAt, 'newer'), null),
+      optional('series', readPostSeries(post, slug), null)
+    ])
+
+    const rawContents = String(contentSnapshot.data()?.contents ?? '')
+    const article = addHeadingAnchors(sanitizeBlogHtml(rawContents))
+
+    return {
+      post,
+      contents: article.html,
+      headings: article.headings,
+      readingTime: estimateReadingTime(article.html),
+      excerpt: htmlToExcerpt(rawContents),
+      author,
+      related,
+      older,
+      newer,
+      series
+    }
+  } catch (error) {
+    failRead('post', error)
+  }
+}, {
+  name: 'blog-post',
+  maxAge: 300,
+  swr: true,
+  getKey: event => encodeKeyPart(getRouterParam(event, 'slug', { decode: true })?.trim())
+})

package/server/api/blog/posts/index.get.ts

@@ -0,0 +1,35 @@
+import type { H3Event } from 'h3'
+import type { IPostListResponse } from '#blog/shared/types/api'
+
+/** Query params, normalized once for both the handler and the cache key. */
+function readParams(event: H3Event) {
+  const query = getQuery(event)
+  return {
+    page: parsePage(query.page),
+    size: parseLimit(query.limit),
+    tag: parseText(query.tag)
+  }
+}
+
+/**
+ * Published posts newest first for the home feed and the `/page/N` archive.
+ * Query: `page` (default 1), `limit` (1-50, default 12), `tag` (exact tag name).
+ */
+export default defineCachedEventHandler(async (event): Promise<IPostListResponse> => {
+  const { page, size, tag } = readParams(event)
+  if (page === null)
+    throw createError({ statusCode: 400, statusMessage: 'Invalid page' })
+
+  try {
+    const { items, hasMore } = await listPublishedPosts(page, size, query =>
+      tag ? query.where('tags', 'array-contains', tag) : query)
+    return { posts: items, hasMore }
+  } catch (error) {
+    failRead('posts', error)
+  }
+}, {
+  name: 'blog-posts',
+  maxAge: 300,
+  swr: true,
+  getKey: event => postListCacheKey(readParams(event))
+})

package/server/api/blog/series/[slug].get.ts

@@ -0,0 +1,29 @@
+import type { H3Event } from 'h3'
+import type { ISeriesPageResponse } from '#blog/shared/types/api'
+
+function readSlug(event: H3Event): string {
+  return getRouterParam(event, 'slug', { decode: true })?.trim() ?? ''
+}
+
+/** A series (`series/{slug}`) and its published parts in reading order. 404 for an unknown series. */
+export default defineCachedEventHandler(async (event): Promise<ISeriesPageResponse> => {
+  const slug = readSlug(event)
+  // A "/" would address a subcollection path, not a series id.
+  if (!slug || slug.includes('/'))
+    notFound('Series not found')
+
+  try {
+    const [series, posts] = await Promise.all([readSeries(slug), readSeriesPosts(slug)])
+    if (!series)
+      notFound('Series not found')
+
+    return { series, posts }
+  } catch (error) {
+    failRead('series', error)
+  }
+}, {
+  name: 'blog-series',
+  maxAge: 300,
+  swr: true,
+  getKey: event => encodeKeyPart(readSlug(event))
+})

package/server/api/blog/series/index.get.ts

@@ -0,0 +1,15 @@
+import type { ISeriesListResponse } from '#blog/shared/types/api'
+
+/** Series names by slug for the post card badge. */
+export default defineCachedEventHandler(async (): Promise<ISeriesListResponse> => {
+  try {
+    return { series: await readSeriesList() }
+  } catch (error) {
+    failRead('series-list', error)
+  }
+}, {
+  name: 'blog-series-list',
+  maxAge: 300,
+  swr: true,
+  getKey: () => 'all'
+})

package/server/api/blog/settings.get.ts

@@ -0,0 +1,18 @@
+import type { ISettingsResponse } from '#blog/shared/types/api'
+import { getFirestore } from 'firebase-admin/firestore'
+
+/** Site-wide `settings/general` (branding + SEO defaults) for the layout, navbar and footer. */
+export default defineCachedEventHandler(async (): Promise<ISettingsResponse> => {
+  try {
+    const snapshot = await getFirestore().collection('settings').doc('general').get()
+    const data = snapshot.data()
+    return { settings: data ? toSettings(data) : null }
+  } catch (error) {
+    failRead('settings', error)
+  }
+}, {
+  name: 'blog-settings',
+  maxAge: 300,
+  swr: true,
+  getKey: () => 'general'
+})

package/server/api/blog/tags/[tag].get.ts

@@ -0,0 +1,35 @@
+import type { H3Event } from 'h3'
+import type { ITagPageResponse } from '#blog/shared/types/api'
+
+/** Query params, normalized once for both the handler and the cache key. */
+function readParams(event: H3Event) {
+  return {
+    tag: getRouterParam(event, 'tag', { decode: true })?.trim() ?? '',
+    page: parsePage(getQuery(event).page)
+  }
+}
+
+/** Published posts carrying a tag, newest first. Query: `page` (default 1). */
+export default defineCachedEventHandler(async (event): Promise<ITagPageResponse> => {
+  const { tag, page } = readParams(event)
+  if (!tag)
+    notFound('Tag not found')
+  if (page === null)
+    throw createError({ statusCode: 400, statusMessage: 'Invalid page' })
+
+  try {
+    const { items, hasMore } = await listPublishedPosts(page, POSTS_PAGE_SIZE, query =>
+      query.where('tags', 'array-contains', tag))
+    return { tag, posts: items, hasMore }
+  } catch (error) {
+    failRead('tag', error)
+  }
+}, {
+  name: 'blog-tag',
+  maxAge: 300,
+  swr: true,
+  getKey: (event) => {
+    const { tag, page } = readParams(event)
+    return pagedCacheKey(tag, page)
+  }
+})

package/server/api/blog/tags/index.get.ts

@@ -0,0 +1,17 @@
+import type { ITagsResponse } from '#blog/shared/types/api'
+import { getFirestore } from 'firebase-admin/firestore'
+
+/** Every tag, most used first (home tag filter). */
+export default defineCachedEventHandler(async (): Promise<ITagsResponse> => {
+  try {
+    const snapshot = await getFirestore().collection('tags').orderBy('count', 'desc').get()
+    return { tags: snapshot.docs.map(item => toTag(item.id, item.data())) }
+  } catch (error) {
+    failRead('tags', error)
+  }
+}, {
+  name: 'blog-tags',
+  maxAge: 300,
+  swr: true,
+  getKey: () => 'all'
+})

package/server/handlers/rss.xml.ts

@@ -0,0 +1,53 @@
+import { getFirestore } from 'firebase-admin/firestore'
+
+/**
+ * RSS 2.0 feed of the latest published, indexable posts with their sanitized bodies, served at
+ * `<basePath>/rss.xml` (registered by `blog-module.ts`). Cached like the read endpoints; a failed
+ * read answers an uncached 503.
+ */
+export default defineCachedEventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig(event)
+  const siteUrl = (getSiteConfig(event).url || runtimeConfig.siteUrl).replace(/\/+$/, '')
+  const basePath = runtimeConfig.public.blog.basePath
+  const brand = useAppConfig().blog
+
+  try {
+    const db = getFirestore()
+    const [settingsSnapshot, posts] = await Promise.all([
+      db.collection('settings').doc('general').get(),
+      readPublishedPosts(publishedPostsQuery().orderBy('createdAt', 'desc').limit(RSS_QUERY_LIMIT))
+    ])
+    const feedPosts = selectFeedPosts(posts)
+    const contentSnapshots = feedPosts.length
+      ? await db.getAll(...feedPosts.map(post => db.collection('postContents').doc(postSlug(post))))
+      : []
+
+    const settingsData = settingsSnapshot.data()
+    const settings = settingsData ? toSettings(settingsData) : null
+    const items = feedPosts.map((post, index) => buildRssItem({
+      post,
+      siteUrl,
+      basePath,
+      contents: String(contentSnapshots[index]?.data()?.contents ?? ''),
+      defaultAuthor: brand.defaultAuthor
+    }))
+
+    setResponseHeader(event, 'content-type', 'application/rss+xml; charset=utf-8')
+    return buildRssFeed({
+      title: settings?.blogName?.trim() || brand.name,
+      description: settings?.blogDescription?.trim() || brand.description,
+      siteUrl: toBlogUrl(siteUrl, basePath),
+      feedUrl: toBlogUrl(siteUrl, basePath, '/rss.xml'),
+      imageUrl: settings?.logoURL,
+      lastBuildDate: latestPostDate(feedPosts),
+      items
+    })
+  } catch (error) {
+    failRead('rss', error)
+  }
+}, {
+  name: 'rss',
+  maxAge: 300,
+  swr: true,
+  getKey: () => 'feed'
+})

package/server/plugins/firebase.ts

@@ -0,0 +1,20 @@
+import { applicationDefault, getApps, initializeApp } from 'firebase-admin/app'
+
+/**
+ * Default Admin SDK app for server routes: the cached public read endpoints.
+ */
+export default defineNitroPlugin(() => {
+  // Skip firebase initialization during build/prerender
+  if (import.meta.prerender)
+    return
+
+  if (getApps().some(app => app.name === '[DEFAULT]'))
+    return
+
+  try {
+    initializeApp({ credential: applicationDefault() })
+  } catch (error) {
+    // Unlike blog-admin, a failed init must not crash the server: reads then answer 503 (never cached).
+    console.log('[firebase-admin] Admin SDK failed to initialize. Blog data will not load.', error)
+  }
+})