@setzkasten-cms/astro-admin 0.6.0

package/src/init/__tests__/patcher-page-mode.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Patcher page-mode bug regression tests.
+ *
+ * Covers 5 specific bugs that were fixed in template-patcher-v2:
+ *   1. patchArrayField always uses mapExpressions[0] (second array gets same expression)
+ *   2. patchSectionId puts id on Astro component instead of <section> in page mode
+ *   3. patchTextField only patches first matching text node
+ *   4. removeOldVarDeclarations leaves trailing semicolon
+ *   5. removeOldVarDeclarations causes TDZ (alias placed before skData declaration)
+ */
+
+import { describe, it, expect } from 'vitest'
+import { patchTemplateForFields } from '../../init/template-patcher-v2'
+import type { PatchField } from '../../init/template-patcher-v2'
+
+// ---------------------------------------------------------------------------
+// Bug 1: patchArrayField always uses mapExpressions[0]
+//
+// When a page has two separate inline {[...].map()} arrays, both get patched
+// to the same (first) expression. The second array's .map() ends up using the
+// first array's skData key and defaultValue items.
+// ---------------------------------------------------------------------------
+
+describe('Bug 1: patchArrayField uses correct expression per field', () => {
+  // The bug: patchArrayField always picked mapExpressions[0], so both fields
+  // patched the SAME first .map() expression. Fix: content-based matching
+  // searches for the field's first defaultValue item within each expression.
+  // The fixture uses inline arrays (the bug only affected those, not var.map()).
+  const source = `---
+export const prerender = true;
+import BaseLayout from '../layouts/BaseLayout.astro';
+---
+
+<BaseLayout>
+  <section class="py-16">
+    <div class="grid">
+      {[
+        { name: '@setzkasten-cms/core', desc: 'Schema, Feldtypen, Validation' },
+        { name: '@setzkasten-cms/ui', desc: 'React-UI: Provider, FormStore' },
+      ].map((pkg) => (
+        <div>
+          <h3>{pkg.name}</h3>
+          <p>{pkg.desc}</p>
+        </div>
+      ))}
+    </div>
+    <div class="grid">
+      {[
+        { title: 'Dependency Inversion', desc: 'UI haengt nur von Ports ab' },
+        { title: 'Schema-First', desc: 'Alles leitet sich vom TypeScript-Schema ab' },
+      ].map((principle) => (
+        <div>
+          <h3>{principle.title}</h3>
+          <p>{principle.desc}</p>
+        </div>
+      ))}
+    </div>
+  </section>
+</BaseLayout>
+`
+
+  const fields: PatchField[] = [
+    { key: 'items', type: 'array', defaultValue: [
+      { name: '@setzkasten-cms/core', desc: 'Schema, Feldtypen, Validation' },
+      { name: '@setzkasten-cms/ui', desc: 'React-UI: Provider, FormStore' },
+    ]},
+    { key: 'items2', type: 'array', defaultValue: [
+      { title: 'Dependency Inversion', desc: 'UI haengt nur von Ports ab' },
+      { title: 'Schema-First', desc: 'Alles leitet sich vom TypeScript-Schema ab' },
+    ]},
+  ]
+
+  it('should reference skData?.items for the first array', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    expect(patched).toContain('skData?.items')
+  })
+
+  it('should reference skData?.items2 for the second array', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    expect(patched).toContain('skData?.items2')
+  })
+
+  it('should not bleed defaultValue items across arrays', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    // The patcher generates (skData?.items ?? []).map(...) for each array field.
+    // Both patterns must appear as distinct, non-overlapping substrings.
+    expect(patched).toContain('skData?.items2')
+    // skData?.items must appear as a standalone reference (not only as prefix of items2)
+    // Strip all occurrences of "items2" and check "items" is still present
+    expect(patched.replace(/items2/g, 'ITEMS2')).toContain('skData?.items')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Bug 2: patchSectionId puts id on Astro component in page mode
+//
+// In page mode the patcher was adding id="section-X" to <BaseLayout> (an
+// Astro component) rather than to the inner <section> element. The preview
+// middleware looks for <section id="section-X"> in the rendered DOM.
+// ---------------------------------------------------------------------------
+
+describe('Bug 2: patchSectionId targets <section> not <BaseLayout> in page mode', () => {
+  const source = `---
+import BaseLayout from '../layouts/BaseLayout.astro';
+---
+
+<BaseLayout>
+  <section class="py-16">
+    <h1>Titel</h1>
+  </section>
+</BaseLayout>
+`
+
+  const fields: PatchField[] = [
+    { key: 'heading', type: 'text', defaultValue: 'Titel' },
+  ]
+
+  it('should add id="section-_page_test" to the <section> element', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    expect(patched).toMatch(/<section[^>]*id="section-_page_test"/)
+  })
+
+  it('should NOT add id to <BaseLayout>', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    expect(patched).not.toMatch(/<BaseLayout[^>]*id=/)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Bug 3: patchTextField only patches first matching text node
+//
+// When multiple elements contain identical text (e.g. an <h1> and a <span>
+// both say "Architektur"), only the first occurrence was being patched.
+// Both elements should receive data-sk-field and set:html bindings.
+// ---------------------------------------------------------------------------
+
+describe('Bug 3: patchTextField patches all matching text nodes', () => {
+  const source = `---
+import BaseLayout from '../layouts/BaseLayout.astro';
+---
+
+<BaseLayout>
+  <section class="py-16">
+    <nav><span>Architektur</span></nav>
+    <h1>Architektur</h1>
+  </section>
+</BaseLayout>
+`
+
+  const fields: PatchField[] = [
+    { key: 'heading', type: 'text', defaultValue: 'Architektur' },
+  ]
+
+  it('should add data-sk-field to the <h1> element', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    expect(patched).toMatch(/<h1[^>]*data-sk-field/)
+  })
+
+  it('should add data-sk-field to the <span> element', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    expect(patched).toMatch(/<span[^>]*data-sk-field/)
+  })
+
+  it('should add set:html to both elements', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+    // Count occurrences of set:html — should appear at least twice
+    const matches = patched.match(/set:html/g) ?? []
+    expect(matches.length).toBeGreaterThanOrEqual(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Bug 4: removeOldVarDeclarations leaves trailing semicolon
+//
+// After removing `const fields = [...]`, the array body was cleared but the
+// closing `};` or standalone `;` was left as a stray line in the frontmatter.
+// ---------------------------------------------------------------------------
+
+describe('Bug 4: removeOldVarDeclarations does not leave stray semicolon', () => {
+  const source = `---
+import BaseLayout from '../layouts/BaseLayout.astro';
+
+const fields = ['Alpha', 'Beta', 'Gamma'];
+---
+
+<BaseLayout>
+  <section class="py-16">
+    <ul>
+      {fields.map((f) => <li>{f}</li>)}
+    </ul>
+  </section>
+</BaseLayout>
+`
+
+  const fields: PatchField[] = [
+    { key: 'fields', type: 'array', defaultValue: ['Alpha', 'Beta', 'Gamma'] },
+  ]
+
+  it('should not contain a line that is only a semicolon in the frontmatter', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+
+    // Extract frontmatter
+    const fmMatch = patched.match(/^---\n([\s\S]*?)\n---/)
+    const frontmatter = fmMatch ? fmMatch[1]! : patched
+
+    const lines = frontmatter.split('\n').map(l => l.trim())
+    expect(lines).not.toContain(';')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Bug 5: removeOldVarDeclarations causes TDZ
+//
+// When `const fields = skData?.fields ?? []` alias was inserted BEFORE
+// `const skData = getSection(...)`, accessing `skData` threw a
+// "Cannot access 'skData' before initialization" error at runtime.
+// The alias must always appear AFTER the skData declaration.
+// ---------------------------------------------------------------------------
+
+describe('Bug 5: removeOldVarDeclarations alias placed after skData (no TDZ)', () => {
+  const source = `---
+import BaseLayout from '../layouts/BaseLayout.astro';
+
+const fields = ['Alpha', 'Beta', 'Gamma'];
+---
+
+<BaseLayout>
+  <section class="py-16">
+    <p>Anzahl: {fields.length}</p>
+    <ul>
+      {fields.map((f) => <li>{f}</li>)}
+    </ul>
+  </section>
+</BaseLayout>
+`
+
+  const patchFields: PatchField[] = [
+    { key: 'fields', type: 'array', defaultValue: ['Alpha', 'Beta', 'Gamma'] },
+  ]
+
+  it('should place the fields alias AFTER the skData declaration', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', patchFields, [], { mode: 'page' })
+
+    const fmMatch = patched.match(/^---\n([\s\S]*?)\n---/)
+    const frontmatter = fmMatch ? fmMatch[1]! : patched
+
+    const skDataIndex = frontmatter.indexOf('const skData = getSection(')
+    const aliasIndex = frontmatter.indexOf('const fields = skData?.')
+
+    expect(skDataIndex, 'skData declaration should exist in frontmatter').toBeGreaterThan(-1)
+    expect(aliasIndex, 'fields alias should exist in frontmatter').toBeGreaterThan(-1)
+    expect(aliasIndex).toBeGreaterThan(skDataIndex)
+  })
+
+  it('should not contain a stray semicolon line in frontmatter', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', patchFields, [], { mode: 'page' })
+
+    const fmMatch = patched.match(/^---\n([\s\S]*?)\n---/)
+    const frontmatter = fmMatch ? fmMatch[1]! : patched
+
+    const lines = frontmatter.split('\n').map(l => l.trim())
+    expect(lines).not.toContain(';')
+  })
+
+  it('should preserve fields.length in the template', async () => {
+    const patched = await patchTemplateForFields(source, '_page_test', patchFields, [], { mode: 'page' })
+
+    // Extract template (after closing ---)
+    const templatePart = patched.split('\n---\n').slice(1).join('\n---\n')
+    expect(templatePart).toContain('fields.length')
+  })
+})

package/src/init/__tests__/section-pipeline.test.ts

@@ -0,0 +1,393 @@
+/**
+ * Section Pipeline tests — migrated from test-sections-runner.mts
+ *
+ * Runs analyzer v2 + patcher v2 on every .astro file in test-sections/
+ * and validates:
+ *   - Basic bindings (data-sk-field, skData, Astro.props, no [object Object])
+ *   - Repeated groups (.map, instance reduction, CSS integrity)
+ *   - Content JSON completeness
+ *   - _classN alignment + tag consistency
+ *   - Re-parse validity
+ *   - data-sk-field binding coverage
+ *   - Stale frontmatter var cleanup
+ */
+
+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'
+
+// ---------------------------------------------------------------------------
+// Test sections directory (root of monorepo)
+// ---------------------------------------------------------------------------
+
+const SECTIONS_DIR = join(import.meta.dirname!, '..', '..', '..', '..', '..', 'test-sections')
+const files = readdirSync(SECTIONS_DIR).filter(f => f.endsWith('.astro')).sort()
+
+// ---------------------------------------------------------------------------
+// Helpers (ported from test-sections-runner.mts)
+// ---------------------------------------------------------------------------
+
+function extractClassValues(src: string): string[] {
+  const regex = /class="([^"]*)"/g
+  const classes: string[] = []
+  let m: RegExpExecArray | null
+  while ((m = regex.exec(src)) !== null) classes.push(m[1]!)
+  return classes
+}
+
+function checkCssIntegrity(
+  source: string,
+  patched: string,
+  groups: Array<{ tag: string; instances: Array<{ start: number; end: number }>; fields?: Array<{ key: string; defaultValues?: unknown[] }> }>,
+): { ok: boolean; lost: string[] } {
+  const lost: string[] = []
+  const dynamicClassValues = new Set<string>()
+  for (const g of groups) {
+    for (const f of (g.fields ?? [])) {
+      if (f.key.startsWith('_class') && f.defaultValues) {
+        for (const dv of f.defaultValues) {
+          if (typeof dv === 'string') dynamicClassValues.add(dv)
+        }
+      }
+    }
+  }
+  for (const g of groups) {
+    const originalClasses = new Set<string>()
+    for (const inst of g.instances) {
+      for (const cls of extractClassValues(source.slice(inst.start, inst.end))) {
+        originalClasses.add(cls)
+      }
+    }
+    const patchedClasses = new Set(extractClassValues(patched))
+    for (const cls of originalClasses) {
+      if (!patchedClasses.has(cls) && !dynamicClassValues.has(cls)) lost.push(cls)
+    }
+  }
+  return { ok: lost.length === 0, lost }
+}
+
+const SK_FIELD_NOT_NEEDED = new Set(['image', 'icon'])
+
+function fieldNeedsSkBinding(field: { key: string; type: string }): boolean {
+  if (SK_FIELD_NOT_NEEDED.has(field.type)) return false
+  if (field.key.startsWith('_class')) return false
+  if (/link\d*$/i.test(field.key) && !/text/i.test(field.key)) return false
+  if (/alt\d*$/i.test(field.key)) return false
+  return true
+}
+
+function checkSkFieldBindings(
+  patched: string,
+  sectionKey: string,
+  fields: Array<{ key: string; type: string }>,
+  groups: Array<{ fieldKey: string; fields: Array<{ key: string; type: string }> }>,
+): { ok: boolean; missing: string[]; found: string[]; skipped: string[] } {
+  const missing: string[] = []
+  const found: string[] = []
+  const skipped: string[] = []
+  const repeatedFieldKeys = new Set<string>()
+  for (const g of groups) repeatedFieldKeys.add(g.fieldKey)
+
+  for (const field of fields) {
+    if (repeatedFieldKeys.has(field.key)) {
+      const mapBinding = `${sectionKey}.${field.key}.\${_i}`
+      if (patched.includes(mapBinding)) {
+        found.push(`${sectionKey}.${field.key}.*`)
+      } else {
+        missing.push(`${sectionKey}.${field.key}.* (container)`)
+      }
+      continue
+    }
+    if (!fieldNeedsSkBinding(field)) {
+      skipped.push(`${sectionKey}.${field.key} (${field.type})`)
+      continue
+    }
+    if (!patched.includes(`?.${field.key}`)) {
+      skipped.push(`${sectionKey}.${field.key} (not replaced)`)
+      continue
+    }
+    const binding = `${sectionKey}.${field.key}`
+    const hasStaticBinding = patched.includes(`data-sk-field="${binding}"`)
+    const hasExprBinding = patched.includes(`data-sk-field={\`${binding}`)
+    if (hasStaticBinding || hasExprBinding) {
+      found.push(binding)
+    } else {
+      missing.push(binding)
+    }
+  }
+
+  for (const g of groups) {
+    for (const innerField of g.fields) {
+      if (innerField.type === 'array') { skipped.push(`${sectionKey}.${g.fieldKey}.*.${innerField.key} (array)`); continue }
+      if (!fieldNeedsSkBinding(innerField)) { skipped.push(`${sectionKey}.${g.fieldKey}.*.${innerField.key} (${innerField.type})`); continue }
+      if (!patched.includes(`item.${innerField.key}`)) { skipped.push(`${sectionKey}.${g.fieldKey}.*.${innerField.key} (not replaced)`); continue }
+      const innerBinding = `${sectionKey}.${g.fieldKey}.\${_i}.${innerField.key}`
+      if (patched.includes(innerBinding)) {
+        found.push(`${sectionKey}.${g.fieldKey}.*.${innerField.key}`)
+      } else {
+        missing.push(`${sectionKey}.${g.fieldKey}.*.${innerField.key}`)
+      }
+    }
+  }
+  return { ok: missing.length === 0, missing, found, skipped }
+}
+
+// ---------------------------------------------------------------------------
+// Test suite: one describe per .astro file in test-sections/
+// ---------------------------------------------------------------------------
+
+describe('Section Pipeline', () => {
+  for (const file of files) {
+    const name = basename(file, '.astro')
+    const filenameKey = name
+      .replace(/Section$/, '')
+      .replace(/([A-Z])/g, (m, c, i) => (i === 0 ? c.toLowerCase() : '-' + c.toLowerCase()))
+
+    describe(name, () => {
+      let source: string
+      let section: Awaited<ReturnType<typeof analyzeAstroSection>>
+      let patched: string
+      let groups: any[]
+      // Page-mode fixtures already have getSection() — detect and handle separately
+      let isPageMode: boolean
+      let sectionKey: string
+
+      beforeAll(async () => {
+        source = readFileSync(join(SECTIONS_DIR, file), 'utf-8')
+        isPageMode = source.includes("import { getSection } from 'setzkasten:content'")
+        const getSectionMatch = isPageMode ? source.match(/getSection\(['"]([^'"]+)['"]\)/) : null
+        sectionKey = getSectionMatch?.[1] ?? filenameKey
+        const options = isPageMode ? { mode: 'page' as const } : undefined
+        section = await analyzeAstroSection(source, sectionKey, name, `src/components/sections/${file}`, options)
+        groups = (section as any)._analyzerResult?.repeatedGroups ?? []
+        patched = await patchTemplateForFields(source, sectionKey, section.fields, groups, options)
+      })
+
+      it('should detect fields', () => {
+        expect(section.fields.length).toBeGreaterThan(0)
+      })
+
+      it('should contain data-sk-field after patching', () => {
+        if (patched === source) return // no changes needed
+        expect(patched).toContain('data-sk-field')
+      })
+
+      it('should contain skData bindings', () => {
+        if (patched === source) return
+        expect(patched).toContain('skData?.')
+      })
+
+      it('should contain Astro.props or getSection (page mode)', () => {
+        if (patched === source) return
+        if (isPageMode) {
+          expect(patched).toContain('getSection(')
+        } else {
+          expect(patched).toContain('Astro.props')
+        }
+      })
+
+      it('should not contain [object Object]', () => {
+        expect(patched).not.toContain('[object Object]')
+      })
+
+      it('should not have duplicate arrays from repeated groups as top-level fields', () => {
+        if (groups.length === 0) return
+        const innerArraySources = new Set<string>()
+        for (const g of groups) {
+          for (const f of g.fields) {
+            if (f.type === 'array') {
+              for (const pos of f.positions) {
+                if (pos?.source) innerArraySources.add(pos.source)
+              }
+            }
+          }
+        }
+        const duplicateArrays = section.fields.filter((f: any) =>
+          f.type === 'array' && innerArraySources.has(f.key),
+        )
+        expect(duplicateArrays, `Duplicate arrays: ${duplicateArrays.map((f: any) => f.key).join(', ')}`).toHaveLength(0)
+      })
+
+      it('should remove consumed frontmatter vars', () => {
+        if (patched === source || groups.length === 0) return
+        const fmEnd = patched.indexOf('---', patched.indexOf('---') + 3)
+        const patchedFm = fmEnd > 0 ? patched.slice(0, fmEnd) : ''
+        const staleVars: string[] = []
+        for (const g of groups) {
+          for (const f of g.fields) {
+            for (const pos of f.positions) {
+              if (pos?.source && patchedFm.includes(`const ${pos.source}`)) {
+                staleVars.push(pos.source)
+              }
+            }
+          }
+        }
+        expect(staleVars, `Stale vars: ${staleVars.join(', ')}`).toHaveLength(0)
+      })
+
+      it('should generate .map() for repeated groups', () => {
+        if (groups.length === 0) return
+        expect(patched).toContain('.map((item,')
+      })
+
+      it('should reduce instance count for repeated groups', () => {
+        if (groups.length === 0) return
+        for (const g of groups) {
+          const tagRegex = new RegExp(`<${g.tag}[\\s>]`, 'g')
+          const originalCount = (source.match(tagRegex) || []).length
+          const patchedCount = (patched.match(tagRegex) || []).length
+          expect(patchedCount, `<${g.tag}> count should decrease`).toBeLessThan(originalCount)
+        }
+      })
+
+      it('should preserve CSS classes', () => {
+        if (patched === source || groups.length === 0) return
+        const css = checkCssIntegrity(source, patched, groups)
+        expect(css.lost, `Lost CSS classes: ${css.lost.slice(0, 3).join(', ')}`).toHaveLength(0)
+      })
+
+      it('should produce complete content JSON', () => {
+        if (groups.length === 0) return
+        const issues: string[] = []
+
+        for (const g of groups) {
+          const arrayField = section.fields.find((f: any) => f.key === g.fieldKey)
+          if (!arrayField) { issues.push(`No top-level field for group ${g.fieldKey}`); continue }
+
+          const items = arrayField.defaultValue as Array<Record<string, unknown>> | undefined
+          if (!Array.isArray(items) || items.length === 0) {
+            issues.push(`${g.fieldKey} defaultValue is empty or not an array`)
+            continue
+          }
+
+          for (const innerField of g.fields) {
+            for (let ii = 0; ii < items.length && ii < innerField.defaultValues.length; ii++) {
+              const expected = innerField.defaultValues[ii]
+              if (expected == null) continue
+              const actual = items[ii]?.[innerField.key]
+              if (actual === undefined) {
+                issues.push(`${g.fieldKey}[${ii}].${innerField.key} missing`)
+              }
+            }
+          }
+
+          const itemRefRegex = /\bitem\.(\w+)/g
+          let refMatch: RegExpExecArray | null
+          const referencedKeys = new Set<string>()
+          while ((refMatch = itemRefRegex.exec(patched)) !== null) {
+            referencedKeys.add(refMatch[1]!)
+          }
+          for (const refKey of referencedKeys) {
+            if (['map', 'length', 'filter', 'forEach', 'join', 'slice'].includes(refKey)) continue
+            const hasInAnyItem = items.some(item => refKey in item)
+            if (!hasInAnyItem) {
+              issues.push(`{item.${refKey}} used in template but missing in content JSON`)
+            }
+          }
+        }
+
+        expect(issues, issues.slice(0, 5).join('\n')).toHaveLength(0)
+      })
+
+      it('should have correct _classN alignment', () => {
+        if (groups.length === 0) return
+        const issues: string[] = []
+
+        for (const g of groups) {
+          const classFields = g.fields.filter((f: any) => f.key.startsWith('_class'))
+          if (classFields.length === 0 || !g.classAttrs) continue
+
+          for (let instIdx = 0; instIdx < g.instances.length; instIdx++) {
+            const instAttrs = g.classAttrs[instIdx]
+            if (!instAttrs) continue
+
+            const originalClassCounts = new Map<string, number>()
+            for (const attr of instAttrs) {
+              originalClassCounts.set(attr.value, (originalClassCounts.get(attr.value) ?? 0) + 1)
+            }
+
+            const assignedClassCounts = new Map<string, string[]>()
+            for (const cf of classFields) {
+              const val = cf.defaultValues[instIdx]
+              if (typeof val !== 'string') continue
+              if (instIdx > 0 && val === cf.defaultValues[0]) continue
+              const arr = assignedClassCounts.get(val) ?? []
+              arr.push(cf.key)
+              assignedClassCounts.set(val, arr)
+            }
+
+            for (const [val, keys] of assignedClassCounts) {
+              const origCount = originalClassCounts.get(val) ?? 0
+              if (keys.length > origCount) {
+                const label = instIdx === 0 ? 'template' : `instance ${instIdx}`
+                issues.push(`${g.fieldKey} ${label}: "${val.slice(0, 40)}" assigned to [${keys.join(', ')}] but appears ${origCount}×`)
+              }
+            }
+          }
+        }
+
+        expect(issues, issues.slice(0, 3).join('\n')).toHaveLength(0)
+      })
+
+      it('should have correct _classN tag consistency', () => {
+        if (groups.length === 0) return
+        const issues: string[] = []
+
+        for (const g of groups) {
+          const classFields = g.fields.filter((f: any) => f.key.startsWith('_class'))
+          if (classFields.length === 0 || !g.classAttrs) continue
+
+          const classTagMap = new Map<string, string>()
+          const classTagRegex = /<(\w+)[\s][^>]*?class=\{item\.(_class\d+)\}/g
+          let ctm: RegExpExecArray | null
+          while ((ctm = classTagRegex.exec(patched)) !== null) {
+            classTagMap.set(ctm[2]!, ctm[1]!)
+          }
+
+          for (const cf of classFields) {
+            const expectedTag = classTagMap.get(cf.key)
+            if (!expectedTag) continue
+            const templateValue = cf.defaultValues[0]
+
+            for (let instIdx = 1; instIdx < g.instances.length; instIdx++) {
+              const instValue = cf.defaultValues[instIdx]
+              if (typeof instValue !== 'string') continue
+              if (instValue === templateValue) continue
+
+              const instAttrs = g.classAttrs[instIdx]
+              if (!instAttrs) continue
+
+              const matchingAttr = instAttrs.find((a: any) => a.value === instValue)
+              if (!matchingAttr) continue
+
+              const pathParts = matchingAttr.path.split('/')
+              const lastPart = pathParts[pathParts.length - 1]!
+              const actualTag = lastPart.replace(/:\d+$/, '') || g.tag
+
+              if (actualTag !== expectedTag) {
+                issues.push(`${cf.key} instance ${instIdx}: expected <${expectedTag}> but on <${actualTag}>`)
+              }
+            }
+          }
+        }
+
+        expect(issues, issues.slice(0, 3).join('\n')).toHaveLength(0)
+      })
+
+      it('should re-parse cleanly after patching', async () => {
+        if (patched === source) return
+        await expect(
+          analyzeAstroSection(patched, sectionKey + '__reparse', name, 'reparse-test'),
+        ).resolves.toBeDefined()
+      })
+
+      it('should have complete data-sk-field bindings', () => {
+        if (patched === source) return
+        const bindings = checkSkFieldBindings(patched, sectionKey, section.fields, groups)
+        expect(bindings.missing, `Missing bindings: ${bindings.missing.join(', ')}`).toHaveLength(0)
+      })
+    })
+  }
+})