starlight-seo 0.2.0

package/index.js

@@ -0,0 +1,66 @@
+import { fileURLToPath } from 'node:url'
+import { audit, report } from './lib/audit.js'
+import { normalize } from './lib/options.js'
+
+const OPTIONS = 'virtual:starlight-seo/options'
+const EXTEND = 'virtual:starlight-seo/extend'
+
+const virtual = (options, root) => {
+  const extend = options.extend ? fileURLToPath(new URL(options.extend, root)) : null
+  return {
+    name: 'starlight-seo:virtual',
+    resolveId(id) {
+      if (id === OPTIONS || id === EXTEND) return `\0${id}`
+    },
+    load(id) {
+      if (id === `\0${OPTIONS}`) return `export default ${JSON.stringify(options)}`
+      if (id === `\0${EXTEND}`) {
+        return extend
+          ? `import * as user from ${JSON.stringify(extend)}\nconst hooks = { ...user }\nexport const page = hooks.page\nexport const graph = hooks.graph`
+          : 'export const page = undefined\nexport const graph = undefined'
+      }
+    },
+  }
+}
+
+export default function starlightSeo(userOptions = {}) {
+  return {
+    name: 'starlight-seo',
+    hooks: {
+      'config:setup'({ config, astroConfig, addRouteMiddleware, addIntegration }) {
+        const root = !config.defaultLocale || config.defaultLocale === 'root'
+        const options = normalize(userOptions, {
+          site: astroConfig.site,
+          delimiter: config.titleDelimiter,
+          defaultPrefix: root ? '' : `/${config.defaultLocale}`,
+        })
+
+        addRouteMiddleware({ entrypoint: 'starlight-seo/middleware', order: 'post' })
+
+        addIntegration({
+          name: 'starlight-seo',
+          hooks: {
+            'astro:config:setup': ({ config: astro, updateConfig }) => {
+              updateConfig({
+                vite: {
+                  plugins: [virtual(options, astro.root)],
+                  ssr: { noExternal: ['starlight-seo'] },
+                },
+              })
+            },
+            'astro:build:done': async ({ dir, logger }) => {
+              if (options.audit.failOn === 'off') return
+              const result = await audit(fileURLToPath(dir), options)
+              report(result, logger, options.audit.limit)
+              const failed = result.errors > 0 || (options.audit.failOn === 'warn' && result.warnings > 0)
+              if (failed) throw new Error(`[starlight-seo] audit failed: ${result.errors} error(s), ${result.warnings} warning(s)`)
+            },
+          },
+        })
+      },
+    },
+  }
+}
+
+export { audit } from './lib/audit.js'
+export { normalize } from './lib/options.js'

package/lib/audit.d.ts

@@ -0,0 +1,17 @@
+export interface AuditFinding {
+  rule: string
+  level: 'error' | 'warn'
+  path: string
+  message: string
+}
+
+export interface AuditResult {
+  pages: number
+  findings: AuditFinding[]
+  errors: number
+  warnings: number
+}
+
+export function audit(root: string, options: unknown): Promise<AuditResult>
+export function inspect(html: string): Record<string, unknown>
+export function report(result: AuditResult, logger: { info(message: string): void; warn(message: string): void; error(message: string): void }, limit?: number): void

package/lib/audit.js

@@ -0,0 +1,164 @@
+import { existsSync } from 'node:fs'
+import { readFile, readdir } from 'node:fs/promises'
+import { join, relative, resolve, sep } from 'node:path'
+import { anyMatch, length } from './text.js'
+
+const ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' }
+
+const decode = (value) =>
+  String(value)
+    .replace(/&#x([0-9a-f]+);/gi, (whole, code) => String.fromCodePoint(parseInt(code, 16)))
+    .replace(/&#(\d+);/g, (whole, code) => String.fromCodePoint(Number(code)))
+    .replace(/&(\w+);/g, (whole, name) => ENTITIES[name] ?? whole)
+
+const attributes = (source) => {
+  const result = {}
+  for (const match of source.matchAll(/([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) result[match[1].toLowerCase()] = decode(match[2] ?? match[3])
+  return result
+}
+
+async function* walk(directory) {
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const full = join(directory, entry.name)
+    if (entry.isDirectory()) yield* walk(full)
+    else if (entry.name.endsWith('.html')) yield full
+  }
+}
+
+const routeOf = (root, file) => {
+  const path = `/${relative(root, file).split(sep).join('/')}`
+  return path.endsWith('/index.html') ? path.slice(0, -'index.html'.length) : path
+}
+
+const trim = (value) => value.replace(/(index)?\.html$/, '').replace(/\/+$/, '') || '/'
+
+const sameRoute = (canonical, path) => {
+  try {
+    return trim(decodeURIComponent(new URL(canonical).pathname)) === trim(path)
+  } catch {
+    return true
+  }
+}
+
+const localPath = (href) => {
+  const { pathname } = new URL(href)
+  try {
+    return decodeURIComponent(pathname)
+  } catch {
+    return pathname
+  }
+}
+
+export function inspect(html) {
+  const end = html.search(/<\/head>/i)
+  const head = end === -1 ? html : html.slice(0, end)
+  const tags = [...head.matchAll(/<(meta|link)\b([^>]*)>/gi)].map((match) => ({ tag: match[1].toLowerCase(), attrs: attributes(match[2]) }))
+  const meta = (key, value) => tags.find((entry) => entry.tag === 'meta' && entry.attrs[key] === value)?.attrs.content
+  const title = head.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i)
+  const scripts = [...html.matchAll(/<script\b[^>]*type\s*=\s*["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi)].map((match) => match[1])
+  const nodes = []
+  let invalid = 0
+  for (const script of scripts) {
+    try {
+      const parsed = JSON.parse(script)
+      for (const item of [].concat(parsed)) nodes.push(...(Array.isArray(item?.['@graph']) ? item['@graph'] : [item]))
+    } catch {
+      invalid += 1
+    }
+  }
+  return {
+    title: title ? decode(title[1]).trim() : undefined,
+    description: meta('name', 'description'),
+    ogTitle: meta('property', 'og:title'),
+    ogImage: meta('property', 'og:image'),
+    robots: meta('name', 'robots'),
+    canonical: tags.find((entry) => entry.tag === 'link' && entry.attrs.rel === 'canonical')?.attrs.href,
+    redirect: tags.some((entry) => entry.tag === 'meta' && entry.attrs['http-equiv']?.toLowerCase() === 'refresh'),
+    scripts: scripts.length,
+    invalid,
+    nodes,
+  }
+}
+
+export async function audit(root, options) {
+  const levels = options.audit.rules
+  const excluded = [...options.exclude, ...options.audit.exclude]
+  const findings = []
+  const add = (rule, path, message) => {
+    if (levels[rule] !== 'off') findings.push({ rule, level: levels[rule], path, message })
+  }
+  const titles = new Map()
+  const descriptions = new Map()
+  let pages = 0
+
+  for await (const file of walk(root)) {
+    const path = routeOf(root, file)
+    if (anyMatch(excluded, path)) continue
+    const page = inspect(await readFile(file, 'utf8'))
+    if (page.redirect || /\bnoindex\b/i.test(page.robots ?? '')) continue
+    if (page.canonical && !sameRoute(page.canonical, path)) continue
+    pages += 1
+
+    if (!page.title) add('title.missing', path, 'no <title>')
+    else {
+      const size = length(page.title)
+      if (size < options.title.min) add('title.short', path, `${size} < ${options.title.min}: ${page.title}`)
+      if (size > options.title.max) add('title.long', path, `${size} > ${options.title.max}: ${page.title}`)
+      titles.set(page.title, [...(titles.get(page.title) ?? []), path])
+    }
+
+    if (!page.description) add('description.missing', path, 'no meta description')
+    else {
+      const size = length(page.description)
+      if (size < options.description.min) add('description.short', path, `${size} < ${options.description.min}`)
+      if (size > options.description.max) add('description.long', path, `${size} > ${options.description.max}`)
+      descriptions.set(page.description, [...(descriptions.get(page.description) ?? []), path])
+    }
+
+    if (!page.canonical) add('canonical.missing', path, 'no canonical link')
+
+    if (page.invalid > 0) add('jsonld.invalid', path, `${page.invalid} JSON-LD block(s) do not parse`)
+    if (page.scripts === 0) add('jsonld.missing', path, 'no JSON-LD')
+    for (const node of page.nodes) {
+      const id = String(node?.['@id'] ?? '')
+      const name = id.endsWith('#article') ? node.headline : id.endsWith('#webpage') ? node.name : undefined
+      if (name !== undefined && page.ogTitle !== undefined && name !== page.ogTitle) {
+        add('jsonld.mismatch', path, `${id} says "${name}", og:title says "${page.ogTitle}"`)
+      }
+    }
+
+    if (!page.ogImage) add('image.missing', path, 'no og:image')
+    else if (page.ogImage.startsWith(`${options.origin}/`)) {
+      const local = localPath(page.ogImage)
+      const target = resolve(root, `.${local}`)
+      const inside = target.startsWith(`${resolve(root)}${sep}`)
+      if (!inside || !existsSync(target)) add('image.broken', path, `${local} is not in the build output`)
+    }
+  }
+
+  for (const [title, paths] of titles) {
+    if (paths.length > 1) for (const path of paths) add('title.duplicate', path, `shared by ${paths.length} pages: ${title}`)
+  }
+  for (const [, paths] of descriptions) {
+    if (paths.length > 1) for (const path of paths) add('description.duplicate', path, `shared by ${paths.length} pages`)
+  }
+
+  return {
+    pages,
+    findings,
+    errors: findings.filter((finding) => finding.level === 'error').length,
+    warnings: findings.filter((finding) => finding.level === 'warn').length,
+  }
+}
+
+export function report(result, logger, limit = 15) {
+  const groups = new Map()
+  for (const finding of result.findings) groups.set(finding.rule, [...(groups.get(finding.rule) ?? []), finding])
+  for (const [rule, list] of groups) {
+    const write = list[0].level === 'error' ? logger.error.bind(logger) : logger.warn.bind(logger)
+    write(`${rule}: ${list.length} page(s)`)
+    for (const finding of list.slice(0, limit)) write(`  ${finding.path}  ${finding.message}`)
+    if (list.length > limit) write(`  ... and ${list.length - limit} more`)
+  }
+  logger.info(`audited ${result.pages} page(s): ${result.errors} error(s), ${result.warnings} warning(s)`)
+}

package/lib/breadcrumbs.js

@@ -0,0 +1,33 @@
+const firstLink = (entry) => {
+  for (const child of entry.entries ?? []) {
+    if (child.type === 'link' && child.href) return child.href
+    const nested = firstLink(child)
+    if (nested) return nested
+  }
+  return undefined
+}
+
+const walk = (entries, trail) => {
+  for (const entry of entries ?? []) {
+    if (entry.type === 'link' && entry.isCurrent) return [...trail, { label: entry.label, href: entry.href, current: true }]
+    if (entry.type === 'group') {
+      const found = walk(entry.entries, [...trail, { label: entry.label, href: firstLink(entry), group: true }])
+      if (found) return found
+    }
+  }
+  return null
+}
+
+const distinct = (crumbs) => crumbs.filter((crumb, index) => !crumb.href || crumb.href !== crumbs[index - 1]?.href)
+
+export function breadcrumbs({ sidebar, home, label, pathname, isHome, groups }) {
+  if (isHome) return []
+  const found = walk(sidebar, []) ?? [{ label, href: pathname, current: true }]
+  const current = found.at(-1)
+  const middle = found
+    .filter((crumb) => !crumb.current)
+    .filter(() => groups !== 'skip')
+    .map((crumb) => (groups === 'plain' ? { label: crumb.label } : { label: crumb.label, href: crumb.href }))
+    .filter((crumb) => crumb.href !== pathname)
+  return [{ label: home.label, href: home.href }, ...distinct(middle), { label: current.label ?? label, href: pathname }]
+}

package/lib/graph.js

@@ -0,0 +1,138 @@
+const ARTICLES = new Set([
+  'Article',
+  'TechArticle',
+  'APIReference',
+  'BlogPosting',
+  'NewsArticle',
+  'Report',
+  'ScholarlyArticle',
+  'SocialMediaPosting',
+  'DiscussionForumPosting',
+])
+
+export const isArticle = (type) => ARTICLES.has(type)
+
+const day = (value) => (value instanceof Date ? value.toISOString().slice(0, 10) : value ? String(value).slice(0, 10) : undefined)
+
+const compact = (node) => Object.fromEntries(Object.entries(node).filter(([, value]) => value !== undefined && value !== null && value !== ''))
+
+const thing = (value) => {
+  if (!value) return undefined
+  if (typeof value === 'string') return { '@type': 'Thing', name: value }
+  return compact({ '@type': value.type ?? 'Thing', name: value.name, description: value.description, url: value.url, sameAs: value.sameAs })
+}
+
+const things = (value) => {
+  if (!value) return undefined
+  const list = [].concat(value).map(thing).filter(Boolean)
+  return list.length === 0 ? undefined : list.length === 1 ? list[0] : list
+}
+
+export const ids = (site, publisher, url) => ({
+  website: `${site.origin}/#website`,
+  publisher: publisher.id ?? `${publisher.url ?? `${site.origin}/`}#${publisher.type === 'Person' ? 'person' : 'organization'}`,
+  webpage: `${url}#webpage`,
+  article: `${url}#article`,
+  breadcrumb: `${url}#breadcrumb`,
+  image: `${url}#primaryimage`,
+})
+
+export function buildGraph({ site, publisher, page }) {
+  const id = ids(site, publisher, page.url)
+  const publisherRef = { '@id': id.publisher }
+  const article = isArticle(page.type)
+  const hasTrail = page.breadcrumbs.length > 1
+  const about = things(page.about)
+
+  const nodes = [
+    compact({
+      '@type': 'WebSite',
+      '@id': id.website,
+      url: `${site.origin}/`,
+      name: site.name,
+      alternateName: site.alternateName,
+      description: site.description,
+      inLanguage: page.language,
+      publisher: publisherRef,
+      about: things(site.about),
+    }),
+    compact({
+      '@type': publisher.type ?? 'Organization',
+      '@id': id.publisher,
+      name: publisher.name,
+      url: publisher.url,
+      logo: publisher.logo ? { '@type': 'ImageObject', url: publisher.logo } : undefined,
+      sameAs: publisher.sameAs,
+    }),
+    compact({
+      '@type': article ? 'WebPage' : page.type,
+      '@id': id.webpage,
+      url: page.url,
+      name: page.title,
+      description: page.description,
+      inLanguage: page.language,
+      isPartOf: { '@id': id.website },
+      breadcrumb: hasTrail ? { '@id': id.breadcrumb } : undefined,
+      primaryImageOfPage: page.image ? { '@id': id.image } : undefined,
+      datePublished: day(page.published),
+      dateModified: day(page.modified),
+      about: article ? undefined : about,
+    }),
+  ]
+
+  if (page.image) {
+    nodes.push(
+      compact({
+        '@type': 'ImageObject',
+        '@id': id.image,
+        url: page.image.url,
+        contentUrl: page.image.url,
+        width: page.image.width,
+        height: page.image.height,
+        caption: page.image.alt,
+      }),
+    )
+  }
+
+  if (article) {
+    nodes.push(
+      compact({
+        '@type': page.type,
+        '@id': id.article,
+        headline: page.title,
+        description: page.description,
+        inLanguage: page.language,
+        url: page.url,
+        mainEntityOfPage: { '@id': id.webpage },
+        isPartOf: { '@id': id.webpage },
+        author: publisherRef,
+        publisher: publisherRef,
+        datePublished: day(page.published),
+        dateModified: day(page.modified ?? page.published),
+        image: page.image ? { '@id': id.image } : undefined,
+        articleSection: page.section,
+        keywords: page.keywords?.length ? page.keywords.join(', ') : undefined,
+        about,
+      }),
+    )
+  }
+
+  if (hasTrail) {
+    nodes.push({
+      '@type': 'BreadcrumbList',
+      '@id': id.breadcrumb,
+      itemListElement: page.breadcrumbs.map((crumb, index) =>
+        compact({
+          '@type': 'ListItem',
+          position: index + 1,
+          name: crumb.label,
+          item: crumb.href ? new URL(crumb.href, site.origin).href : undefined,
+        }),
+      ),
+    })
+  }
+
+  return nodes
+}
+
+export const wrap = (nodes) => ({ '@context': 'https://schema.org', '@graph': nodes })

package/lib/head.js

@@ -0,0 +1,72 @@
+import { buildGraph, wrap } from './graph.js'
+import { serialize } from './text.js'
+
+const isMeta = (entry, key, value) => entry.tag === 'meta' && entry.attrs?.[key] === value
+
+const setMeta = (head, key, value, content) => {
+  const existing = head.find((entry) => isMeta(entry, key, value))
+  if (content === undefined || content === null || content === '') {
+    if (existing) head.splice(head.indexOf(existing), 1)
+    return
+  }
+  if (existing) existing.attrs.content = String(content)
+  else head.push({ tag: 'meta', attrs: { [key]: value, content: String(content) } })
+}
+
+const iso = (value) => (value instanceof Date ? value.toISOString() : value ? new Date(value).toISOString() : undefined)
+
+export const canonicalOf = (head) => {
+  const link = head.find((entry) => entry.tag === 'link' && entry.attrs?.rel === 'canonical')
+  return typeof link?.attrs?.href === 'string' ? link.attrs.href : undefined
+}
+
+export const setCanonical = (head, href) => {
+  const link = head.find((entry) => entry.tag === 'link' && entry.attrs?.rel === 'canonical')
+  if (link) link.attrs.href = href
+  else head.push({ tag: 'link', attrs: { rel: 'canonical', href } })
+  setMeta(head, 'property', 'og:url', href)
+}
+
+export function applyHead(head, page, options) {
+  const title = head.find((entry) => entry.tag === 'title')
+  if (title) title.content = page.headTitle
+  else head.push({ tag: 'title', content: page.headTitle })
+
+  setMeta(head, 'property', 'og:title', page.title)
+  setMeta(head, 'name', 'description', page.description)
+  setMeta(head, 'property', 'og:description', page.description)
+  setMeta(head, 'property', 'og:type', page.article ? 'article' : 'website')
+
+  if (page.image) {
+    setMeta(head, 'property', 'og:image', page.image.url)
+    setMeta(head, 'property', 'og:image:width', page.image.width)
+    setMeta(head, 'property', 'og:image:height', page.image.height)
+    setMeta(head, 'property', 'og:image:alt', page.image.alt)
+    setMeta(head, 'name', 'twitter:image', page.image.url)
+    setMeta(head, 'name', 'twitter:image:alt', page.image.alt)
+  } else {
+    setMeta(head, 'name', 'twitter:card', 'summary')
+  }
+
+  if (page.article) {
+    setMeta(head, 'property', 'article:published_time', iso(page.published))
+    setMeta(head, 'property', 'article:modified_time', iso(page.modified))
+  }
+
+  const hasRobots = head.some((entry) => isMeta(entry, 'name', 'robots'))
+  if (page.noindex) setMeta(head, 'name', 'robots', 'noindex, follow')
+  else if (options.robots && !hasRobots) setMeta(head, 'name', 'robots', options.robots)
+}
+
+export function graphOf(page, options) {
+  const publisher = {
+    ...options.publisher,
+    name: options.publisher.name ?? page.site.name,
+    url: options.publisher.url ?? `${page.site.origin}/`,
+  }
+  return buildGraph({ site: page.site, publisher, page })
+}
+
+export function pushGraph(head, nodes) {
+  head.push({ tag: 'script', attrs: { type: 'application/ld+json' }, content: serialize(wrap(nodes)) })
+}

package/lib/options.js

@@ -0,0 +1,87 @@
+const LEVELS = ['error', 'warn', 'off']
+
+export const RULES = {
+  'title.missing': 'error',
+  'title.short': 'warn',
+  'title.long': 'warn',
+  'title.duplicate': 'error',
+  'description.missing': 'error',
+  'description.short': 'warn',
+  'description.long': 'warn',
+  'description.duplicate': 'error',
+  'canonical.missing': 'error',
+  'jsonld.missing': 'warn',
+  'jsonld.invalid': 'error',
+  'jsonld.mismatch': 'error',
+  'image.missing': 'warn',
+  'image.broken': 'error',
+}
+
+const fail = (message) => {
+  throw new Error(`[starlight-seo] ${message}`)
+}
+
+export function normalize(user = {}, context = {}) {
+  const origin = context.site ? String(context.site).replace(/\/+$/, '') : undefined
+  if (!origin) fail('set `site` in the Astro config: canonical URLs and JSON-LD identifiers need an absolute origin')
+
+  const title = user.title ?? {}
+  const description = user.description ?? {}
+  const audit = user.audit === false ? { failOn: 'off' } : (user.audit ?? {})
+  const rules = { ...RULES, ...(audit.rules ?? {}) }
+  for (const [rule, level] of Object.entries(rules)) {
+    if (!(rule in RULES)) fail(`unknown audit rule "${rule}"`)
+    if (!LEVELS.includes(level)) fail(`audit rule "${rule}" has level "${level}", expected one of ${LEVELS.join(', ')}`)
+  }
+  const brand = title.brand ?? 'auto'
+  if (!['auto', 'always', 'never'].includes(brand)) fail('`title.brand` must be "auto", "always" or "never"')
+  const groups = user.breadcrumbs?.groups ?? 'link'
+  if (!['link', 'plain', 'skip'].includes(groups)) fail('`breadcrumbs.groups` must be "link", "plain" or "skip"')
+
+  if (!['canonical', 'keep'].includes(user.fallback ?? 'canonical')) fail('`fallback` must be "canonical" or "keep"')
+
+  const image = typeof user.image === 'string' ? { src: user.image } : user.image
+  const publisher = user.publisher ?? {}
+
+  return {
+    origin,
+    site: {
+      name: user.site?.name,
+      alternateName: user.site?.alternateName,
+      description: user.site?.description,
+      about: user.site?.about,
+    },
+    publisher: {
+      type: publisher.type ?? 'Organization',
+      id: publisher.id,
+      name: publisher.name,
+      url: publisher.url,
+      logo: publisher.logo,
+      sameAs: publisher.sameAs,
+    },
+    title: {
+      min: title.min ?? 30,
+      max: title.max ?? 60,
+      brand,
+      delimiter: title.delimiter ?? context.delimiter ?? '|',
+      templates: title.templates ?? [],
+      site: title.site,
+    },
+    description: { min: description.min ?? 70, max: description.max ?? 160 },
+    types: user.types ?? [],
+    defaultType: user.defaultType ?? 'TechArticle',
+    image: image ? { src: image.src, width: image.width ?? 1200, height: image.height ?? 630, alt: image.alt } : null,
+    robots: user.robots === undefined ? 'max-snippet:-1, max-image-preview:large, max-video-preview:-1' : user.robots,
+    breadcrumbs: { groups, home: user.breadcrumbs?.home },
+    exclude: user.exclude ?? ['/404/', '/404.html'],
+    extend: user.extend,
+    fallback: user.fallback ?? 'canonical',
+    defaultPrefix: context.defaultPrefix ?? '',
+    audit: {
+      failOn: audit.failOn ?? 'error',
+      exclude: audit.exclude ?? [],
+      limit: audit.limit ?? 15,
+      rules,
+    },
+  }
+}

package/lib/page.js

@@ -0,0 +1,75 @@
+import { breadcrumbs } from './breadcrumbs.js'
+import { isArticle } from './graph.js'
+import { resolveTitle } from './title.js'
+import { fill, firstMatch, pick } from './text.js'
+
+const slugOf = (path) => path.replace(/^\/+|\/+$/g, '') || 'index'
+
+const absolute = (value, origin) => new URL(value, `${origin}/`).href
+
+export function retitle(options, page, base) {
+  const brand = pick(options.title.site, page.language, page.locale) ?? page.site.name
+  const title = resolveTitle({ label: page.label, seoTitle: base, path: page.path, lang: page.language, locale: page.locale, siteName: brand, options: options.title })
+  return { title: title.base, headTitle: title.full, titleSource: 'hook' }
+}
+
+export function resolvePage(options, input) {
+  const { pathname, path, lang, locale, label, siteTitle, seo = {} } = input
+  const siteName = pick(options.site.name, lang, locale) ?? siteTitle
+  const home = { label: pick(options.breadcrumbs.home, lang, locale) ?? siteName, href: input.homeHref }
+
+  const brand = pick(options.title.site, lang, locale) ?? siteName
+  const title = resolveTitle({ label, seoTitle: seo.title, path, lang, locale, siteName: brand, options: options.title })
+  const description = seo.description ?? input.description ?? pick(options.site.description, lang, locale)
+
+  const rule = firstMatch(options.types, path)
+  const type = seo.type ?? rule?.type ?? (input.isHome ? 'WebPage' : input.template === 'splash' ? 'CollectionPage' : options.defaultType)
+
+  const source = seo.image ?? (options.image ? fill(pick(options.image.src, lang, locale), { slug: slugOf(path), lang: lang ?? '', locale: locale ?? '' }) : undefined)
+  const image = source
+    ? {
+        url: absolute(source, options.origin),
+        width: seo.image ? undefined : options.image.width,
+        height: seo.image ? undefined : options.image.height,
+        alt: seo.imageAlt ?? pick(options.image?.alt, lang, locale) ?? title.base,
+      }
+    : null
+
+  return {
+    url: input.canonical,
+    pathname,
+    path,
+    language: lang,
+    locale,
+    isHome: input.isHome,
+    label,
+    title: title.base,
+    headTitle: title.full,
+    titleSource: title.source,
+    description,
+    type,
+    article: isArticle(type),
+    image,
+    noindex: seo.noindex === true,
+    published: seo.published,
+    modified: seo.modified ?? input.lastUpdated,
+    section: seo.section ?? rule?.section,
+    keywords: seo.keywords,
+    about: seo.about ?? pick(options.site.about, lang, locale),
+    breadcrumbs: breadcrumbs({
+      sidebar: input.sidebar,
+      home,
+      label,
+      pathname,
+      isHome: input.isHome,
+      groups: options.breadcrumbs.groups,
+    }),
+    site: {
+      origin: options.origin,
+      name: siteName,
+      alternateName: pick(options.site.alternateName, lang, locale),
+      description: pick(options.site.description, lang, locale),
+      about: pick(options.site.about, lang, locale),
+    },
+  }
+}