upcontent 0.0.0-stage → 0.1.0

package/src/components/MermaidLoader.astro

@@ -0,0 +1,290 @@
+---
+---
+
+<script>
+  import mermaid from 'mermaid'
+  import { renderMermaidDiagram } from '../lib/mermaid-render'
+
+  function mermaidTheme() {
+    return document.documentElement.dataset.theme === 'dark' ? 'dark' : 'default'
+  }
+
+  mermaid.initialize({ startOnLoad: false, theme: mermaidTheme() })
+
+  let scale = 1
+  let translateX = 0
+  let translateY = 0
+  let dialogEl: HTMLDialogElement | null = null
+  let contentEl: HTMLDivElement | null = null
+
+  function applyTransform() {
+    if (contentEl) contentEl.style.transform = `translate(${translateX}px, ${translateY}px) scale(${scale})`
+  }
+
+  function resetTransform() {
+    scale = 1
+    translateX = 0
+    translateY = 0
+    applyTransform()
+  }
+
+  function ensureDialog() {
+    if (dialogEl) return
+
+    dialogEl = document.createElement('dialog')
+    dialogEl.className = 'mermaid-fullscreen-dialog'
+
+    const closeBtn = document.createElement('button')
+    closeBtn.type = 'button'
+    closeBtn.className = 'mermaid-fullscreen-close'
+    closeBtn.setAttribute('aria-label', 'Fechar')
+    closeBtn.textContent = '✕'
+    closeBtn.addEventListener('click', () => dialogEl?.close())
+
+    const viewport = document.createElement('div')
+    viewport.className = 'mermaid-fullscreen-viewport'
+
+    contentEl = document.createElement('div')
+    contentEl.className = 'mermaid-fullscreen-content'
+    viewport.appendChild(contentEl)
+
+    dialogEl.append(closeBtn, viewport)
+    document.body.appendChild(dialogEl)
+
+    dialogEl.addEventListener('click', e => {
+      if (e.target === dialogEl) dialogEl?.close()
+    })
+    dialogEl.addEventListener('close', resetTransform)
+
+    viewport.addEventListener(
+      'wheel',
+      e => {
+        e.preventDefault()
+        const delta = e.deltaY > 0 ? -0.1 : 0.1
+        scale = Math.min(Math.max(scale + delta, 0.2), 5)
+        applyTransform()
+      },
+      { passive: false },
+    )
+
+    let dragging = false
+    let lastX = 0
+    let lastY = 0
+    viewport.addEventListener('pointerdown', e => {
+      dragging = true
+      lastX = e.clientX
+      lastY = e.clientY
+      viewport.setPointerCapture(e.pointerId)
+    })
+    viewport.addEventListener('pointermove', e => {
+      if (!dragging) return
+      translateX += e.clientX - lastX
+      translateY += e.clientY - lastY
+      lastX = e.clientX
+      lastY = e.clientY
+      applyTransform()
+    })
+    viewport.addEventListener('pointerup', () => { dragging = false })
+    viewport.addEventListener('pointerleave', () => { dragging = false })
+  }
+
+  function openFullscreen(svg: string) {
+    ensureDialog()
+    if (!dialogEl || !contentEl) return
+    contentEl.innerHTML = svg
+    resetTransform()
+    dialogEl.showModal()
+  }
+
+  async function copyToClipboard(button: HTMLButtonElement, text: string) {
+    await navigator.clipboard.writeText(text)
+    const original = button.textContent
+    button.textContent = 'Copiado!'
+    setTimeout(() => { button.textContent = original }, 2000)
+  }
+
+  async function processDiagrams() {
+    const nodes = Array.from(document.querySelectorAll<HTMLElement>('div.mermaid'))
+    for (const node of nodes) {
+      // <br/> inside a div becomes a DOM element before textContent reads it — não deveria
+      // acontecer (remarkMermaid já normaliza), mas o replace aqui é defensivo.
+      const source = (node.textContent ?? '').replace(/ /g, ' ')
+      const result = await renderMermaidDiagram(mermaid, source)
+
+      if (result.status === 'ok') {
+        const container = document.createElement('div')
+        container.className = 'mermaid-container'
+        container.dataset.mermaidSource = source
+
+        const copyBtn = document.createElement('button')
+        copyBtn.type = 'button'
+        copyBtn.className = 'mermaid-copy-btn'
+        copyBtn.textContent = 'Copiar'
+        copyBtn.setAttribute('aria-label', 'Copiar código-fonte do diagrama')
+        copyBtn.addEventListener('click', e => {
+          e.stopPropagation()
+          void copyToClipboard(copyBtn, source)
+        })
+
+        const diagram = document.createElement('div')
+        diagram.className = 'mermaid-diagram'
+        diagram.innerHTML = result.svg
+        diagram.setAttribute('role', 'button')
+        diagram.setAttribute('tabindex', '0')
+        diagram.setAttribute('aria-label', 'Abrir diagrama em tela cheia')
+        diagram.addEventListener('click', () => openFullscreen(diagram.innerHTML))
+        diagram.addEventListener('keydown', e => {
+          if (e.key === 'Enter' || e.key === ' ') {
+            e.preventDefault()
+          openFullscreen(diagram.innerHTML)
+          }
+        })
+
+        container.append(copyBtn, diagram)
+        node.replaceWith(container)
+      } else {
+        const errorBox = document.createElement('div')
+        errorBox.className = 'mermaid-error'
+        errorBox.dataset.mermaidSource = source
+
+        const message = document.createElement('p')
+        message.className = 'mermaid-error-message'
+        message.textContent = `Erro ao renderizar diagrama Mermaid: ${result.message}`
+
+        const pre = document.createElement('pre')
+        pre.className = 'mermaid-error-source'
+        pre.textContent = result.source
+
+        errorBox.append(message, pre)
+        node.replaceWith(errorBox)
+      }
+    }
+  }
+
+  async function rerenderExistingDiagrams() {
+    mermaid.initialize({ startOnLoad: false, theme: mermaidTheme() })
+    for (const container of document.querySelectorAll<HTMLElement>('[data-mermaid-source]')) {
+      const source = container.dataset.mermaidSource
+      if (!source) continue
+      const result = await renderMermaidDiagram(mermaid, source)
+      if (result.status === 'ok') {
+        const diagram = container.querySelector('.mermaid-diagram')
+        if (diagram) diagram.innerHTML = result.svg
+      }
+    }
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => void processDiagrams())
+  } else {
+    void processDiagrams()
+  }
+
+  new MutationObserver(() => void rerenderExistingDiagrams()).observe(document.documentElement, {
+    attributes: true,
+    attributeFilter: ['data-theme'],
+  })
+</script>
+
+<style is:global>
+  .mermaid-container {
+    position: relative;
+  }
+
+  .mermaid-diagram {
+    cursor: zoom-in;
+  }
+
+  .mermaid-diagram:focus-visible {
+    outline: 2px solid var(--sl-color-accent);
+    outline-offset: 0.25rem;
+  }
+
+  .mermaid-copy-btn {
+    position: absolute;
+    top: 0.5rem;
+    right: 0.5rem;
+    padding: 0.25rem 0.5rem;
+    font-size: var(--sl-text-2xs, 0.75rem);
+    border: 1px solid var(--sl-color-gray-5);
+    border-radius: 0.25rem;
+    background: var(--sl-color-gray-6);
+    color: var(--sl-color-gray-2);
+    cursor: pointer;
+    opacity: 0;
+    transition: opacity 0.15s;
+  }
+  .mermaid-container:hover .mermaid-copy-btn,
+  .mermaid-copy-btn:focus-visible {
+    opacity: 1;
+  }
+
+  @media (prefers-reduced-motion: reduce) {
+    .mermaid-copy-btn {
+      transition: none;
+    }
+  }
+
+  .mermaid-error {
+    border: 1px solid var(--sl-color-red, #c53434);
+    border-radius: 0.5rem;
+    padding: 1rem;
+  }
+  .mermaid-error-message {
+    color: var(--sl-color-red, #c53434);
+    font-weight: 600;
+    margin: 0 0 0.5rem;
+  }
+  .mermaid-error-source {
+    white-space: pre-wrap;
+    overflow-x: auto;
+    margin: 0;
+  }
+
+  .mermaid-fullscreen-dialog {
+    padding: 0;
+    border: none;
+    width: 100vw;
+    height: 100vh;
+    max-width: 100vw;
+    max-height: 100vh;
+    background: var(--sl-color-bg, var(--sl-color-black));
+  }
+  .mermaid-fullscreen-dialog::backdrop {
+    background-color: var(--sl-color-backdrop-overlay, rgba(0, 0, 0, 0.6));
+  }
+
+  .mermaid-fullscreen-close {
+    position: absolute;
+    top: 1rem;
+    right: 1rem;
+    z-index: 1;
+    border: 1px solid var(--sl-color-gray-5);
+    border-radius: 0.375rem;
+    background: var(--sl-color-gray-6);
+    color: var(--sl-color-gray-2);
+    width: 2.5rem;
+    height: 2.5rem;
+    cursor: pointer;
+  }
+
+  .mermaid-fullscreen-viewport {
+    width: 100%;
+    height: 100%;
+    overflow: hidden;
+    touch-action: none;
+    cursor: grab;
+  }
+  .mermaid-fullscreen-viewport:active {
+    cursor: grabbing;
+  }
+
+  .mermaid-fullscreen-content {
+    width: 100%;
+    height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transform-origin: center center;
+  }
+</style>

package/src/components/PaletteShowcase.astro

@@ -0,0 +1,122 @@
+---
+const palettes = {
+  quiet: { label: 'Quiet / default', accent: '#334155', surface: '#f8fafc', ink: '#0f172a' },
+  river: { label: 'River', accent: '#0f766e', surface: '#f0fdfa', ink: '#134e4a' },
+  signal: { label: 'Signal', accent: '#be123c', surface: '#fff1f2', ink: '#4c0519' },
+}
+---
+
+<div class="palette-showcase" data-palette="quiet" data-palettes={JSON.stringify(palettes)}>
+  <div class="palette-controls" role="group" aria-label="Preview palettes">
+    {Object.entries(palettes).map(([id, palette], index) => (
+      <button
+        type="button"
+        class="palette-button"
+        data-palette-button={id}
+        aria-pressed={index === 0 ? 'true' : 'false'}
+      >
+        {palette.label}
+      </button>
+    ))}
+  </div>
+  <div class="palette-preview" aria-live="polite">
+    <div class="palette-swatch" data-swatch="accent"></div>
+    <div class="palette-swatch" data-swatch="surface"></div>
+    <div class="palette-swatch" data-swatch="ink"></div>
+    <div class="palette-preview-copy">
+    <strong data-palette-label>{palettes.quiet.label}</strong>
+      <span>One configuration seam, many possible identities.</span>
+    </div>
+  </div>
+</div>
+
+<script>
+  document.querySelectorAll<HTMLElement>('.palette-showcase').forEach(showcase => {
+    const palettes: Record<string, { accent: string; surface: string; ink: string; label: string }> = JSON.parse(
+      showcase.dataset.palettes ?? '{}',
+    )
+    const label = showcase.querySelector('[data-palette-label]')
+
+    showcase.querySelectorAll<HTMLButtonElement>('[data-palette-button]').forEach(button => {
+      button.addEventListener('click', () => {
+        const paletteId = button.dataset.paletteButton
+        const palette = paletteId ? palettes[paletteId] : undefined
+        if (!palette) return
+        showcase.dataset.palette = paletteId
+        showcase.style.setProperty('--palette-accent', palette.accent)
+        showcase.style.setProperty('--palette-surface', palette.surface)
+        showcase.style.setProperty('--palette-ink', palette.ink)
+        if (label) label.textContent = palette.label
+        showcase.querySelectorAll('[data-palette-button]').forEach(control => {
+          control.setAttribute('aria-pressed', String(control === button))
+        })
+      })
+    })
+
+    showcase.querySelector('[data-palette-button]')?.dispatchEvent(new Event('click'))
+  })
+</script>
+
+<style>
+  .palette-showcase {
+    --palette-accent: #334155;
+    --palette-surface: #f8fafc;
+    --palette-ink: #0f172a;
+    margin: 2rem 0;
+  }
+
+  .palette-controls {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+    margin-bottom: 1rem;
+  }
+
+  .palette-button {
+    border: 1px solid var(--sl-color-gray-5);
+    border-radius: 999px;
+    background: transparent;
+    color: var(--sl-color-text);
+    cursor: pointer;
+    padding: 0.45rem 0.75rem;
+  }
+
+  .palette-button[aria-pressed='true'] {
+    border-color: var(--sl-color-accent);
+    background: var(--sl-color-accent);
+    color: var(--sl-color-bg);
+  }
+
+  .palette-preview {
+    display: grid;
+    grid-template-columns: repeat(3, 3rem) 1fr;
+    gap: 0.75rem;
+    align-items: center;
+    border: 1px solid var(--sl-color-gray-5);
+    border-radius: 0.5rem;
+    padding: 1rem;
+    background: var(--palette-surface);
+    color: var(--palette-ink);
+  }
+
+  .palette-swatch {
+    width: 3rem;
+    height: 3rem;
+    border: 1px solid color-mix(in srgb, var(--palette-ink), transparent 70%);
+    border-radius: 0.35rem;
+  }
+
+  .palette-swatch[data-swatch='accent'] { background: var(--palette-accent); }
+  .palette-swatch[data-swatch='surface'] { background: var(--palette-surface); }
+  .palette-swatch[data-swatch='ink'] { background: var(--palette-ink); }
+
+  .palette-preview-copy {
+    display: grid;
+    gap: 0.25rem;
+  }
+
+  @media (max-width: 560px) {
+    .palette-preview { grid-template-columns: repeat(3, 2.25rem) 1fr; }
+    .palette-swatch { width: 2.25rem; height: 2.25rem; }
+  }
+</style>

package/src/components/StructuredDataCopy.astro

@@ -0,0 +1,22 @@
+<script>
+  const buttons = document.querySelectorAll<HTMLButtonElement>('[data-sdp-copy]')
+
+  for (const button of buttons) {
+    button.addEventListener('click', async () => {
+      const source = button.dataset.sdpCopy
+      const label = button.querySelector('.sdp-copy-label')
+      if (!source || !label) return
+
+      try {
+        await navigator.clipboard.writeText(decodeURIComponent(source))
+        label.textContent = 'Copied'
+      } catch {
+        label.textContent = 'Copy failed'
+      }
+
+      window.setTimeout(() => {
+        label.textContent = 'Copy'
+      }, 1500)
+    })
+  }
+</script>

package/src/content/__mocks__/astro-content.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod'
+
+export { z }
+
+export function defineCollection(config: unknown) {
+  return config
+}

package/src/content/__mocks__/astro-loaders.ts

@@ -0,0 +1,3 @@
+export function glob(_config: unknown) {
+  return {}
+}

package/src/content.config.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+}))
+
+import * as fs from 'node:fs'
+import { domainFieldsSchema, isBlocked, resolveTitle, toRelativeDocPath } from './content.config'
+import { _resetPortalConfigCache } from './lib/portal-config'
+
+beforeEach(() => {
+  _resetPortalConfigCache()
+  vi.mocked(fs.existsSync).mockReturnValue(false)
+})
+
+// domainFieldsSchema cobre só os campos de domínio deste portal — o título
+// obrigatório do Starlight é resolvido por resolveTitle() antes da
+// validação (ver describe('resolveTitle') abaixo), não faz parte deste schema.
+describe('domainFieldsSchema', () => {
+  it('aceita frontmatter completamente vazio', () => {
+    const result = domainFieldsSchema.safeParse({})
+    expect(result.success).toBe(true)
+  })
+
+  it('aceita status outdated', () => {
+    const result = domainFieldsSchema.safeParse({ status: 'outdated' })
+    expect(result.success).toBe(true)
+  })
+
+  it('aceita created/updated como objeto Date (YAML parseia datas automaticamente)', () => {
+    const result = domainFieldsSchema.safeParse({
+      created: new Date('2026-08-07'),
+      updated: new Date('2026-08-07'),
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.created).toBe('2026-08-07')
+      expect(result.data.updated).toBe('2026-08-07')
+    }
+  })
+
+  it('aceita todos os campos de domínio preenchidos', () => {
+    const result = domainFieldsSchema.safeParse({
+      type: 'architecture',
+      status: 'active',
+      created: '2026-08-07',
+      updated: '2026-08-07',
+      teams: ['my-team'],
+      impacted_teams: [],
+      domains: [],
+      repos: ['my-frontend-repo'],
+      areas: [],
+      tags: ['sdd/prd'],
+      aliases: [],
+      related: [],
+    })
+    expect(result.success).toBe(true)
+  })
+})
+
+describe('resolveTitle', () => {
+  it('mantém o title do frontmatter quando presente', () => {
+    const data: Record<string, unknown> = { title: 'Meu Título' }
+    resolveTitle('docs/algo.md', data)
+    expect(data.title).toBe('Meu Título')
+  })
+
+  it('deriva do filename em Title Case quando title ausente', () => {
+    const data: Record<string, unknown> = {}
+    resolveTitle('domains/trd-backend.md', data)
+    expect(data.title).toBe('Trd Backend')
+  })
+
+  it('remove prefixo numérico do filename antes de converter', () => {
+    const data: Record<string, unknown> = {}
+    resolveTitle('docs/adr/0001-self-hosted.md', data)
+    expect(data.title).toBe('Self Hosted')
+  })
+
+  it('usa apenas o nome do arquivo, ignorando o diretório', () => {
+    const data: Record<string, unknown> = {}
+    resolveTitle('domains/licencas/gestao-acessos.md', data)
+    expect(data.title).toBe('Gestao Acessos')
+  })
+
+  it('usa o campo configurado em content.titleField quando presente', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true)
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({ content: { titleField: 'heading' } })
+    )
+    const data: Record<string, unknown> = { heading: 'Título Alternativo' }
+    resolveTitle('domains/algo.md', data)
+    expect(data.title).toBe('Título Alternativo')
+  })
+
+  it('cai no fallback de filename quando content.titleField está configurado mas ausente no frontmatter', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true)
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({ content: { titleField: 'heading' } })
+    )
+    const data: Record<string, unknown> = {}
+    resolveTitle('domains/algo-especifico.md', data)
+    expect(data.title).toBe('Algo Especifico')
+  })
+})
+
+describe('isBlocked', () => {
+  it('bloqueia CLAUDE.md (case-insensitive)', () => {
+    expect(isBlocked('CLAUDE.md')).toBe(true)
+    expect(isBlocked('claude.md')).toBe(true)
+  })
+
+  it('bloqueia RULES.md (case-insensitive)', () => {
+    expect(isBlocked('RULES.md')).toBe(true)
+    expect(isBlocked('rules.md')).toBe(true)
+  })
+
+  it('bloqueia qualquer arquivo dentro de .claude/', () => {
+    expect(isBlocked('.claude/settings.json')).toBe(true)
+  })
+
+  it('bloqueia qualquer arquivo dentro de .github/', () => {
+    expect(isBlocked('.github/workflows/ci.yml')).toBe(true)
+  })
+
+  it('bloqueia qualquer arquivo dentro de .upcontent/', () => {
+    expect(isBlocked('.upcontent/config.json')).toBe(true)
+    expect(isBlocked('.upcontent/assets/logo.svg')).toBe(true)
+  })
+
+  // adversarial: arquivo com nome parecido mas que NÃO deve ser bloqueado
+  it('não bloqueia domains/README.md', () => {
+    expect(isBlocked('domains/README.md')).toBe(false)
+  })
+
+  it('bloqueia shared/INDEX.md (case-insensitive — arquivo real usa maiúsculo)', () => {
+    expect(isBlocked('shared/INDEX.md')).toBe(true)
+  })
+
+  it('não bloqueia docs/prd/prd.md', () => {
+    expect(isBlocked('docs/prd/prd.md')).toBe(false)
+  })
+
+  // adversarial: arquivo com prefixo ".cl" que NÃO é ".claude/"
+  it('não bloqueia um arquivo hipotético .clue/something.md', () => {
+    expect(isBlocked('.clue/something.md')).toBe(false)
+  })
+})
+
+describe('toRelativeDocPath', () => {
+  // o loader glob() do Astro gera entry.filePath relativo à raiz do projeto
+  // (ex: "src/content/docs/RULES.md"), não relativo ao content base — isBlocked()
+  // espera o path relativo ao content base (ex: "RULES.md")
+  it('remove o prefixo src/content/docs/', () => {
+    expect(toRelativeDocPath('src/content/docs/RULES.md')).toBe('RULES.md')
+    expect(toRelativeDocPath('src/content/docs/shared/index.md')).toBe('shared/index.md')
+  })
+
+  it('mantém o path como está se o prefixo não estiver presente', () => {
+    expect(toRelativeDocPath('RULES.md')).toBe('RULES.md')
+  })
+})

package/src/content.config.ts

@@ -0,0 +1,90 @@
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { defineCollection } from 'astro:content'
+import { z } from 'astro/zod'
+import { docsSchema } from '@astrojs/starlight/schema'
+import { glob } from 'astro/loaders'
+import type { Loader, LoaderContext } from 'astro/loaders'
+import { getBlocklist, isBlocked, toRelativeDocPath, toTitleCase } from './lib/content-blocklist'
+import { getPortalConfig } from './lib/portal-config'
+
+export { getBlocklist, isBlocked, toRelativeDocPath }
+
+// Campos de domínio específicos deste portal, além do schema padrão do
+// Starlight (title, description, sidebar, etc). Mantido isolado do
+// docsSchema() do Starlight pra ser testável sem precisar de um
+// SchemaContext (o título obrigatório do Starlight é resolvido pelo loader,
+// não pelo schema — ver resolveTitle()).
+export const domainFieldsSchema = z.object({
+  type: z.string().optional(),
+  status: z.string().optional(),
+  created: z.string().or(z.date().transform(d => d.toISOString().split('T')[0])).optional(),
+  updated: z.string().or(z.date().transform(d => d.toISOString().split('T')[0])).optional(),
+  teams: z.array(z.string()).optional(),
+  impacted_teams: z.array(z.string()).optional(),
+  domains: z.array(z.string()).optional(),
+  repos: z.array(z.string()).optional(),
+  areas: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  aliases: z.array(z.string()).optional(),
+  related: z.array(z.string()).optional(),
+})
+
+// Resolve o título obrigatório do Starlight ANTES da validação do schema:
+// usa content.titleField do .upcontent/config.json se presente no frontmatter,
+// senão deriva do nome do arquivo em Title Case (prefixo numérico removido).
+// Muda `data` in-place — é chamado de dentro do generateId/parseData do
+// loader, no ponto em que o frontmatter ainda não foi validado.
+export function resolveTitle(relativeFilePath: string, data: Record<string, unknown>): void {
+  if (typeof data.title === 'string' && data.title.trim().length > 0) return
+
+  const titleField = getPortalConfig().content?.titleField ?? 'title'
+  if (titleField !== 'title') {
+    const custom = data[titleField]
+    if (typeof custom === 'string' && custom.trim().length > 0) {
+      data.title = custom
+      return
+    }
+  }
+
+  const filename = relativeFilePath.split('/').pop() ?? relativeFilePath
+  const withoutExt = filename.replace(/\.mdx?$/i, '')
+  data.title = toTitleCase(withoutExt)
+}
+
+function toCaseInsensitiveGlob(value: string): string {
+  return value.replace(/[A-Za-z]/g, character => `[${character.toLowerCase()}${character.toUpperCase()}]`)
+}
+
+// Carrega Markdown com glob(): injeta o fallback de título antes da validação
+// e aplica a blocklist como exclusões de glob antes do parse dos documentos.
+function portalDocsLoader(): Loader {
+  return {
+    name: 'portal-docs-loader',
+    async load(context: LoaderContext) {
+      const docsBasePath = fileURLToPath(new URL('src/content/docs/', context.config.root))
+      const patterns = [
+        '**/[^_]*.{markdown,mdown,mkdn,mkd,mdwn,md,mdx}',
+        ...getBlocklist().map(blocked => `!${toCaseInsensitiveGlob(blocked)}${blocked.endsWith('/') ? '**' : ''}`),
+      ]
+      const wrappedContext: LoaderContext = {
+        ...context,
+        parseData: async (props) => {
+          if (props.filePath) {
+            const relative = path.relative(docsBasePath, props.filePath).split(path.sep).join('/')
+            resolveTitle(relative, props.data)
+          }
+          return context.parseData(props)
+        },
+      }
+      await glob({ base: docsBasePath, pattern: patterns }).load(wrappedContext)
+    },
+  }
+}
+
+export const collections = {
+  docs: defineCollection({
+    loader: portalDocsLoader(),
+    schema: docsSchema({ extend: domainFieldsSchema }),
+  }),
+}