@setzkasten-cms/astro-admin 0.6.0

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

@@ -0,0 +1,1033 @@
+/**
+ * Page-level content detection tests.
+ *
+ * Tests that the analyzer correctly detects inline content on pages
+ * (frontmatter arrays, headings, text) — not just imported section components.
+ *
+ * Covers:
+ *   1. Pure inline page (like /docs — no section imports, all content inline)
+ *   2. Mixed page (section imports + inline content)
+ *   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 { 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')
+
+// ---------------------------------------------------------------------------
+// 1. Pure inline page (PageInlineContent.astro)
+//    Simulates a docs page with ALL content in frontmatter + template.
+// ---------------------------------------------------------------------------
+
+describe('Page-level: pure inline content', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+  let patched: string
+  let groups: any[]
+
+  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' })
+    groups = (section as any)._analyzerResult?.repeatedGroups ?? []
+    patched = await patchTemplateForFields(source, '_page_docs', section.fields, groups, { mode: 'page' })
+  })
+
+  it('should detect fields from inline content', () => {
+    expect(section.fields.length).toBeGreaterThan(0)
+  })
+
+  it('should detect text fields (headings, paragraphs, overline)', () => {
+    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)
+    expect(keys).toContain('heading')
+    expect(keys).toContain('description')
+  })
+
+  it('should patch with data-sk-field attributes', () => {
+    expect(patched).toContain('data-sk-field')
+  })
+
+  it('should inject getSection import (not Astro.props) in page mode', () => {
+    expect(patched).toContain("import { getSection } from 'setzkasten:content'")
+    expect(patched).toContain("getSection('_page_docs')")
+  })
+
+  it('should NOT inject Astro.props in page mode', () => {
+    // The original source doesn't have Astro.props and page mode shouldn't add it
+    expect(patched).not.toContain('Astro.props')
+  })
+
+  it('should not contain [object Object]', () => {
+    expect(patched).not.toContain('[object Object]')
+  })
+
+  it('should re-parse cleanly after patching', async () => {
+    await expect(
+      analyzeAstroSection(patched, '_page_docs__reparse', 'docsPage', 'reparse-test'),
+    ).resolves.toBeDefined()
+  })
+
+  it('should use skData bindings', () => {
+    expect(patched).toContain('skData?.')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 2. Mixed page (PageMixedContent.astro)
+//    Has imported section components AND inline content (testimonials).
+//    The analyzer should find the inline content fields.
+// ---------------------------------------------------------------------------
+
+describe('Page-level: mixed content (imports + inline)', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+  let groups: any[]
+
+  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' })
+    groups = (section as any)._analyzerResult?.repeatedGroups ?? []
+  })
+
+  it('should detect inline content fields', () => {
+    expect(section.fields.length).toBeGreaterThan(0)
+  })
+
+  it('should detect inline text fields', () => {
+    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')
+    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.defaultValue.includes('Kunden') || f.defaultValue.includes('Feedback')),
+    )
+    expect(hasExpectedText, 'Should detect inline heading or paragraph text').toBe(true)
+  })
+
+  it('should NOT include imported component content as fields', () => {
+    // HeroSection and FeaturesSection are imports — their internal fields
+    // should NOT appear when analyzing the page template
+    // (imports are <HeroSection /> tags, their content is in separate files)
+    for (const field of section.fields) {
+      // If an import-sourced field leaked through, it would be detected as a component tag
+      expect(field.key).not.toMatch(/^hero/i)
+      expect(field.key).not.toMatch(/^feature/i)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 3. Patcher mode comparison: 'component' vs 'page'
+//    Same source, different modes → different frontmatter injection.
+// ---------------------------------------------------------------------------
+
+describe('Patcher mode: component vs page', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+  let groups: any[]
+
+  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' })
+    groups = (section as any)._analyzerResult?.repeatedGroups ?? []
+  })
+
+  it('component mode should inject Astro.props', async () => {
+    const patched = await patchTemplateForFields(source, '_page_docs', section.fields, groups)
+    expect(patched).toContain('Astro.props')
+    expect(patched).not.toContain("getSection('_page_docs')")
+  })
+
+  it('page mode should inject getSection', async () => {
+    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')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 4. Edge case: page with no detectable content
+//    A minimal page with only a layout wrapper should produce no fields.
+// ---------------------------------------------------------------------------
+
+describe('Page-level: minimal page (no content)', () => {
+  const minimalPage = `---
+---
+
+<html><body><slot /></body></html>
+`
+
+  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' })
+    expect(section.fields).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 5. Edge case: page already integrated (has getSection)
+// ---------------------------------------------------------------------------
+
+describe('Page-level: already integrated page', () => {
+  const integratedPage = `---
+import BaseLayout from '../layouts/BaseLayout.astro';
+import { getSection } from 'setzkasten:content';
+const skData = getSection('_page_about');
+---
+
+<BaseLayout title="About">
+  <h1 data-sk-field="_page_about.title" set:html={skData?.title}>Über uns</h1>
+</BaseLayout>
+`
+
+  it('should detect alreadyIntegrated flag', async () => {
+    const section = await analyzeAstroSection(integratedPage, '_page_about', 'aboutPage', 'src/pages/about.astro', { mode: 'page' })
+    expect(section.alreadyIntegrated).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 6. Integration: full scan flow for mixed page
+//    Simulates what init-scan-page.ts does:
+//      1. extractSectionImports() → finds imported section components
+//      2. analyzeAstroSection() on page source → finds inline content
+//    Both must return results for a mixed page.
+// ---------------------------------------------------------------------------
+
+describe('Full scan flow: mixed page (imports + inline)', () => {
+  let source: string
+  let imports: ReturnType<typeof extractSectionImports>
+  let pageSection: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  beforeAll(async () => {
+    source = readFileSync(join(SECTIONS_DIR, 'PageMixedContent.astro'), 'utf-8')
+
+    // Simulate repo file tree (the section component files exist)
+    const repoFiles: RepoFile[] = [
+      { path: 'src/pages/index.astro', type: 'blob' },
+      { path: 'src/components/sections/HeroSection.astro', type: 'blob' },
+      { path: 'src/components/sections/FeaturesSection.astro', type: 'blob' },
+      { path: 'src/layouts/BaseLayout.astro', type: 'blob' },
+    ]
+
+    // Step 1: extractSectionImports (same as init-scan-page.ts line 95)
+    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' })
+  })
+
+  it('should find imported section components via extractSectionImports', () => {
+    expect(imports.length).toBeGreaterThan(0)
+    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)
+    expect(keys).toContain('hero')
+    expect(keys).toContain('features')
+  })
+
+  it('should resolve file paths for imported sections', () => {
+    for (const imp of imports) {
+      expect(imp.resolvedPath, `${imp.componentName} should have resolvedPath`).toBeTruthy()
+    }
+  })
+
+  it('should detect inline content separately via page-level analysis', () => {
+    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.defaultValue.includes('Kunden') || f.defaultValue.includes('Feedback')),
+    )
+    expect(hasInlineContent, 'Page-level should find inline text content').toBe(true)
+  })
+
+  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))
+    expect(importKeys.has(pageSection.key)).toBe(false)
+  })
+
+  it('should cover all content: imports + page-level together', () => {
+    // A mixed page produces:
+    //   - N imported sections (each analyzed separately from their component source)
+    //   - 1 page-level section (inline content analyzed from page source)
+    const totalSections = imports.length + 1 // +1 for page-level
+    expect(totalSections).toBeGreaterThanOrEqual(3) // 2 imports + 1 page-level
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 7. Integration: pure inline page has no section imports
+//    extractSectionImports should return empty, but page-level finds fields.
+// ---------------------------------------------------------------------------
+
+describe('Full scan flow: pure inline page (no imports)', () => {
+  let source: string
+  let imports: ReturnType<typeof extractSectionImports>
+  let pageSection: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  beforeAll(async () => {
+    source = readFileSync(join(SECTIONS_DIR, 'PageInlineContent.astro'), 'utf-8')
+
+    const repoFiles: RepoFile[] = [
+      { path: 'src/pages/docs/index.astro', type: 'blob' },
+      { path: 'src/layouts/BaseLayout.astro', type: 'blob' },
+    ]
+
+    imports = extractSectionImports(source, 'src/pages/docs/index.astro', repoFiles, '')
+    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', () => {
+    expect(imports).toHaveLength(0)
+  })
+
+  it('should still detect content via page-level analysis', () => {
+    expect(pageSection.fields.length).toBeGreaterThan(0)
+  })
+
+  it('should detect heading and description fields', () => {
+    const keys = pageSection.fields.map(f => f.key)
+    expect(keys).toContain('heading')
+    expect(keys).toContain('description')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 7b. Page-level: .map()-only arrays must be detected on pages
+//     In component mode, .map()-only arrays are filtered (they become
+//     repeatedGroup inner fields). In page mode, they are standalone content.
+// ---------------------------------------------------------------------------
+
+describe('Page-level: .map()-only arrays detected', () => {
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+  let sectionComponent: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  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' })
+    // Component mode (default): .map()-only arrays should be filtered
+    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')
+    expect(arrayFields.length).toBeGreaterThan(0)
+  })
+
+  it('should detect "sections" variable as a field on page mode', () => {
+    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)
+    expect(keys).not.toContain('sections')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 8. Regression: export const prerender must not be removed by patcher
+//    Bug: removeOldVarDeclarations matched "const prerender = true" inside
+//    "export const prerender = true" and removed it, leaving "export " behind.
+// ---------------------------------------------------------------------------
+
+describe('Patcher safety: export const prerender preserved', () => {
+  const pageWithPrerender = `---
+export const prerender = true;
+
+import BaseLayout from '../layouts/BaseLayout.astro';
+
+const title = 'Meine Seite';
+---
+
+<BaseLayout>
+  <h1>{title}</h1>
+  <p>Beschreibung der Seite.</p>
+</BaseLayout>
+`
+
+  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' })
+    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)
+    expect(keys).not.toContain('prerender')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 9. Regression: already-integrated page must not be re-patched
+//    Bug: page with getSection/setzkasten:content was offered for adoption,
+//    patcher added duplicate imports and removed essential variables.
+// ---------------------------------------------------------------------------
+
+describe('Patcher safety: already integrated page not re-patched', () => {
+  const integratedPage = `---
+export const prerender = true;
+
+import BaseLayout from '../layouts/BaseLayout.astro';
+import HeroSection from '../components/sections/HeroSection.astro';
+import { getPage, getSection } from 'setzkasten:content';
+
+const page = getPage('index');
+const normalize = (k: string) => k.replace(/[-_]/g, '').toLowerCase();
+const SECTION_COMPONENTS: Record<string, any> = {
+  [normalize('hero')]: HeroSection,
+};
+---
+
+<BaseLayout>
+  {page?.sections.map(({ Component, data }) => (
+    <Component data={data} />
+  ))}
+</BaseLayout>
+`
+
+  it('should detect alreadyIntegrated and skip adoption', async () => {
+    const section = await analyzeAstroSection(integratedPage, '_page_index', 'indexPage', 'test.astro', { mode: 'page' })
+    expect(section.alreadyIntegrated).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 10. Layout detection: extractLayoutImport
+// ---------------------------------------------------------------------------
+
+describe('Layout detection: extractLayoutImport', () => {
+  it('should find layout import from page source', () => {
+    const pageSource = `---
+import BaseLayout from '../layouts/BaseLayout.astro';
+---
+<BaseLayout><h1>Hello</h1></BaseLayout>`
+
+    const repoFiles: RepoFile[] = [
+      { path: 'src/pages/index.astro', type: 'blob' },
+      { path: 'src/layouts/BaseLayout.astro', type: 'blob' },
+    ]
+
+    const layout = extractLayoutImport(pageSource, 'src/pages/index.astro', repoFiles, '')
+    expect(layout).not.toBeNull()
+    expect(layout!.componentName).toBe('BaseLayout')
+    expect(layout!.resolvedPath).toBe('src/layouts/BaseLayout.astro')
+  })
+
+  it('should return null if no layout import exists', () => {
+    const pageSource = `---
+import HeroSection from '../components/sections/HeroSection.astro';
+---
+<HeroSection />`
+
+    const repoFiles: RepoFile[] = [
+      { path: 'src/pages/index.astro', type: 'blob' },
+      { path: 'src/components/sections/HeroSection.astro', type: 'blob' },
+    ]
+
+    const layout = extractLayoutImport(pageSource, 'src/pages/index.astro', repoFiles, '')
+    expect(layout).toBeNull()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 11. Layout regions: header and footer content detection
+// ---------------------------------------------------------------------------
+
+describe('Layout regions: header and footer analysis', () => {
+  let layoutSource: string
+
+  beforeAll(() => {
+    layoutSource = readFileSync(join(SECTIONS_DIR, 'layouts', 'TestLayout.astro'), 'utf-8')
+  })
+
+  it('should detect header content as a section', async () => {
+    const headerHtml = extractRegionHtml(layoutSource, 'header')
+    expect(headerHtml).toBeTruthy()
+
+    const regionSource = `---\n---\n\n${headerHtml}`
+    const section = await analyzeAstroSection(regionSource, '_layout_header', 'header', 'test-layout.astro', { mode: 'page' })
+    expect(section.fields.length).toBeGreaterThan(0)
+  })
+
+  it('should detect footer content as a section', async () => {
+    const footerHtml = extractRegionHtml(layoutSource, 'footer')
+    expect(footerHtml).toBeTruthy()
+
+    const regionSource = `---\n---\n\n${footerHtml}`
+    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 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')),
+    )
+    expect(hasNavContent, 'Should detect header text content').toBe(true)
+  })
+
+  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 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')),
+    )
+    expect(hasFooterContent, 'Should detect footer text content').toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 14. Generic page sweep — every file in test-sections/pages/ is analyzed.
+//     Automatically covers new test pages without manual registration.
+//     Checks: no crash, ≥1 field detected, no [object Object] in any value.
+// ---------------------------------------------------------------------------
+
+describe('Page sweep: all pages in pages/', () => {
+  const pageFiles = readdirSync(PAGES_DIR).filter(f => f.endsWith('.astro')).sort()
+
+  for (const file of pageFiles) {
+    describe(file, () => {
+      let source: string
+      let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+      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' })
+      })
+
+      it('should not crash during analysis', () => {
+        expect(section).toBeDefined()
+        expect(section.fields).toBeDefined()
+      })
+
+      it('should detect at least one field', () => {
+        expect(section.fields.length).toBeGreaterThan(0)
+      })
+
+      it('should not produce [object Object] in any field value', () => {
+        // Check for structural [object Object] — array items that weren't parsed as proper
+        // objects/primitives but got stringified. String fields that happen to *contain*
+        // the text "[object Object]" (e.g. changelog entries describing the bug) are fine.
+        expect(hasStructuralObjectString(section.fields)).toBe(false)
+      })
+    })
+  }
+})
+
+// ---------------------------------------------------------------------------
+// 15. DocsIndexPage: nested sections array (sections[].items[])
+//     Bug case: items array of {title,href,description} objects was shown
+//     as [object Object] in the CMS. The analyzer must detect items as
+//     an array-of-objects field with correct sub-fields.
+// ---------------------------------------------------------------------------
+
+describe('DocsIndexPage: nested sections[].items[] detection', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  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' },
+    )
+  })
+
+  it('should detect the outer sections array', () => {
+    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')
+    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 rows = sectionsField?.defaultValue as Array<Record<string, unknown>> | undefined
+    expect(Array.isArray(rows)).toBe(true)
+    if (rows) {
+      for (const row of rows) {
+        // items must not stringify to "[object Object]" (would mean objects weren't parsed)
+        const itemsValue = row['items']
+        expect(JSON.stringify(itemsValue)).not.toContain('[object Object]')
+        // items should be an array
+        expect(Array.isArray(itemsValue)).toBe(true)
+      }
+    }
+  })
+
+  it('should detect item sub-fields (title, href, description)', () => {
+    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 rows = sectionsField?.defaultValue as Array<Record<string, unknown>> | undefined
+    if (rows?.[0]) {
+      const items = rows[0]['items'] as Array<Record<string, unknown>> | undefined
+      expect(items?.[0]).toHaveProperty('title')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 16. EventSchedulePage: nested days[].sessions[] map detection
+//     Same double-nested map pattern as DocsIndexPage. Each day has
+//     sessions with time/title/speaker/track/description.
+// ---------------------------------------------------------------------------
+
+describe('EventSchedulePage: nested days[].sessions[] detection', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  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' },
+    )
+  })
+
+  it('should detect the outer days array', () => {
+    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 rows = daysField?.defaultValue as Array<Record<string, unknown>> | undefined
+    expect(Array.isArray(rows)).toBe(true)
+    if (rows) {
+      for (const row of rows) {
+        expect(JSON.stringify(row['sessions'])).not.toContain('[object Object]')
+        expect(Array.isArray(row['sessions'])).toBe(true)
+      }
+    }
+  })
+
+  it('should detect session sub-fields (time, title, speaker)', () => {
+    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')
+    expect(sessions?.[0]).toHaveProperty('time')
+  })
+
+  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')
+    expect(hasScalars).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 17. ChangelogPage: nested releases[].changes[] detection
+// ---------------------------------------------------------------------------
+
+describe('ChangelogPage: nested releases[].changes[] detection', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  beforeAll(async () => {
+    source = readFileSync(join(PAGES_DIR, 'ChangelogPage.astro'), 'utf-8')
+    section = await analyzeAstroSection(
+      source, '_page_changelog', 'changelogPage', 'src/pages/changelog.astro', { mode: 'page' },
+    )
+  })
+
+  it('should detect the releases array', () => {
+    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 rows = releasesField?.defaultValue as Array<Record<string, unknown>> | undefined
+    expect(Array.isArray(rows)).toBe(true)
+    if (rows) {
+      for (const row of rows) {
+        expect(hasStructuralObjectString(row['changes'])).toBe(false)
+        expect(Array.isArray(row['changes'])).toBe(true)
+      }
+    }
+  })
+
+  it('should detect change sub-fields (type, text)', () => {
+    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')
+    expect(changes?.[0]).toHaveProperty('type')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 18. BlogListPage: frontmatter posts array + single featuredPost object
+// ---------------------------------------------------------------------------
+
+describe('BlogListPage: posts array and featuredPost object', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  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' },
+    )
+  })
+
+  it('should detect the posts array', () => {
+    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')
+    expect(postsField?.type).toBe('array')
+    const items = postsField?.defaultValue as Array<Record<string, unknown>> | undefined
+    expect(items?.[0]).toHaveProperty('title')
+    expect(items?.[0]).toHaveProperty('excerpt')
+  })
+
+  it('should not contain [object Object] anywhere', () => {
+    expect(JSON.stringify(section.fields)).not.toContain('[object Object]')
+  })
+
+  it('should detect featuredPost or its scalar fields', () => {
+    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'))
+    expect(hasFeatured).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 19. PricingPage: plans array with nested features string array + table
+// ---------------------------------------------------------------------------
+
+describe('PricingPage: plans with nested features[] and table', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  beforeAll(async () => {
+    source = readFileSync(join(PAGES_DIR, 'PricingPage.astro'), 'utf-8')
+    section = await analyzeAstroSection(
+      source, '_page_pricing', 'pricingPage', 'src/pages/pricing.astro', { mode: 'page' },
+    )
+  })
+
+  it('should detect the plans array', () => {
+    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')
+    expect(JSON.stringify(plansField)).not.toContain('[object Object]')
+  })
+
+  it('should detect faqItems array', () => {
+    const keys = section.fields.map(f => f.key)
+    expect(keys).toContain('faqItems')
+  })
+
+  it('should not produce [object Object] anywhere', () => {
+    expect(JSON.stringify(section.fields)).not.toContain('[object Object]')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 20. LandingIndexPage: inline .map() arrays + frontmatter steps array
+// ---------------------------------------------------------------------------
+
+describe('LandingIndexPage: inline maps and steps array', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  beforeAll(async () => {
+    source = readFileSync(join(PAGES_DIR, 'LandingIndexPage.astro'), 'utf-8')
+    section = await analyzeAstroSection(
+      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')
+    expect(hasHero).toBe(true)
+  })
+
+  it('should detect the steps array', () => {
+    const keys = section.fields.map(f => f.key)
+    expect(keys).toContain('steps')
+  })
+
+  it('should not produce [object Object] anywhere', () => {
+    expect(JSON.stringify(section.fields)).not.toContain('[object Object]')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 21. AboutPage: team array + milestones array + inline values map
+// ---------------------------------------------------------------------------
+
+describe('AboutPage: team, milestones, inline values', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  beforeAll(async () => {
+    source = readFileSync(join(PAGES_DIR, 'AboutPage.astro'), 'utf-8')
+    section = await analyzeAstroSection(
+      source, '_page_about', 'aboutPage', 'src/pages/about.astro', { mode: 'page' },
+    )
+  })
+
+  it('should detect the team array', () => {
+    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 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)
+    expect(keys).toContain('milestones')
+  })
+
+  it('should not produce [object Object] anywhere', () => {
+    expect(JSON.stringify(section.fields)).not.toContain('[object Object]')
+  })
+})
+
+/**
+ * Helper: extract a <tag>...</tag> region from layout source (strips frontmatter first).
+ */
+/**
+ * Checks for STRUCTURAL [object Object] — values that were not properly parsed
+ * (e.g. an array item got coerced to string "[object Object]").
+ * Does NOT flag string fields that happen to CONTAIN "[object Object]" as text.
+ */
+function hasStructuralObjectString(value: unknown): boolean {
+  if (typeof value === 'string') {
+    // 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 (value !== null && typeof value === 'object') {
+    return Object.values(value as object).some(v => hasStructuralObjectString(v))
+  }
+  return false
+}
+
+function extractRegionHtml(layoutSource: string, tag: string): string | null {
+  let template = layoutSource
+  if (layoutSource.startsWith('---')) {
+    const endIdx = layoutSource.indexOf('\n---', 3)
+    if (endIdx !== -1) template = layoutSource.slice(endIdx + 4)
+  }
+
+  const openTag = new RegExp(`<${tag}(\\s[^>]*)?>`, 'i')
+  const openMatch = openTag.exec(template)
+  if (!openMatch) return null
+
+  const closeTag = `</${tag}>`
+  const closeIdx = template.indexOf(closeTag, openMatch.index)
+  if (closeIdx === -1) return null
+
+  return template.slice(openMatch.index, closeIdx + closeTag.length)
+}
+
+// ---------------------------------------------------------------------------
+// 12. Docs architecture page: table detection
+//     The /docs/architecture page has a <table> with hardcoded <tbody><tr> rows.
+//     The analyzer should detect the rows as a repeatedGroup array field.
+// ---------------------------------------------------------------------------
+
+describe('Docs architecture page: table row detection', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+
+  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' },
+    )
+  })
+
+  it('should detect the table as an array field', () => {
+    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,
+    )
+    expect(tableField).toBeDefined()
+  })
+
+  it('should produce a repeatedGroup for <tbody><tr>', () => {
+    const groups = (section as any)._analyzerResult?.repeatedGroups ?? []
+    const tableGroup = groups.find((g: any) => g.tag === 'tr')
+    expect(tableGroup).toBeDefined()
+    expect(tableGroup.instances).toHaveLength(3)
+  })
+
+  it('should detect td cell content as inner fields', () => {
+    const groups = (section as any)._analyzerResult?.repeatedGroups ?? []
+    const tableGroup = groups.find((g: any) => g.tag === 'tr')
+    expect(tableGroup).toBeDefined()
+    // Each row has 3 <td> cells → 3 inner fields
+    expect(tableGroup.fields.length).toBeGreaterThanOrEqual(3)
+  })
+
+  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,
+    )
+    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,
+    )
+    const rows = tableField?.defaultValue as Array<Record<string, unknown>>
+    // First row should contain "ContentRepository"
+    const firstRow = rows[0]
+    expect(Object.values(firstRow ?? {})).toContain('ContentRepository')
+  })
+
+  it('should also detect headings outside the table', () => {
+    const headings = section.fields.filter(f => f.key.startsWith('heading'))
+    expect(headings.length).toBeGreaterThan(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 13. Docs installation page: CodeBlock not treated as a section import
+//     CodeBlock is a generic component (not a CMS section).
+//     extractSectionImports must NOT pick it up as a section.
+// ---------------------------------------------------------------------------
+
+describe('Docs installation page: CodeBlock import handling', () => {
+  let source: string
+
+  beforeAll(() => {
+    source = readFileSync(join(PAGES_DIR, 'DocsInstallationPage.astro'), 'utf-8')
+  })
+
+  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')
+    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' },
+    )
+    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' },
+    )
+    // 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'),
+    )
+    expect(codeBlockField).toBeDefined()
+    expect(Array.isArray(codeBlockField?.defaultValue)).toBe(true)
+    expect((codeBlockField?.defaultValue as unknown[]).length).toBe(4)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 22. Nested map live-edit: inner items must get data-sk-field bindings
+//     Bug: patchArrayField patched outer sections.map() but left inner
+//     section.items.map() without _j index and without data-sk-field attrs.
+//     After fix: inner map must have _j, container binding, and field bindings.
+// ---------------------------------------------------------------------------
+
+describe('Nested map live-edit: inner items have data-sk-field', () => {
+  let source: string
+  let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+  let patched: string
+
+  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' },
+    )
+    const groups = (section as any)._analyzerResult?.repeatedGroups ?? []
+    patched = await patchTemplateForFields(source, '_page_docs', section.fields, groups, { mode: 'page' })
+  })
+
+  it('should add _j index to inner .map() call', () => {
+    expect(patched).toMatch(/items\.map\s*\(\s*\(?\s*item\s*,\s*_j\s*\)?/)
+  })
+
+  it('should add container data-sk-field to first element of inner map', () => {
+    expect(patched).toContain('data-sk-field={`_page_docs.sections.${_i}.items.${_j}`}')
+  })
+
+  it('should add data-sk-field for item.title in inner map', () => {
+    expect(patched).toContain('_page_docs.sections.${_i}.items.${_j}.title')
+  })
+
+  it('should add data-sk-field for item.description in inner map', () => {
+    expect(patched).toContain('_page_docs.sections.${_i}.items.${_j}.description')
+  })
+
+  it('should still have outer sections map with _i index', () => {
+    expect(patched).toMatch(/sections.*map.*section.*_i/)
+  })
+})