@setzkasten-cms/astro-admin 1.4.2 → 1.5.0

package/src/init/__tests__/page-level.test.ts

@@ -10,13 +10,13 @@
  *   3. Patcher mode:'page' (injects getSection instead of Astro.props)
  */
 
-import { describe, it, expect, beforeAll } from 'vitest'
 import { readFileSync, readdirSync } from 'fs'
-import { join, basename } from 'path'
+import { basename, join } from 'path'
+import type { RepoFile } from '@setzkasten-cms/core/init'
+import { beforeAll, describe, expect, it } from 'vitest'
+import { extractLayoutImport, extractSectionImports } from '../../init/astro-detector'
 import { analyzeAstroSection } from '../../init/astro-section-analyzer-v2'
 import { patchTemplateForFields } from '../../init/template-patcher-v2'
-import { extractSectionImports, extractLayoutImport } from '../../init/astro-detector'
-import type { RepoFile } from '@setzkasten-cms/core/init'
 
 const SECTIONS_DIR = join(import.meta.dirname!, '..', '..', '..', '..', '..', 'test-sections')
 const PAGES_DIR = join(SECTIONS_DIR, 'pages')
@@ -34,9 +34,17 @@ describe('Page-level: pure inline content', () => {
 
   beforeAll(async () => {
     source = readFileSync(join(SECTIONS_DIR, 'PageInlineContent.astro'), 'utf-8')
-    section = await analyzeAstroSection(source, '_page_docs', 'docsPage', 'src/pages/docs/index.astro', { mode: 'page' })
+    section = await analyzeAstroSection(
+      source,
+      '_page_docs',
+      'docsPage',
+      'src/pages/docs/index.astro',
+      { mode: 'page' },
+    )
     groups = (section as any)._analyzerResult?.repeatedGroups ?? []
-    patched = await patchTemplateForFields(source, '_page_docs', section.fields, groups, { mode: 'page' })
+    patched = await patchTemplateForFields(source, '_page_docs', section.fields, groups, {
+      mode: 'page',
+    })
   })
 
   it('should detect fields from inline content', () => {
@@ -44,10 +52,10 @@ describe('Page-level: pure inline content', () => {
   })
 
   it('should detect text fields (headings, paragraphs, overline)', () => {
-    const textFields = section.fields.filter(f => f.type === 'text')
+    const textFields = section.fields.filter((f) => f.type === 'text')
     expect(textFields.length).toBeGreaterThan(0)
     // Should find the heading and description
-    const keys = textFields.map(f => f.key)
+    const keys = textFields.map((f) => f.key)
     expect(keys).toContain('heading')
     expect(keys).toContain('description')
   })
@@ -95,7 +103,13 @@ describe('Page-level: mixed content (imports + inline)', () => {
   beforeAll(async () => {
     source = readFileSync(join(SECTIONS_DIR, 'PageMixedContent.astro'), 'utf-8')
     // Analyze the page as a page-level section (same as init-scan-page.ts would)
-    section = await analyzeAstroSection(source, '_page_index', 'indexPage', 'src/pages/index.astro', { mode: 'page' })
+    section = await analyzeAstroSection(
+      source,
+      '_page_index',
+      'indexPage',
+      'src/pages/index.astro',
+      { mode: 'page' },
+    )
     groups = (section as any)._analyzerResult?.repeatedGroups ?? []
   })
 
@@ -104,16 +118,17 @@ describe('Page-level: mixed content (imports + inline)', () => {
   })
 
   it('should detect inline text fields', () => {
-    const textFields = section.fields.filter(f => f.type === 'text')
+    const textFields = section.fields.filter((f) => f.type === 'text')
     expect(textFields.length).toBeGreaterThan(0)
   })
 
   it('should detect inline text fields (heading, paragraph)', () => {
-    const textFields = section.fields.filter(f => f.type === 'text')
+    const textFields = section.fields.filter((f) => f.type === 'text')
     expect(textFields.length).toBeGreaterThan(0)
     // Should find "Was unsere Kunden sagen" or "Feedback von echten Nutzern."
     const hasExpectedText = textFields.some(
-      f => typeof f.defaultValue === 'string' &&
+      (f) =>
+        typeof f.defaultValue === 'string' &&
         (f.defaultValue.includes('Kunden') || f.defaultValue.includes('Feedback')),
     )
     expect(hasExpectedText, 'Should detect inline heading or paragraph text').toBe(true)
@@ -143,7 +158,13 @@ describe('Patcher mode: component vs page', () => {
 
   beforeAll(async () => {
     source = readFileSync(join(SECTIONS_DIR, 'PageInlineContent.astro'), 'utf-8')
-    section = await analyzeAstroSection(source, '_page_docs', 'docsPage', 'src/pages/docs/index.astro', { mode: 'page' })
+    section = await analyzeAstroSection(
+      source,
+      '_page_docs',
+      'docsPage',
+      'src/pages/docs/index.astro',
+      { mode: 'page' },
+    )
     groups = (section as any)._analyzerResult?.repeatedGroups ?? []
   })
 
@@ -154,7 +175,9 @@ describe('Patcher mode: component vs page', () => {
   })
 
   it('page mode should inject getSection', async () => {
-    const patched = await patchTemplateForFields(source, '_page_docs', section.fields, groups, { mode: 'page' })
+    const patched = await patchTemplateForFields(source, '_page_docs', section.fields, groups, {
+      mode: 'page',
+    })
     expect(patched).toContain("import { getSection } from 'setzkasten:content'")
     expect(patched).toContain("getSection('_page_docs')")
     expect(patched).not.toContain('Astro.props')
@@ -174,7 +197,13 @@ describe('Page-level: minimal page (no content)', () => {
 `
 
   it('should detect zero fields for a truly empty page', async () => {
-    const section = await analyzeAstroSection(minimalPage, '_page_empty', 'emptyPage', 'src/pages/empty.astro', { mode: 'page' })
+    const section = await analyzeAstroSection(
+      minimalPage,
+      '_page_empty',
+      'emptyPage',
+      'src/pages/empty.astro',
+      { mode: 'page' },
+    )
     expect(section.fields).toHaveLength(0)
   })
 })
@@ -196,7 +225,13 @@ const skData = getSection('_page_about');
 `
 
   it('should detect alreadyIntegrated flag', async () => {
-    const section = await analyzeAstroSection(integratedPage, '_page_about', 'aboutPage', 'src/pages/about.astro', { mode: 'page' })
+    const section = await analyzeAstroSection(
+      integratedPage,
+      '_page_about',
+      'aboutPage',
+      'src/pages/about.astro',
+      { mode: 'page' },
+    )
     expect(section.alreadyIntegrated).toBe(true)
   })
 })
@@ -229,18 +264,24 @@ describe('Full scan flow: mixed page (imports + inline)', () => {
     imports = extractSectionImports(source, 'src/pages/index.astro', repoFiles, '')
 
     // Step 2: page-level analysis (same as init-scan-page.ts after the imports loop)
-    pageSection = await analyzeAstroSection(source, '_page_index', 'indexPage', 'src/pages/index.astro', { mode: 'page' })
+    pageSection = await analyzeAstroSection(
+      source,
+      '_page_index',
+      'indexPage',
+      'src/pages/index.astro',
+      { mode: 'page' },
+    )
   })
 
   it('should find imported section components via extractSectionImports', () => {
     expect(imports.length).toBeGreaterThan(0)
-    const componentNames = imports.map(i => i.componentName)
+    const componentNames = imports.map((i) => i.componentName)
     expect(componentNames).toContain('HeroSection')
     expect(componentNames).toContain('FeaturesSection')
   })
 
   it('should resolve section keys from imports', () => {
-    const keys = imports.map(i => i.sectionKey)
+    const keys = imports.map((i) => i.sectionKey)
     expect(keys).toContain('hero')
     expect(keys).toContain('features')
   })
@@ -255,7 +296,8 @@ describe('Full scan flow: mixed page (imports + inline)', () => {
     expect(pageSection.fields.length).toBeGreaterThan(0)
     // Page-level should find the inline "Was unsere Kunden sagen" heading
     const hasInlineContent = pageSection.fields.some(
-      f => typeof f.defaultValue === 'string' &&
+      (f) =>
+        typeof f.defaultValue === 'string' &&
         (f.defaultValue.includes('Kunden') || f.defaultValue.includes('Feedback')),
     )
     expect(hasInlineContent, 'Page-level should find inline text content').toBe(true)
@@ -264,7 +306,7 @@ describe('Full scan flow: mixed page (imports + inline)', () => {
   it('should produce non-overlapping results (imports vs inline)', () => {
     // Import keys are "hero", "features" — page-level key is "_page_index"
     // They should never collide
-    const importKeys = new Set(imports.map(i => i.sectionKey))
+    const importKeys = new Set(imports.map((i) => i.sectionKey))
     expect(importKeys.has(pageSection.key)).toBe(false)
   })
 
@@ -296,7 +338,13 @@ describe('Full scan flow: pure inline page (no imports)', () => {
     ]
 
     imports = extractSectionImports(source, 'src/pages/docs/index.astro', repoFiles, '')
-    pageSection = await analyzeAstroSection(source, '_page_docs', 'docsPage', 'src/pages/docs/index.astro', { mode: 'page' })
+    pageSection = await analyzeAstroSection(
+      source,
+      '_page_docs',
+      'docsPage',
+      'src/pages/docs/index.astro',
+      { mode: 'page' },
+    )
   })
 
   it('should find zero section imports for a pure inline page', () => {
@@ -308,7 +356,7 @@ describe('Full scan flow: pure inline page (no imports)', () => {
   })
 
   it('should detect heading and description fields', () => {
-    const keys = pageSection.fields.map(f => f.key)
+    const keys = pageSection.fields.map((f) => f.key)
     expect(keys).toContain('heading')
     expect(keys).toContain('description')
   })
@@ -327,23 +375,34 @@ describe('Page-level: .map()-only arrays detected', () => {
   beforeAll(async () => {
     const source = readFileSync(join(SECTIONS_DIR, 'PageInlineContent.astro'), 'utf-8')
     // Page mode: .map()-only arrays should be kept
-    section = await analyzeAstroSection(source, '_page_docs', 'docsPage', 'src/pages/docs/index.astro', { mode: 'page' })
+    section = await analyzeAstroSection(
+      source,
+      '_page_docs',
+      'docsPage',
+      'src/pages/docs/index.astro',
+      { mode: 'page' },
+    )
     // Component mode (default): .map()-only arrays should be filtered
-    sectionComponent = await analyzeAstroSection(source, 'docs', 'DocsSection', 'src/components/docs.astro')
+    sectionComponent = await analyzeAstroSection(
+      source,
+      'docs',
+      'DocsSection',
+      'src/components/docs.astro',
+    )
   })
 
   it('should detect the sections array on page mode', () => {
-    const arrayFields = section.fields.filter(f => f.type === 'array')
+    const arrayFields = section.fields.filter((f) => f.type === 'array')
     expect(arrayFields.length).toBeGreaterThan(0)
   })
 
   it('should detect "sections" variable as a field on page mode', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('sections')
   })
 
   it('should NOT detect "sections" variable in component mode (.map()-only filter)', () => {
-    const keys = sectionComponent.fields.map(f => f.key)
+    const keys = sectionComponent.fields.map((f) => f.key)
     expect(keys).not.toContain('sections')
   })
 })
@@ -370,15 +429,33 @@ const title = 'Meine Seite';
 `
 
   it('should not remove export const prerender', async () => {
-    const section = await analyzeAstroSection(pageWithPrerender, '_page_test', 'testPage', 'test.astro', { mode: 'page' })
-    const patched = await patchTemplateForFields(pageWithPrerender, '_page_test', section.fields, [], { mode: 'page' })
+    const section = await analyzeAstroSection(
+      pageWithPrerender,
+      '_page_test',
+      'testPage',
+      'test.astro',
+      { mode: 'page' },
+    )
+    const patched = await patchTemplateForFields(
+      pageWithPrerender,
+      '_page_test',
+      section.fields,
+      [],
+      { mode: 'page' },
+    )
     expect(patched).toContain('export const prerender = true')
     expect(patched).not.toMatch(/^export\s*$/m) // no bare "export " line
   })
 
   it('should not detect prerender as a content field', async () => {
-    const section = await analyzeAstroSection(pageWithPrerender, '_page_test', 'testPage', 'test.astro', { mode: 'page' })
-    const keys = section.fields.map(f => f.key)
+    const section = await analyzeAstroSection(
+      pageWithPrerender,
+      '_page_test',
+      'testPage',
+      'test.astro',
+      { mode: 'page' },
+    )
+    const keys = section.fields.map((f) => f.key)
     expect(keys).not.toContain('prerender')
   })
 })
@@ -412,7 +489,13 @@ const SECTION_COMPONENTS: Record<string, any> = {
 `
 
   it('should detect alreadyIntegrated and skip adoption', async () => {
-    const section = await analyzeAstroSection(integratedPage, '_page_index', 'indexPage', 'test.astro', { mode: 'page' })
+    const section = await analyzeAstroSection(
+      integratedPage,
+      '_page_index',
+      'indexPage',
+      'test.astro',
+      { mode: 'page' },
+    )
     expect(section.alreadyIntegrated).toBe(true)
   })
 })
@@ -471,7 +554,13 @@ describe('Layout regions: header and footer analysis', () => {
     expect(headerHtml).toBeTruthy()
 
     const regionSource = `---\n---\n\n${headerHtml}`
-    const section = await analyzeAstroSection(regionSource, '_layout_header', 'header', 'test-layout.astro', { mode: 'page' })
+    const section = await analyzeAstroSection(
+      regionSource,
+      '_layout_header',
+      'header',
+      'test-layout.astro',
+      { mode: 'page' },
+    )
     expect(section.fields.length).toBeGreaterThan(0)
   })
 
@@ -480,21 +569,36 @@ describe('Layout regions: header and footer analysis', () => {
     expect(footerHtml).toBeTruthy()
 
     const regionSource = `---\n---\n\n${footerHtml}`
-    const section = await analyzeAstroSection(regionSource, '_layout_footer', 'footer', 'test-layout.astro', { mode: 'page' })
+    const section = await analyzeAstroSection(
+      regionSource,
+      '_layout_footer',
+      'footer',
+      'test-layout.astro',
+      { mode: 'page' },
+    )
     expect(section.fields.length).toBeGreaterThan(0)
   })
 
   it('should detect text fields in header (brand name, nav links)', async () => {
     const headerHtml = extractRegionHtml(layoutSource, 'header')!
     const regionSource = `---\n---\n\n${headerHtml}`
-    const section = await analyzeAstroSection(regionSource, '_layout_header', 'header', 'test-layout.astro', { mode: 'page' })
+    const section = await analyzeAstroSection(
+      regionSource,
+      '_layout_header',
+      'header',
+      'test-layout.astro',
+      { mode: 'page' },
+    )
 
-    const textFields = section.fields.filter(f => f.type === 'text')
+    const textFields = section.fields.filter((f) => f.type === 'text')
     expect(textFields.length).toBeGreaterThan(0)
     // Should find brand name or nav link text
     const hasNavContent = textFields.some(
-      f => typeof f.defaultValue === 'string' &&
-        (f.defaultValue.includes('MeinBrand') || f.defaultValue.includes('Features') || f.defaultValue.includes('Jetzt starten')),
+      (f) =>
+        typeof f.defaultValue === 'string' &&
+        (f.defaultValue.includes('MeinBrand') ||
+          f.defaultValue.includes('Features') ||
+          f.defaultValue.includes('Jetzt starten')),
     )
     expect(hasNavContent, 'Should detect header text content').toBe(true)
   })
@@ -502,13 +606,22 @@ describe('Layout regions: header and footer analysis', () => {
   it('should detect text fields in footer (brand, tagline, copyright)', async () => {
     const footerHtml = extractRegionHtml(layoutSource, 'footer')!
     const regionSource = `---\n---\n\n${footerHtml}`
-    const section = await analyzeAstroSection(regionSource, '_layout_footer', 'footer', 'test-layout.astro', { mode: 'page' })
+    const section = await analyzeAstroSection(
+      regionSource,
+      '_layout_footer',
+      'footer',
+      'test-layout.astro',
+      { mode: 'page' },
+    )
 
-    const textFields = section.fields.filter(f => f.type === 'text')
+    const textFields = section.fields.filter((f) => f.type === 'text')
     expect(textFields.length).toBeGreaterThan(0)
     const hasFooterContent = textFields.some(
-      f => typeof f.defaultValue === 'string' &&
-        (f.defaultValue.includes('MeinBrand') || f.defaultValue.includes('CMS') || f.defaultValue.includes('Rechte')),
+      (f) =>
+        typeof f.defaultValue === 'string' &&
+        (f.defaultValue.includes('MeinBrand') ||
+          f.defaultValue.includes('CMS') ||
+          f.defaultValue.includes('Rechte')),
     )
     expect(hasFooterContent, 'Should detect footer text content').toBe(true)
   })
@@ -521,7 +634,9 @@ describe('Layout regions: header and footer analysis', () => {
 // ---------------------------------------------------------------------------
 
 describe('Page sweep: all pages in pages/', () => {
-  const pageFiles = readdirSync(PAGES_DIR).filter(f => f.endsWith('.astro')).sort()
+  const pageFiles = readdirSync(PAGES_DIR)
+    .filter((f) => f.endsWith('.astro'))
+    .sort()
 
   for (const file of pageFiles) {
     describe(file, () => {
@@ -530,8 +645,13 @@ describe('Page sweep: all pages in pages/', () => {
 
       beforeAll(async () => {
         source = readFileSync(join(PAGES_DIR, file), 'utf-8')
-        const pageKey = `_page_${basename(file, '.astro').replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '')}`
-        section = await analyzeAstroSection(source, pageKey, 'testPage', `src/pages/${file}`, { mode: 'page' })
+        const pageKey = `_page_${basename(file, '.astro')
+          .replace(/([A-Z])/g, '_$1')
+          .toLowerCase()
+          .replace(/^_/, '')}`
+        section = await analyzeAstroSection(source, pageKey, 'testPage', `src/pages/${file}`, {
+          mode: 'page',
+        })
       })
 
       it('should not crash during analysis', () => {
@@ -567,22 +687,26 @@ describe('DocsIndexPage: nested sections[].items[] detection', () => {
   beforeAll(async () => {
     source = readFileSync(join(PAGES_DIR, 'DocsIndexPage.astro'), 'utf-8')
     section = await analyzeAstroSection(
-      source, '_page_docs', 'docsPage', 'src/pages/docs/index.astro', { mode: 'page' },
+      source,
+      '_page_docs',
+      'docsPage',
+      'src/pages/docs/index.astro',
+      { mode: 'page' },
     )
   })
 
   it('should detect the outer sections array', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('sections')
   })
 
   it('should detect sections as an array field', () => {
-    const sectionsField = section.fields.find(f => f.key === 'sections')
+    const sectionsField = section.fields.find((f) => f.key === 'sections')
     expect(sectionsField?.type).toBe('array')
   })
 
   it('should detect items inside each section as an array field (not [object Object])', () => {
-    const sectionsField = section.fields.find(f => f.key === 'sections')
+    const sectionsField = section.fields.find((f) => f.key === 'sections')
     const rows = sectionsField?.defaultValue as Array<Record<string, unknown>> | undefined
     expect(Array.isArray(rows)).toBe(true)
     if (rows) {
@@ -600,7 +724,7 @@ describe('DocsIndexPage: nested sections[].items[] detection', () => {
     const allValues = JSON.stringify(section.fields)
     expect(allValues).not.toContain('[object Object]')
     // At least one item object should have a title key
-    const sectionsField = section.fields.find(f => f.key === 'sections')
+    const sectionsField = section.fields.find((f) => f.key === 'sections')
     const rows = sectionsField?.defaultValue as Array<Record<string, unknown>> | undefined
     if (rows?.[0]) {
       const items = rows[0]['items'] as Array<Record<string, unknown>> | undefined
@@ -622,17 +746,21 @@ describe('EventSchedulePage: nested days[].sessions[] detection', () => {
   beforeAll(async () => {
     source = readFileSync(join(PAGES_DIR, 'EventSchedulePage.astro'), 'utf-8')
     section = await analyzeAstroSection(
-      source, '_page_event_schedule', 'eventPage', 'src/pages/event.astro', { mode: 'page' },
+      source,
+      '_page_event_schedule',
+      'eventPage',
+      'src/pages/event.astro',
+      { mode: 'page' },
     )
   })
 
   it('should detect the outer days array', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('days')
   })
 
   it('should detect sessions inside each day without [object Object]', () => {
-    const daysField = section.fields.find(f => f.key === 'days')
+    const daysField = section.fields.find((f) => f.key === 'days')
     const rows = daysField?.defaultValue as Array<Record<string, unknown>> | undefined
     expect(Array.isArray(rows)).toBe(true)
     if (rows) {
@@ -644,7 +772,7 @@ describe('EventSchedulePage: nested days[].sessions[] detection', () => {
   })
 
   it('should detect session sub-fields (time, title, speaker)', () => {
-    const daysField = section.fields.find(f => f.key === 'days')
+    const daysField = section.fields.find((f) => f.key === 'days')
     const rows = daysField?.defaultValue as Array<Record<string, unknown>> | undefined
     const sessions = rows?.[0]?.['sessions'] as Array<Record<string, unknown>> | undefined
     expect(sessions?.[0]).toHaveProperty('title')
@@ -652,8 +780,10 @@ describe('EventSchedulePage: nested days[].sessions[] detection', () => {
   })
 
   it('should also detect frontmatter scalar vars (eventTitle, eventLocation)', () => {
-    const keys = section.fields.map(f => f.key)
-    const hasScalars = keys.some(k => k === 'eventTitle' || k === 'eventLocation' || k === 'eventDate')
+    const keys = section.fields.map((f) => f.key)
+    const hasScalars = keys.some(
+      (k) => k === 'eventTitle' || k === 'eventLocation' || k === 'eventDate',
+    )
     expect(hasScalars).toBe(true)
   })
 })
@@ -669,17 +799,21 @@ describe('ChangelogPage: nested releases[].changes[] detection', () => {
   beforeAll(async () => {
     source = readFileSync(join(PAGES_DIR, 'ChangelogPage.astro'), 'utf-8')
     section = await analyzeAstroSection(
-      source, '_page_changelog', 'changelogPage', 'src/pages/changelog.astro', { mode: 'page' },
+      source,
+      '_page_changelog',
+      'changelogPage',
+      'src/pages/changelog.astro',
+      { mode: 'page' },
     )
   })
 
   it('should detect the releases array', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('releases')
   })
 
   it('should detect changes inside each release without [object Object]', () => {
-    const releasesField = section.fields.find(f => f.key === 'releases')
+    const releasesField = section.fields.find((f) => f.key === 'releases')
     const rows = releasesField?.defaultValue as Array<Record<string, unknown>> | undefined
     expect(Array.isArray(rows)).toBe(true)
     if (rows) {
@@ -691,7 +825,7 @@ describe('ChangelogPage: nested releases[].changes[] detection', () => {
   })
 
   it('should detect change sub-fields (type, text)', () => {
-    const releasesField = section.fields.find(f => f.key === 'releases')
+    const releasesField = section.fields.find((f) => f.key === 'releases')
     const rows = releasesField?.defaultValue as Array<Record<string, unknown>> | undefined
     const changes = rows?.[0]?.['changes'] as Array<Record<string, unknown>> | undefined
     expect(changes?.[0]).toHaveProperty('text')
@@ -710,17 +844,21 @@ describe('BlogListPage: posts array and featuredPost object', () => {
   beforeAll(async () => {
     source = readFileSync(join(PAGES_DIR, 'BlogListPage.astro'), 'utf-8')
     section = await analyzeAstroSection(
-      source, '_page_blog', 'blogPage', 'src/pages/blog/index.astro', { mode: 'page' },
+      source,
+      '_page_blog',
+      'blogPage',
+      'src/pages/blog/index.astro',
+      { mode: 'page' },
     )
   })
 
   it('should detect the posts array', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('posts')
   })
 
   it('should detect posts as an array-of-objects with expected sub-fields', () => {
-    const postsField = section.fields.find(f => f.key === 'posts')
+    const postsField = section.fields.find((f) => f.key === 'posts')
     expect(postsField?.type).toBe('array')
     const items = postsField?.defaultValue as Array<Record<string, unknown>> | undefined
     expect(items?.[0]).toHaveProperty('title')
@@ -732,9 +870,11 @@ describe('BlogListPage: posts array and featuredPost object', () => {
   })
 
   it('should detect featuredPost or its scalar fields', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     // Either as a single object field or its sub-fields are detected
-    const hasFeatured = keys.some(k => k.toLowerCase().includes('featured') || k.toLowerCase().includes('post'))
+    const hasFeatured = keys.some(
+      (k) => k.toLowerCase().includes('featured') || k.toLowerCase().includes('post'),
+    )
     expect(hasFeatured).toBe(true)
   })
 })
@@ -750,22 +890,26 @@ describe('PricingPage: plans with nested features[] and table', () => {
   beforeAll(async () => {
     source = readFileSync(join(PAGES_DIR, 'PricingPage.astro'), 'utf-8')
     section = await analyzeAstroSection(
-      source, '_page_pricing', 'pricingPage', 'src/pages/pricing.astro', { mode: 'page' },
+      source,
+      '_page_pricing',
+      'pricingPage',
+      'src/pages/pricing.astro',
+      { mode: 'page' },
     )
   })
 
   it('should detect the plans array', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('plans')
   })
 
   it('should not contain [object Object] in plans or nested features', () => {
-    const plansField = section.fields.find(f => f.key === 'plans')
+    const plansField = section.fields.find((f) => f.key === 'plans')
     expect(JSON.stringify(plansField)).not.toContain('[object Object]')
   })
 
   it('should detect faqItems array', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('faqItems')
   })
 
@@ -785,18 +929,22 @@ describe('LandingIndexPage: inline maps and steps array', () => {
   beforeAll(async () => {
     source = readFileSync(join(PAGES_DIR, 'LandingIndexPage.astro'), 'utf-8')
     section = await analyzeAstroSection(
-      source, '_page_index', 'indexPage', 'src/pages/index.astro', { mode: 'page' },
+      source,
+      '_page_index',
+      'indexPage',
+      'src/pages/index.astro',
+      { mode: 'page' },
     )
   })
 
   it('should detect frontmatter scalar vars (headline, ctaText)', () => {
-    const keys = section.fields.map(f => f.key)
-    const hasHero = keys.some(k => k === 'headline' || k === 'ctaText' || k === 'subheadline')
+    const keys = section.fields.map((f) => f.key)
+    const hasHero = keys.some((k) => k === 'headline' || k === 'ctaText' || k === 'subheadline')
     expect(hasHero).toBe(true)
   })
 
   it('should detect the steps array', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('steps')
   })
 
@@ -816,23 +964,27 @@ describe('AboutPage: team, milestones, inline values', () => {
   beforeAll(async () => {
     source = readFileSync(join(PAGES_DIR, 'AboutPage.astro'), 'utf-8')
     section = await analyzeAstroSection(
-      source, '_page_about', 'aboutPage', 'src/pages/about.astro', { mode: 'page' },
+      source,
+      '_page_about',
+      'aboutPage',
+      'src/pages/about.astro',
+      { mode: 'page' },
     )
   })
 
   it('should detect the team array', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('team')
   })
 
   it('should detect team members as objects with name/role/bio', () => {
-    const teamField = section.fields.find(f => f.key === 'team')
+    const teamField = section.fields.find((f) => f.key === 'team')
     const items = teamField?.defaultValue as Array<Record<string, unknown>> | undefined
     expect(items?.[0]).toHaveProperty('name')
   })
 
   it('should detect the milestones array', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('milestones')
   })
 
@@ -854,9 +1006,9 @@ function hasStructuralObjectString(value: unknown): boolean {
     // A string that IS exactly [object Object] or a comma-joined list of them is structural
     return /^\[object Object\](,\[object Object\])*$/.test(value.trim())
   }
-  if (Array.isArray(value)) return value.some(item => hasStructuralObjectString(item))
+  if (Array.isArray(value)) return value.some((item) => hasStructuralObjectString(item))
   if (value !== null && typeof value === 'object') {
-    return Object.values(value as object).some(v => hasStructuralObjectString(v))
+    return Object.values(value as object).some((v) => hasStructuralObjectString(v))
   }
   return false
 }
@@ -892,17 +1044,20 @@ describe('Docs architecture page: table row detection', () => {
   beforeAll(async () => {
     source = readFileSync(join(PAGES_DIR, 'DocsArchitecturePage.astro'), 'utf-8')
     section = await analyzeAstroSection(
-      source, '_page_docs_architecture', 'architecturePage',
-      'src/pages/docs/architecture.astro', { mode: 'page' },
+      source,
+      '_page_docs_architecture',
+      'architecturePage',
+      'src/pages/docs/architecture.astro',
+      { mode: 'page' },
     )
   })
 
   it('should detect the table as an array field', () => {
-    const arrayFields = section.fields.filter(f => f.type === 'array')
+    const arrayFields = section.fields.filter((f) => f.type === 'array')
     expect(arrayFields.length).toBeGreaterThan(0)
     // Should find an array with 3 entries (the 3 tbody rows)
-    const tableField = arrayFields.find(f =>
-      Array.isArray(f.defaultValue) && f.defaultValue.length === 3,
+    const tableField = arrayFields.find(
+      (f) => Array.isArray(f.defaultValue) && f.defaultValue.length === 3,
     )
     expect(tableField).toBeDefined()
   })
@@ -924,14 +1079,14 @@ describe('Docs architecture page: table row detection', () => {
 
   it('should label the table field "Tabellen-Zeilen"', () => {
     const tableField = section.fields.find(
-      f => f.type === 'array' && Array.isArray(f.defaultValue) && f.defaultValue.length === 3,
+      (f) => f.type === 'array' && Array.isArray(f.defaultValue) && f.defaultValue.length === 3,
     )
     expect(tableField?.label).toBe('Tabellen-Zeilen')
   })
 
   it('should include td text in defaultValue', () => {
     const tableField = section.fields.find(
-      f => f.type === 'array' && Array.isArray(f.defaultValue) && f.defaultValue.length === 3,
+      (f) => f.type === 'array' && Array.isArray(f.defaultValue) && f.defaultValue.length === 3,
     )
     const rows = tableField?.defaultValue as Array<Record<string, unknown>>
     // First row should contain "ContentRepository"
@@ -940,7 +1095,7 @@ describe('Docs architecture page: table row detection', () => {
   })
 
   it('should also detect headings outside the table', () => {
-    const headings = section.fields.filter(f => f.key.startsWith('heading'))
+    const headings = section.fields.filter((f) => f.key.startsWith('heading'))
     expect(headings.length).toBeGreaterThan(0)
   })
 })
@@ -959,30 +1114,37 @@ describe('Docs installation page: CodeBlock import handling', () => {
   })
 
   it('should NOT detect CodeBlock as a section import', () => {
-    const imports = extractSectionImports(
-      source, 'src/pages/docs/installation.astro', [], '',
-    )
-    const codeBlockImport = imports.find(i => i.componentName === 'CodeBlock')
+    const imports = extractSectionImports(source, 'src/pages/docs/installation.astro', [], '')
+    const codeBlockImport = imports.find((i) => i.componentName === 'CodeBlock')
     expect(codeBlockImport).toBeUndefined()
   })
 
   it('should detect page-level headings on installation page', async () => {
     const section = await analyzeAstroSection(
-      source, '_page_docs_installation', 'installationPage',
-      'src/pages/docs/installation.astro', { mode: 'page' },
+      source,
+      '_page_docs_installation',
+      'installationPage',
+      'src/pages/docs/installation.astro',
+      { mode: 'page' },
     )
-    const headings = section.fields.filter(f => f.key.startsWith('heading'))
+    const headings = section.fields.filter((f) => f.key.startsWith('heading'))
     expect(headings.length).toBeGreaterThan(0)
   })
 
   it('should detect repeated CodeBlock components as array in page-level scan', async () => {
     const section = await analyzeAstroSection(
-      source, '_page_docs_installation', 'installationPage',
-      'src/pages/docs/installation.astro', { mode: 'page' },
+      source,
+      '_page_docs_installation',
+      'installationPage',
+      'src/pages/docs/installation.astro',
+      { mode: 'page' },
     )
     // 4 CodeBlock components → detected as a "codeBlocks" array
     const codeBlockField = section.fields.find(
-      f => f.type === 'array' && typeof f.key === 'string' && f.key.toLowerCase().includes('codeblock'),
+      (f) =>
+        f.type === 'array' &&
+        typeof f.key === 'string' &&
+        f.key.toLowerCase().includes('codeblock'),
     )
     expect(codeBlockField).toBeDefined()
     expect(Array.isArray(codeBlockField?.defaultValue)).toBe(true)
@@ -1005,10 +1167,16 @@ describe('Nested map live-edit: inner items have data-sk-field', () => {
   beforeAll(async () => {
     source = readFileSync(join(PAGES_DIR, 'DocsIndexPage.astro'), 'utf-8')
     section = await analyzeAstroSection(
-      source, '_page_docs', 'docsPage', 'src/pages/docs/index.astro', { mode: 'page' },
+      source,
+      '_page_docs',
+      'docsPage',
+      'src/pages/docs/index.astro',
+      { mode: 'page' },
     )
     const groups = (section as any)._analyzerResult?.repeatedGroups ?? []
-    patched = await patchTemplateForFields(source, '_page_docs', section.fields, groups, { mode: 'page' })
+    patched = await patchTemplateForFields(source, '_page_docs', section.fields, groups, {
+      mode: 'page',
+    })
   })
 
   it('should add _j index to inner .map() call', () => {
@@ -1042,17 +1210,23 @@ describe('Page-level: template literal variables not extracted as fields', () =>
 
   beforeAll(async () => {
     const source = readFileSync(join(SECTIONS_DIR, 'PageWithTemplateLiterals.astro'), 'utf-8')
-    section = await analyzeAstroSection(source, '_page_docs_example', 'docsExamplePage', 'src/pages/docs/example.astro', { mode: 'page' })
+    section = await analyzeAstroSection(
+      source,
+      '_page_docs_example',
+      'docsExamplePage',
+      'src/pages/docs/example.astro',
+      { mode: 'page' },
+    )
   })
 
   it('should detect the real content fields (heading, description)', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).toContain('heading')
     expect(keys).toContain('description')
   })
 
   it('should NOT extract variables from inside template literal strings (templates, hero, json, template)', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).not.toContain('templates')
     expect(keys).not.toContain('hero')
     expect(keys).not.toContain('json')
@@ -1060,14 +1234,14 @@ describe('Page-level: template literal variables not extracted as fields', () =>
   })
 
   it('should NOT extract the code variables themselves (exampleCode, cliCode, apiCode)', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     expect(keys).not.toContain('exampleCode')
     expect(keys).not.toContain('cliCode')
     expect(keys).not.toContain('apiCode')
   })
 
   it('should find only legitimate fields (no spurious template-literal variables)', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     // Only real content fields should be present — no code variable names
     const spurious = ['templates', 'hero', 'json', 'template', 'exampleCode', 'cliCode', 'apiCode']
     for (const key of spurious) {