@docsector/docsector-reader 4.6.0 → 4.7.0

package/README.md

@@ -67,6 +67,7 @@ Transform Markdown content into beautiful, navigable documentation sites — wit
 - 🦶 **Global Branding Footer** — Built-in `Powered by Docsector` footer renders across documentation and system pages, while respecting each page's own scroll container for full-width layout integration without double scrollbars
 - 🔀 **Internal Shortcut Pages** — Route entries can redirect with `config.link.to`, keeping localized titles while inheriting icon/status from the destination page
 - 📐 **Responsive Subpage Toolbar** — Subpage actions align with the content column on desktop and dock to the bottom on mobile
+- 🆚 **Subpage Templates** — Subpages opt into a structured template via `vs: { template: 'vs' }`; the managed/strict `vs` template owns the order and localized titles of its **Features**, **Performance** and **Security** sections (one `##` heading per section, missing sections dropped gracefully), auto-colorizes `✓`/`✗`/`➕` comparison marks, and highlights the column whose header matches the consumer's `branding.name`
 - ⬆️ **Reading Progress Back to Top** — Documentation subpages can show a floating back-to-top control with circular reading progress that stays above the mobile subpage toolbar
 - 🏷️ **Status Badges** — Mark pages as `done`, `draft`, `empty`, or `new` with visual indicators
 - ✏️ **Edit on GitHub** — Direct links to edit pages on your repository
@@ -1137,6 +1138,7 @@ Notes:
 - In `manual.index.js`, route keys are relative to the `manual` book (for example `'/my-section/my-page'` becomes `/manual/my-section/my-page/...`).
 - You only need to set `config.book` when overriding the inferred book from the registry file.
 - When `showcase` or `vs` are enabled, the subpage toolbar aligns with the content width on desktop and becomes a bottom action bar on mobile.
+- A subpage can opt into a **structured template** with the object form `vs: { template: 'vs' }` (the boolean `true` stays `freestyle`). The built-in `vs` template is managed/strict: it owns the order and localized titles of its **Features**, **Performance** and **Security** sections — write one `##` heading per section in the Markdown and omitted sections are dropped gracefully.
 
 2️⃣ Create Markdown files:
 

package/bin/docsector.js

@@ -24,7 +24,7 @@ const packageRoot = resolve(__dirname, '..')
 const args = process.argv.slice(2)
 const command = args[0]
 
-const VERSION = '4.6.0'
+const VERSION = '4.7.0'
 const AUTHORING_SKILL_NAME = 'docsector-documentation-authoring'
 const AUTHORING_SKILL_DESCRIPTION = 'Author Docsector documentation with Markdown, custom blocks, MCP, and WebMCP.'
 const AUTHORING_SKILL_PUBLIC_PATH = `/.well-known/agent-skills/${AUTHORING_SKILL_NAME}/SKILL.md`

package/docsector.config.js

@@ -88,10 +88,10 @@ export default {
       matchThreshold: 0.4,
       contextExpansion: 1,
       queryRewrite: {
-        enabled: true
+        enabled: false
       },
       reranking: {
-        enabled: true,
+        enabled: false,
         model: '@cf/baai/bge-reranker-base',
         matchThreshold: 0.4
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docsector/docsector-reader",
-  "version": "4.6.0",
+  "version": "4.7.0",
   "description": "A documentation rendering engine built with Vue 3, Quasar v2 and Vite. Transform Markdown into beautiful, navigable documentation sites.",
   "productName": "Docsector Reader",
   "author": "Rodrigo de Araujo Vieira",

package/src/components/DPageSection.vue

@@ -7,8 +7,10 @@ import DPageTokens from './DPageTokens.vue'
 import { pageValueI18nPath } from '../i18n/path'
 import { buildPageAnchorTree } from './page-anchor-tree'
 import { tokenizePageSectionSource } from './page-section-tokens'
+import { applyTemplateSections } from './page-template-sections'
+import docsectorConfig from 'docsector.config.js'
 
-defineProps({
+const props = defineProps({
   id: {
     type: Number,
     required: true
@@ -16,11 +18,15 @@ defineProps({
   renderPrimaryHeading: {
     type: Boolean,
     default: false
+  },
+  template: {
+    type: Object,
+    default: null
   }
 })
 
 const store = useStore()
-const { t } = useI18n()
+const { t, locale } = useI18n()
 
 const tokenized = computed(() => {
   const absolute = store.state.i18n.absolute
@@ -29,7 +35,15 @@ const tokenized = computed(() => {
     return []
   }
 
-  return tokenizePageSectionSource(t(pageValueI18nPath(absolute, 'source')))
+  const tokens = tokenizePageSectionSource(t(pageValueI18nPath(absolute, 'source')))
+
+  if (Array.isArray(props.template?.sections) && props.template.sections.length > 0) {
+    return applyTemplateSections(tokens, props.template, locale.value, {
+      highlightColumn: docsectorConfig?.branding?.name
+    })
+  }
+
+  return tokens
 })
 
 watch(tokenized, (tokens) => {

package/src/components/DPageTokens.vue

@@ -88,6 +88,7 @@ import DBlockApi from './DBlockApi.vue'
   <div
     v-else-if="token.tag === 'table'"
     class="d-table-wrapper"
+    :class="{ 'd-table-wrapper--vs': token.highlight }"
   >
     <d-page-rich-content
       tag="table"

package/src/components/DSubpage.vue

@@ -9,10 +9,18 @@ import DPageBar from "./DPageBar.vue";
 import DH1 from "./DH1.vue";
 import DPageSection from "./DPageSection.vue";
 import { usesRemoteReadmeHomeContent } from '../home-page-mode'
+import { getTemplate } from '../page-template'
 
 const route = useRoute()
 const store = useStore()
 
+const template = computed(() => {
+  const relative = store.state.page.relative
+  const subpage = relative ? relative.replace(/^\//, '') : 'overview'
+  const templates = route.matched?.[0]?.meta?.subpageTemplates
+  return getTemplate(templates?.[subpage])
+})
+
 const id = computed(() => {
   const path = route.path
 
@@ -42,7 +50,7 @@ const usesRemoteReadmeHome = computed(() => {
   </header>
 
   <main>
-    <d-page-section :id="id" :render-primary-heading="usesRemoteReadmeHome" />
+    <d-page-section :id="id" :render-primary-heading="usesRemoteReadmeHome" :template="template" />
   </main>
 </d-page>
 </template>

package/src/components/page-template-sections.js

@@ -0,0 +1,171 @@
+const stripHtml = (value) => String(value ?? '').replace(/<[^>]*>/g, '')
+
+/**
+ * Normalize a heading/key into a comparable slug: strip HTML and diacritics,
+ * lowercase, and collapse non-alphanumerics into single hyphens.
+ */
+const normalizeKey = (value) => stripHtml(value)
+  .normalize('NFD')
+  .replace(/[̀-ͯ]/g, '')
+  .toLowerCase()
+  .trim()
+  .replace(/[^a-z0-9]+/g, '-')
+  .replace(/^-+|-+$/g, '')
+
+const warnUnknownSection = (templateName, heading, allowed) => {
+  if (typeof console !== 'undefined' && typeof console.warn === 'function') {
+    console.warn(
+      `[docsector] Unknown "${templateName}" template section: "${heading}". ` +
+      `Allowed sections: ${allowed.join(', ')}.`
+    )
+  }
+}
+
+// ? Comparison marks colorized in rendered content (✓ yes, ✗ no, ➕ add-on)
+const MARK_CLASS = { '✓': 'vs-mark--yes', '✗': 'vs-mark--no', '➕': 'vs-mark--dep' }
+const MARKABLE_TAGS = new Set(['p', 'table', 'ul', 'ol'])
+const MARK_PATTERN = /[✓✗➕]/
+
+const colorizeMarks = (html) => String(html ?? '').replace(
+  /[✓✗➕]/g,
+  (glyph) => `<span class="vs-mark ${MARK_CLASS[glyph]}">${glyph}</span>`
+)
+
+// ? Detect tables whose 2nd header matches the consumer-configured highlight column
+const isHighlightColumnTable = (html, label) => {
+  if (!label) {
+    return false
+  }
+
+  const header = html.match(/<thead[\s\S]*?<\/thead>/i)?.[0] ?? html.match(/<tr[\s\S]*?<\/tr>/i)?.[0] ?? ''
+  const cells = [...header.matchAll(/<th[^>]*>([\s\S]*?)<\/th>/gi)].map(cell => cell[1].replace(/<[^>]*>/g, '').trim())
+
+  return cells[1] === label
+}
+
+const transformToken = (token, highlightColumn) => {
+  if (!token || typeof token.content !== 'string') {
+    return token
+  }
+
+  let content = token.content
+  if (MARKABLE_TAGS.has(token.tag) && MARK_PATTERN.test(content)) {
+    content = colorizeMarks(content)
+  }
+
+  // ? Flag (not inject) — the <table> element is created by DPageTokens, not in token.content
+  const highlight = token.tag === 'table' && isHighlightColumnTable(token.content, highlightColumn)
+
+  if (content === token.content && !highlight) {
+    return token
+  }
+
+  return highlight ? { ...token, content, highlight: true } : { ...token, content }
+}
+
+/**
+ * Apply a structured subpage template to a flat token stream (managed/strict).
+ *
+ * The template owns the section structure: each canonical section is rendered in
+ * the template's declared order, with the template's localized title overriding
+ * the markdown heading. Sections absent from the markdown are gracefully omitted.
+ * Markdown content before the first `h2` is kept as an intro. Unknown top-level
+ * `h2` sections are warned about and appended after the canonical sections so no
+ * authored content is lost.
+ *
+ * Freestyle templates (no `sections`) return the tokens unchanged.
+ *
+ * @param {Array} tokens - Tokenized page section source.
+ * @param {Object} template - Resolved template preset.
+ * @param {string} [locale] - Active locale for section titles.
+ * @param {Object} [options] - Render options.
+ * @param {string} [options.highlightColumn] - Header label whose comparison column is emphasized (consumer-provided, e.g. the project name).
+ * @returns {Array} Reordered/relabeled token stream.
+ */
+export function applyTemplateSections (tokens, template, locale = 'en-US', options = {}) {
+  const sections = template?.sections
+  const highlightColumn = options.highlightColumn
+
+  if (!Array.isArray(sections) || sections.length === 0) {
+    return Array.isArray(tokens) ? tokens : []
+  }
+
+  // ? Map every accepted slug (canonical key + each localized title) to its section index
+  const indexBySlug = new Map()
+  sections.forEach((section, index) => {
+    indexBySlug.set(normalizeKey(section.key), index)
+
+    for (const title of Object.values(section.title || {})) {
+      const slug = normalizeKey(title)
+      if (slug && !indexBySlug.has(slug)) {
+        indexBySlug.set(slug, index)
+      }
+    }
+  })
+
+  // ! Partition tokens into intro, canonical buckets and unknown sections
+  const intro = []
+  const buckets = sections.map(() => null)
+  const unknowns = []
+  let current = null
+
+  // @ Walk the flat stream, splitting at h2 boundaries
+  for (const token of Array.isArray(tokens) ? tokens : []) {
+    if (token?.tag === 'h2') {
+      const slug = normalizeKey(token.anchorId ?? token.content)
+      const index = indexBySlug.has(slug) ? indexBySlug.get(slug) : -1
+
+      if (index >= 0) {
+        if (buckets[index] === null) {
+          buckets[index] = []
+        }
+        current = { type: 'section', index }
+      } else {
+        const unknown = { token, body: [] }
+        unknowns.push(unknown)
+        current = { type: 'unknown', unknown }
+      }
+
+      continue
+    }
+
+    if (current === null) {
+      intro.push(token)
+    } else if (current.type === 'section') {
+      buckets[current.index].push(token)
+    } else {
+      current.unknown.body.push(token)
+    }
+  }
+
+  // @@ Rebuild in canonical order
+  const output = [...intro]
+
+  sections.forEach((section, index) => {
+    const body = buckets[index]
+    if (body === null) {
+      return
+    }
+
+    output.push({
+      tag: 'h2',
+      anchorId: section.key,
+      content: section.title?.[locale] || section.title?.['en-US'] || section.key,
+      icon: section.icon
+    })
+    output.push(...body)
+  })
+
+  // ? Append unknown sections (non-destructive) after warning
+  if (unknowns.length > 0) {
+    const allowed = sections.map(section => section.key)
+
+    for (const unknown of unknowns) {
+      warnUnknownSection(template.name, stripHtml(unknown.token.content), allowed)
+      output.push(unknown.token, ...unknown.body)
+    }
+  }
+
+  // : colorize comparison marks (✓/✗/➕) + highlight the configured column
+  return output.map(token => transformToken(token, highlightColumn))
+}

package/src/css/app.sass

@@ -84,6 +84,20 @@ body.body--dark
         color: #B19248
     section
       color: var(--q-light-in-dark-2)
+    // VS comparison marks (dark)
+    .vs-mark--yes
+      color: #3fb950
+    .vs-mark--no
+      color: #ff7b72
+    .vs-mark--dep
+      color: #d29922
+    // VS comparison: highlight the configured column (dark)
+    .d-table-wrapper--vs
+      th:nth-child(2),
+      td:nth-child(2)
+        background: rgba(193, 166, 103, 0.12)
+        border-left-color: rgba(193, 166, 103, 0.45)
+        border-right-color: rgba(193, 166, 103, 0.45)
     // token
     code:not(pre > code)
       color: var(--q-primary-in-dark-bg) !important
@@ -102,7 +116,8 @@ body.body--dark
         border-bottom: 1px dotted #1b4a6c
 
     &.overview,
-    &.showcase
+    &.showcase,
+    &.vs
       blockquote
         border-left-color: #3d444d
         background-color: #161b22 !important
@@ -157,6 +172,25 @@ body.body--dark
   --big-play-button-background: #000 !important
   --big-play-button-background-dark: #000 !important
 
+  // VS comparison marks
+  .vs-mark
+    font-weight: 700
+  .vs-mark--yes
+    color: #1a7f37
+  .vs-mark--no
+    color: #cf222e
+  .vs-mark--dep
+    color: #9a6700
+
+  // VS comparison: highlight the configured column
+  .d-table-wrapper--vs
+    th:nth-child(2),
+    td:nth-child(2)
+      background: rgba(105, 86, 43, 0.07)
+      font-weight: 600
+      border-left: 2px solid rgba(105, 86, 43, 0.35)
+      border-right: 2px solid rgba(105, 86, 43, 0.35)
+
   h1, h2, h3, h4, h5, h6
     font-weight: 600
     padding: 6px
@@ -281,7 +315,8 @@ body.body--dark
       transition: all 0.3s ease
 
   &.overview,
-  &.showcase
+  &.showcase,
+  &.vs
     blockquote
       margin: 1.5em 0
       padding: 0.85em 1.1em

package/src/i18n/helpers.js

@@ -448,11 +448,11 @@ export function buildMessages ({ langModules, mdModules, pages, books, pageEntri
       // Overview
       _.overview.source = load(topPage, path, 'overview', lang, sourceRoot)
       // showcase
-      if (config.subpages?.showcase === true) {
+      if (config.subpages?.showcase) {
         _.showcase.source = load(topPage, path, 'showcase', lang, sourceRoot)
       }
       // Vs
-      if (config.subpages?.vs === true) {
+      if (config.subpages?.vs) {
         _.vs.source = load(topPage, path, 'vs', lang, sourceRoot)
       }
     }

package/src/page-template.js

@@ -0,0 +1,118 @@
+export const PAGE_TEMPLATE_FREESTYLE = 'freestyle'
+export const PAGE_TEMPLATE_VS = 'vs'
+
+/**
+ * Subpage template presets.
+ *
+ * A template defines the fixed structure a subpage must follow. `freestyle`
+ * (the default) imposes no structure — the markdown renders exactly as written.
+ * Structured templates declare an ordered `sections` list; the renderer slots
+ * the markdown bodies into that fixed structure (canonical order, template-owned
+ * localized titles, graceful omission of absent sections).
+ */
+const PAGE_TEMPLATE_PRESETS = Object.freeze({
+  [PAGE_TEMPLATE_FREESTYLE]: Object.freeze({
+    name: PAGE_TEMPLATE_FREESTYLE,
+    sections: null
+  }),
+  [PAGE_TEMPLATE_VS]: Object.freeze({
+    name: PAGE_TEMPLATE_VS,
+    sections: Object.freeze([
+      Object.freeze({
+        key: 'features',
+        icon: 'checklist',
+        title: Object.freeze({ 'en-US': 'Features', 'pt-BR': 'Recursos' })
+      }),
+      Object.freeze({
+        key: 'performance',
+        icon: 'speed',
+        title: Object.freeze({ 'en-US': 'Performance', 'pt-BR': 'Desempenho' })
+      }),
+      Object.freeze({
+        key: 'security',
+        icon: 'security',
+        title: Object.freeze({ 'en-US': 'Security', 'pt-BR': 'Segurança' })
+      })
+    ])
+  })
+})
+
+const normalizeTemplateName = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_-]+/g, '-')
+
+  if (normalized && Object.prototype.hasOwnProperty.call(PAGE_TEMPLATE_PRESETS, normalized)) {
+    return normalized
+  }
+
+  return PAGE_TEMPLATE_FREESTYLE
+}
+
+const firstDefined = (source, keys) => {
+  for (const key of keys) {
+    if (source?.[key] !== undefined) {
+      return source[key]
+    }
+  }
+
+  return undefined
+}
+
+const toTemplateName = (source) => {
+  if (source === undefined || source === null) {
+    return undefined
+  }
+
+  if (typeof source === 'boolean') {
+    return source ? PAGE_TEMPLATE_FREESTYLE : undefined
+  }
+
+  if (typeof source === 'string') {
+    return normalizeTemplateName(source)
+  }
+
+  if (typeof source === 'object' && !Array.isArray(source)) {
+    const name = firstDefined(source, ['template', 'name', 'type', 'preset'])
+    return name === undefined ? undefined : normalizeTemplateName(name)
+  }
+
+  return undefined
+}
+
+/**
+ * Whether a subpage config value enables that subpage.
+ *
+ * Accepts the boolean shorthand (`true`) or the object form (`{ template }`).
+ */
+export function isSubpageEnabled (value) {
+  return value === true || (typeof value === 'object' && value !== null && !Array.isArray(value))
+}
+
+/**
+ * Resolve a subpage template from one or more config sources.
+ *
+ * Sources may be a template name string, the subpage config value
+ * (`true` | `{ template }`), or undefined. Later sources win; the default is
+ * `freestyle`. Returns the resolved template preset object.
+ */
+export function resolveSubpageTemplate (...sources) {
+  let name = PAGE_TEMPLATE_FREESTYLE
+
+  for (const source of sources) {
+    const resolved = toTemplateName(source)
+    if (resolved !== undefined) {
+      name = resolved
+    }
+  }
+
+  return PAGE_TEMPLATE_PRESETS[name] || PAGE_TEMPLATE_PRESETS[PAGE_TEMPLATE_FREESTYLE]
+}
+
+/**
+ * Get a template preset object by name, falling back to `freestyle`.
+ */
+export function getTemplate (name) {
+  return PAGE_TEMPLATE_PRESETS[normalizeTemplateName(name)] || PAGE_TEMPLATE_PRESETS[PAGE_TEMPLATE_FREESTYLE]
+}

package/src/pages/manual/content/structures/subpage.overview.en-US.md

@@ -8,6 +8,43 @@ Under the hood, routed documentation uses `DSubpage` for this composition.
 
 The implementation generates a deterministic numeric ID from the current route path using a hash function. This ID is passed to `DPageSection` to keep per-page renderer indexes stable across page navigations.
 
+## Subpage templates
+
+Subpages render free-form Markdown by default (the `freestyle` template). A subpage can instead opt into a **structured template** that owns a fixed set of sections, declared per subpage in the page registry:
+
+```javascript
+// src/pages/manual.index.js
+'/WPI/HTTP/HTTP_Server_CLI': {
+  config: {
+    subpages: {
+      vs: { template: 'vs' }   // enable the `vs` subpage with the `vs` template
+    }
+  }
+}
+```
+
+The boolean shorthand (`showcase: true`) still means "enabled, freestyle". The object form `&#123; template: '<name>' &#125;` selects a template.
+
+### Built-in templates
+
+| Template | Structure |
+|---|---|
+| `freestyle` (default) | No fixed structure — Markdown renders as written |
+| `vs` | Fixed comparison sections: Features, Performance, Security |
+
+### Managed (strict) rendering
+
+Structured templates are **managed**: the template owns the section titles, icons and order. In the Markdown you write one `##` heading per section (its slug must match a section key — or one of its localized titles); the renderer then:
+
+- renders sections in the template's canonical order,
+- replaces each heading with the template's localized title,
+- gracefully omits sections you do not include (so a page with partial data just leaves them out),
+- warns in the dev console about unknown headings and appends them after the canonical sections.
+
+Every `vs` subpage therefore shares the same structure. Templates are resolved by `resolveSubpageTemplate()` (`src/page-template.js`) and applied by `applyTemplateSections()` (`src/components/page-template-sections.js`).
+
+Inside comparison tables the engine colorizes the marks `✓` / `✗` / `➕` and highlights the column whose header matches your project's `branding.name`. The engine stays product-agnostic — the highlighted column is configured by the consumer (via `branding.name` in `docsector.config.js`), not hardcoded.
+
 ## Template
 
 ```html
@@ -16,7 +53,7 @@ The implementation generates a deterministic numeric ID from the current route p
     <d-h1 :id="0" />
   </header>
   <main>
-    <d-page-section :id="id" />
+    <d-page-section :id="id" :template="template" />
   </main>
 </d-page>
 ```

package/src/pages/manual/content/structures/subpage.overview.pt-BR.md

@@ -8,6 +8,43 @@ Na implementação, a documentação roteada usa `DSubpage` para essa composiç
 
 A implementação gera um ID numérico determinístico a partir do caminho da rota atual usando uma função hash. Esse ID é passado ao `DPageSection` para manter estáveis os índices internos do renderer em cada página.
 
+## Templates de subpágina
+
+As subpáginas renderizam Markdown livre por padrão (o template `freestyle`). Uma subpágina pode, em vez disso, optar por um **template estruturado** que controla um conjunto fixo de seções, declarado por subpágina no registro de páginas:
+
+```javascript
+// src/pages/manual.index.js
+'/WPI/HTTP/HTTP_Server_CLI': {
+  config: {
+    subpages: {
+      vs: { template: 'vs' }   // habilita a subpágina `vs` com o template `vs`
+    }
+  }
+}
+```
+
+O atalho booleano (`showcase: true`) continua significando "habilitada, freestyle". A forma de objeto `&#123; template: '<nome>' &#125;` seleciona um template.
+
+### Templates nativos
+
+| Template | Estrutura |
+|---|---|
+| `freestyle` (padrão) | Sem estrutura fixa — o Markdown renderiza como foi escrito |
+| `vs` | Seções de comparação fixas: Recursos, Desempenho, Segurança |
+
+### Renderização gerenciada (estrita)
+
+Templates estruturados são **gerenciados**: o template controla os títulos, ícones e a ordem das seções. No Markdown você escreve um heading `##` por seção (cujo slug deve corresponder à chave da seção — ou a um de seus títulos localizados); o renderer então:
+
+- renderiza as seções na ordem canônica do template,
+- substitui cada heading pelo título localizado do template,
+- omite com elegância as seções que você não inclui (uma página com dados parciais simplesmente as deixa de fora),
+- avisa no console de dev sobre headings desconhecidos e os anexa após as seções canônicas.
+
+Toda subpágina `vs` compartilha, portanto, a mesma estrutura. Os templates são resolvidos por `resolveSubpageTemplate()` (`src/page-template.js`) e aplicados por `applyTemplateSections()` (`src/components/page-template-sections.js`).
+
+Dentro das tabelas de comparação o engine coloriza as marcas `✓` / `✗` / `➕` e destaca a coluna cujo header corresponde ao `branding.name` do seu projeto. O engine permanece agnóstico ao produto — a coluna destacada é configurada pelo consumidor (via `branding.name` no `docsector.config.js`), não fica hardcoded.
+
 ## Template
 
 ```html
@@ -16,7 +53,7 @@ A implementação gera um ID numérico determinístico a partir do caminho da ro
     <d-h1 :id="0" />
   </header>
   <main>
-    <d-page-section :id="id" />
+    <d-page-section :id="id" :template="template" />
   </main>
 </d-page>
 ```

package/src/router/routes.js

@@ -2,6 +2,7 @@ import { pageEntries, versions } from 'virtual:docsector-books'
 import boot from 'pages/boot'
 import docsectorConfig from 'docsector.config.js'
 import { resolveHomePageLayout, resolvePageLayout } from '../page-layout'
+import { isSubpageEnabled, resolveSubpageTemplate } from '../page-template'
 
 const normalizeInternalLink = (linkTo) => {
   const normalized = String(linkTo || '').trim()
@@ -85,8 +86,13 @@ for (const entry of pageEntries || []) {
   const config = rawConfig || {}
   const menu = (typeof config.menu === 'object' && config.menu !== null) ? config.menu : {}
   const subpages = {
-    showcase: config?.subpages?.showcase === true,
-    vs: config?.subpages?.vs === true
+    showcase: isSubpageEnabled(config?.subpages?.showcase),
+    vs: isSubpageEnabled(config?.subpages?.vs)
+  }
+  const subpageTemplates = {
+    overview: resolveSubpageTemplate(config?.subpages?.overview).name,
+    showcase: resolveSubpageTemplate(config?.subpages?.showcase).name,
+    vs: resolveSubpageTemplate(config?.subpages?.vs).name
   }
 
   const topPage = config.book ?? config.type ?? entry?.book ?? 'manual'
@@ -159,6 +165,7 @@ for (const entry of pageEntries || []) {
       pageVersion,
       menu,
       subpages,
+      subpageTemplates,
       data: page.data,
       book: topPage,
       // legacy compatibility