@setzkasten-cms/astro-admin 0.6.0

package/src/init/astro-section-analyzer-v2.ts

@@ -0,0 +1,1663 @@
+/**
+ * Astro-specific section component analysis (v2).
+ *
+ * Two-phase architecture:
+ *   Phase 1 — Structural detection (AST-based, position-tracked, no CSS heuristics)
+ *   Phase 2 — Label enrichment (delegated to field-label-enricher.ts)
+ *
+ * The analyzer produces an AnalyzerResult that is consumed by:
+ *   - field-label-enricher.ts (cosmetic labels)
+ *   - template-patcher-v2.ts  (template transformation)
+ */
+
+import { parse } from '@astrojs/compiler'
+import { inferFields, type InferredSection, type InferredField } from '@setzkasten-cms/core/init'
+import type {
+  AnalyzerResult,
+  RepeatedGroup,
+  RepeatedGroupInstance,
+  InnerFieldInfo,
+  FieldPosition,
+} from './analyzer-types.js'
+import { enrichFieldLabels } from './field-label-enricher.js'
+
+// ---------------------------------------------------------------------------
+// AST types
+// ---------------------------------------------------------------------------
+
+interface AstNode {
+  type: string
+  position?: { start: { offset: number; line: number; column: number }; end?: { offset: number } }
+  children?: AstNode[]
+  attributes?: AstAttr[]
+  name?: string
+  value?: string
+}
+
+interface AstAttr {
+  type: 'attribute'
+  kind: 'quoted' | 'empty' | 'expression' | 'spread' | 'shorthand' | 'template-literal'
+  name: string
+  value: string
+  raw?: string
+  position?: { start: { offset: number } }
+}
+
+function walkAst(node: AstNode, callback: (node: AstNode, parent: AstNode | null) => void, parent: AstNode | null = null): void {
+  callback(node, parent)
+  if (node.children) {
+    for (const child of node.children) {
+      walkAst(child, callback, node)
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Analyze an Astro section component and infer its fields.
+ * Returns an AnalyzerResult with structural field info + repeated groups for the patcher.
+ */
+export async function analyzeAstroSection(
+  source: string,
+  sectionKey: string,
+  componentName: string,
+  componentPath: string,
+  options?: { mode?: 'component' | 'page' },
+): Promise<InferredSection & { _analyzerResult: AnalyzerResult }> {
+  const isPageMode = options?.mode === 'page'
+  const alreadyIntegrated =
+    source.includes('data-sk-field') ||
+    source.includes('getSection(') ||
+    source.includes('setzkasten:content')
+
+  const { frontmatter, template, templateOffset } = splitAstroFile(source)
+
+  // Filter variables: skip prop values, fallbacks, and .map()-only sources
+  const variables = extractFrontmatterVariables(frontmatter).filter(name => {
+    const propUsageRegex = new RegExp(`\\w+={${name}}`)
+    if (propUsageRegex.test(template)) return false
+    const fallbackRegex = new RegExp(`(?:\\?\\?|\\|\\|)\\s*${name}\\b`)
+    if (fallbackRegex.test(frontmatter) || fallbackRegex.test(template)) return false
+    // In component mode, .map()-only arrays become repeatedGroup inner fields
+    // and should not also appear as top-level fields.
+    // In page mode, standalone .map() arrays ARE the content → keep them.
+    if (!isPageMode) {
+      const hasMapUsage = new RegExp(`\\b${name}\\.map\\s*\\(`).test(template)
+      const hasNonMapUsage = new RegExp(`\\b${name}\\b(?!\\.map)`).test(template)
+      if (hasMapUsage && !hasNonMapUsage) return false
+    }
+    return true
+  })
+
+  const variableFields = inferFields(variables, template)
+
+  for (const field of variableFields) {
+    if (!field.defaultValue) {
+      field.defaultValue = extractFrontmatterValue(frontmatter, field.key)
+    }
+  }
+
+  // Extract template fields + repeated groups (Phase 1)
+  const { fields: templateFields, repeatedGroups } = await extractTemplateFields(template, frontmatter)
+
+  // Fix positions: extractTemplateFields already subtracts WRAPPER_OFFSET internally,
+  // so positions are relative to the template string. Add templateOffset for full source.
+  const posAdjust = templateOffset
+
+  for (const group of repeatedGroups) {
+    for (const inst of group.instances) {
+      inst.start += posAdjust
+      inst.end += posAdjust
+    }
+    for (const field of group.fields) {
+      for (let i = 0; i < field.positions.length; i++) {
+        const pos = field.positions[i]
+        if (pos) {
+          pos.offset += posAdjust
+        }
+      }
+    }
+  }
+
+  // Adjust classAttrs positions
+  for (const group of repeatedGroups) {
+    if (group.classAttrs) {
+      for (const instAttrs of group.classAttrs) {
+        for (const a of instAttrs) {
+          a.sourceOffset += posAdjust
+        }
+      }
+    }
+  }
+
+  // Phase 2: Enrich labels on repeated group inner fields
+  for (const group of repeatedGroups) {
+    enrichFieldLabels(group.fields)
+  }
+
+  // Assign template positions to variable fields
+  for (const field of variableFields) {
+    const usageRegex = new RegExp(`\\{\\s*(?:\\w+\\.)?${field.key}(?:[.\\s}(])`, 's')
+    const usageMatch = usageRegex.exec(template)
+    if (usageMatch) {
+      ;(field as any)._pos = usageMatch.index
+    } else {
+      const mapUsage = template.indexOf(`${field.key}.map(`)
+      ;(field as any)._pos = mapUsage !== -1 ? mapUsage : Infinity
+    }
+  }
+
+  // Merge all fields and sort by template position
+  const existingKeys = new Set(variableFields.map((f) => f.key))
+  const allFields = [
+    ...variableFields,
+    ...templateFields.filter((f) => !existingKeys.has(f.key)),
+  ]
+  allFields.sort((a, b) => ((a as any)._pos ?? Infinity) - ((b as any)._pos ?? Infinity))
+
+  const fields = allFields.map(({ ...field }) => {
+    delete (field as any)._pos
+    return field
+  })
+
+  const analyzerResult: AnalyzerResult = {
+    sectionKey,
+    componentName,
+    componentPath,
+    alreadyIntegrated,
+    fields,
+    repeatedGroups,
+    frontmatter,
+    template,
+  }
+
+  return {
+    key: sectionKey,
+    componentName,
+    componentPath,
+    fields,
+    alreadyIntegrated,
+    _analyzerResult: analyzerResult,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Frontmatter utilities (unchanged from v1)
+// ---------------------------------------------------------------------------
+
+function splitAstroFile(source: string): { frontmatter: string; template: string; templateOffset: number } {
+  if (!source.startsWith('---')) return { frontmatter: '', template: source, templateOffset: 0 }
+  // Find closing --- marker (starts at beginning of a line after the opening ---)
+  const endIdx = source.indexOf('\n---', 3)
+  if (endIdx === -1) return { frontmatter: '', template: source, templateOffset: 0 }
+  const frontmatter = source.slice(4, endIdx) // after "---\n", before "\n---"
+  let templateStart = endIdx + 4 // skip "\n---"
+  // Skip trailing whitespace/newline on the closing --- line
+  while (templateStart < source.length && source[templateStart] === ' ') templateStart++
+  if (templateStart < source.length && source[templateStart] === '\n') templateStart++
+  return { frontmatter, template: source.slice(templateStart), templateOffset: templateStart }
+}
+
+function extractFrontmatterVariables(frontmatter: string): string[] {
+  const variables: string[] = []
+  const constRegex = /(?:const|let)\s+(\w+)\s*=\s*(.*)/g
+  let match: RegExpExecArray | null
+  while ((match = constRegex.exec(frontmatter)) !== null) {
+    const name = match[1]!
+    const rhs = match[2]?.trim() ?? ''
+    if (isInternalVariable(name)) continue
+    // Skip exported declarations (e.g. "export const prerender = true")
+    const charBefore = match.index > 0 ? frontmatter.slice(Math.max(0, match.index - 10), match.index) : ''
+    if (/export\s*$/.test(charBefore)) continue
+    if (/\.\s*map\s*\(/.test(rhs) || /\w+\?\.\w+/.test(rhs)) continue
+    if (/^\[/.test(rhs) && /^default/i.test(name)) continue
+    // Skip arrow function declarations (internal helpers, not content fields)
+    if (/^\(|^\w+\s*=>/.test(rhs) && /=>/.test(rhs)) continue
+    // Skip setzkasten API calls and other framework calls that return data objects
+    if (/\bget(?:Page|Pages|Section|CollectionEntry)\s*\(/.test(rhs)) continue
+    variables.push(name)
+  }
+  const propsRegex = /const\s+\{\s*([^}]+)\}\s*=\s*Astro\.props/
+  const propsMatch = frontmatter.match(propsRegex)
+  if (propsMatch) {
+    const props = propsMatch[1]!
+      .split(',')
+      .map((p) => p.trim().split(':')[0]!.split('=')[0]!.trim())
+      .filter((p) => p && !isInternalVariable(p))
+    variables.push(...props)
+  }
+  const interfaceRegex = /interface\s+Props\s*\{([^}]+)\}/s
+  const interfaceMatch = frontmatter.match(interfaceRegex)
+  if (interfaceMatch) {
+    const fields = interfaceMatch[1]!
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith('//'))
+      .map((line) => line.match(/^(\w+)\??:/)?.[1])
+      .filter((name): name is string => !!name && !isInternalVariable(name))
+    variables.push(...fields)
+  }
+  return [...new Set(variables)]
+}
+
+function extractFrontmatterValue(frontmatter: string, varName: string): unknown | undefined {
+  const arrayStartRegex = new RegExp(`(?:const|let)\\s+${varName}\\s*=\\s*\\[`)
+  const arrayStartMatch = arrayStartRegex.exec(frontmatter)
+  if (arrayStartMatch) {
+    const startIdx = arrayStartMatch.index + arrayStartMatch[0].length
+    let depth = 1
+    let endIdx = startIdx
+    for (let i = startIdx; i < frontmatter.length && depth > 0; i++) {
+      if (frontmatter[i] === '[') depth++
+      else if (frontmatter[i] === ']') depth--
+      endIdx = i
+    }
+    const content = frontmatter.slice(startIdx, endIdx)
+    const isObjectArray = /\{/.test(content)
+    const isStringArray = /^\s*['"]/.test(content.trim())
+    return extractInlineArrayValues(content, isObjectArray, isStringArray)
+  }
+  const strRegex = new RegExp(`(?:const|let)\\s+${varName}\\s*=\\s*['"]([^'"]+)['"]`)
+  const strMatch = frontmatter.match(strRegex)
+  if (strMatch) return strMatch[1]!
+  const numRegex = new RegExp(`(?:const|let)\\s+${varName}\\s*=\\s*(\\d+(?:\\.\\d+)?)`)
+  const numMatch = frontmatter.match(numRegex)
+  if (numMatch) return Number(numMatch[1]!)
+  return undefined
+}
+
+function isInternalVariable(name: string): boolean {
+  const skip = new Set([
+    'Astro', 'props', 'data', 'class', 'className', 'style', 'id',
+    'slot', 'Fragment', 'Component', 'frontmatter', 'url', 'site',
+    'generator', 'redirect', 'response', 'request', 'cookies',
+    'params', 'slots',
+  ])
+  return skip.has(name) || name.startsWith('_')
+}
+
+// ---------------------------------------------------------------------------
+// Byte → Char offset conversion
+// ---------------------------------------------------------------------------
+
+function buildByteToCharMap(source: string): (byteOffset: number) => number {
+  const buf = Buffer.from(source, 'utf-8')
+  if (buf.length === source.length) return (offset) => offset
+  const map = new Array<number>(buf.length + 1)
+  let byteIdx = 0
+  for (let charIdx = 0; charIdx < source.length; charIdx++) {
+    const codePoint = source.codePointAt(charIdx)!
+    const charByteLen = codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4
+    for (let b = 0; b < charByteLen; b++) map[byteIdx + b] = charIdx
+    byteIdx += charByteLen
+    if (codePoint > 0xffff) charIdx++
+  }
+  map[byteIdx] = source.length
+  return (offset) => offset <= 0 ? 0 : offset >= map.length ? source.length : map[offset]!
+}
+
+function convertAstPositions(node: AstNode, b2c: (offset: number) => number): void {
+  if (node.position?.start) node.position.start.offset = b2c(node.position.start.offset)
+  if (node.position?.end) node.position.end.offset = b2c(node.position.end.offset)
+  if (node.attributes) {
+    for (const attr of node.attributes) {
+      if (attr.position?.start) attr.position.start.offset = b2c(attr.position.start.offset)
+    }
+  }
+  if (node.children) {
+    for (const child of node.children) convertAstPositions(child, b2c)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// AST helper utilities
+// ---------------------------------------------------------------------------
+
+const WRAPPER_OFFSET = 8
+
+function nodeOffset(node: AstNode): number {
+  return (node.position?.start?.offset ?? Infinity) - WRAPPER_OFFSET
+}
+
+function nodeEnd(node: AstNode): number {
+  return (node.position?.end?.offset ?? Infinity) - WRAPPER_OFFSET
+}
+
+function getClassValue(node: AstNode): string {
+  if (!node.attributes) return ''
+  const classAttr = node.attributes.find((a) => a.name === 'class' || a.name === 'className')
+  return classAttr?.value ?? ''
+}
+
+function getAttr(node: AstNode, name: string): AstAttr | undefined {
+  return node.attributes?.find((a) => a.name === name)
+}
+
+function isAriaHidden(node: AstNode): boolean {
+  const attr = getAttr(node, 'aria-hidden')
+  return attr?.value === 'true'
+}
+
+function extractTextContent(node: AstNode, stripCmsBound: boolean = false): string {
+  let text = ''
+  if (node.type === 'text') {
+    text += node.value ?? ''
+  } else if (node.type === 'expression') {
+    const exprCode = (node.children ?? []).map((c) => c.value ?? '').join('')
+    if (stripCmsBound && /^\s*\(?\s*\w+\?\.\s*\w+/.test(exprCode)) return ''
+    const fallbackMatch = exprCode.match(/\?\?\s*['"]([^'"]+)['"]/)
+    if (fallbackMatch) text += fallbackMatch[1]!
+  } else if (node.children) {
+    for (const child of node.children) {
+      text += extractTextContent(child, stripCmsBound)
+    }
+  }
+  return text
+}
+
+/** Tags that indicate inline formatting (bold, italic, links, code, color spans, etc.) */
+const INLINE_FORMATTING_TAGS = new Set([
+  'strong', 'b', 'em', 'i', 'mark', 'code', 'del', 'ins',
+  'sub', 'sup', 'a', 'abbr', 'cite', 'u', 's', 'small',
+  'span', // color/style spans inside text content
+])
+
+/** Check if an element contains inline formatting child elements. */
+function hasInlineFormatting(node: AstNode): boolean {
+  if (!node.children) return false
+  for (const child of node.children) {
+    if (child.type === 'element' && INLINE_FORMATTING_TAGS.has(child.name ?? '')) return true
+    if (hasInlineFormatting(child)) return true
+  }
+  return false
+}
+
+/**
+ * Collect all class="..." attributes from an element subtree.
+ * Returns them with a structural path (child index path) for cross-instance matching.
+ */
+function collectClassAttrs(node: AstNode, path: string = '', source?: string): import('./analyzer-types.js').ClassAttrInfo[] {
+  const result: import('./analyzer-types.js').ClassAttrInfo[] = []
+  if (node.type === 'element' && node.attributes && source) {
+    const classAttr = node.attributes.find(a => a.name === 'class' && a.kind === 'quoted')
+    if (classAttr && classAttr.value) {
+      // The AST position points to the element start, not the attribute.
+      // Find the actual `class="` within the opening tag.
+      const elemStart = nodeOffset(node)
+      const tagEndGuess = source.indexOf('>', elemStart)
+      if (tagEndGuess !== -1) {
+        const classIdx = source.indexOf('class="', elemStart)
+        if (classIdx !== -1 && classIdx < tagEndGuess) {
+          // class="value" → length = 'class="'.length + value.length + '"'.length
+          const sourceLength = 7 + classAttr.value.length + 1
+          result.push({
+            path,
+            value: classAttr.value,
+            sourceOffset: classIdx,
+            sourceLength,
+          })
+        }
+      }
+    }
+  }
+  if (node.children) {
+    // Use tag:nth as path key (more robust than child index for optional elements)
+    const tagCounts: Record<string, number> = {}
+    for (const child of node.children) {
+      if (child.type === 'element' && child.name) {
+        const tag = child.name
+        const nth = tagCounts[tag] ?? 0
+        tagCounts[tag] = nth + 1
+        const childPath = path ? `${path}/${tag}:${nth}` : `${tag}:${nth}`
+        result.push(...collectClassAttrs(child, childPath, source))
+      } else if (child.type === 'expression' && child.children) {
+        // Recurse into expression nodes (e.g. {items.map(() => (<li class="...">))})
+        for (const exprChild of child.children) {
+          if (exprChild.type === 'element' && exprChild.name) {
+            const tag = exprChild.name
+            const nth = tagCounts[tag] ?? 0
+            tagCounts[tag] = nth + 1
+            const childPath = path ? `${path}/${tag}:${nth}` : `${tag}:${nth}`
+            result.push(...collectClassAttrs(exprChild, childPath, source))
+          }
+        }
+      }
+    }
+  }
+  return result
+}
+
+function containsElement(node: AstNode, tagName: string): boolean {
+  if (node.type === 'element' && node.name === tagName) return true
+  if (node.children) {
+    for (const child of node.children) {
+      if (containsElement(child, tagName)) return true
+    }
+  }
+  return false
+}
+
+function serializeNode(node: AstNode): string {
+  if (node.type === 'text') return node.value ?? ''
+  if (node.type === 'expression') {
+    const inner = (node.children ?? []).map((c) => c.value ?? '').join('')
+    return `{${inner}}`
+  }
+  let result = ''
+  if (node.type === 'element' || node.type === 'component') {
+    result += `<${node.name ?? ''}`
+    for (const attr of node.attributes ?? []) {
+      if (attr.kind === 'quoted') result += ` ${attr.name}="${attr.value}"`
+      else if (attr.kind === 'expression') result += ` ${attr.name}={${attr.value}}`
+      else if (attr.kind === 'empty') result += ` ${attr.name}`
+      else result += ` ${attr.name}="${attr.value}"`
+    }
+    result += '>'
+  }
+  for (const child of node.children ?? []) {
+    result += serializeNode(child)
+  }
+  if ((node.type === 'element' || node.type === 'component') && node.name) {
+    result += `</${node.name}>`
+  }
+  return result
+}
+
+function camelToLabel(str: string): string {
+  return str.replace(/([A-Z])/g, ' $1').replace(/^./, (s) => s.toUpperCase()).trim()
+}
+
+function inferInnerFieldType(name: string): InferredField['type'] {
+  const n = name.toLowerCase()
+  if (/icon/.test(n)) return 'icon'
+  if (/image|img|photo|avatar|logo|thumbnail|src/.test(n)) return 'image'
+  if (/color|colour/.test(n)) return 'color'
+  if (/count|amount|number|quantity|total|rating|score|percent|order|index|size|width|height/.test(n)) return 'number'
+  if (/^is[A-Z]/.test(name) || /^has[A-Z]/.test(name) || /enabled|disabled|visible|hidden|active|checked|selected|highlight|accent|featured/.test(n)) return 'boolean'
+  return 'text'
+}
+
+// ---------------------------------------------------------------------------
+// Inline array extraction (unchanged from v1)
+// ---------------------------------------------------------------------------
+
+function extractInlineArrayValues(arrayContent: string, isObjectArray: boolean, isStringArray: boolean): unknown[] {
+  if (isStringArray || !isObjectArray) {
+    const strings: string[] = []
+    const strRegex = /['"]([^'"]+)['"]/g
+    let sm: RegExpExecArray | null
+    while ((sm = strRegex.exec(arrayContent)) !== null) strings.push(sm[1]!)
+    return strings
+  }
+  const objects: Array<Record<string, unknown>> = []
+  let i = 0
+  while (i < arrayContent.length) {
+    if (arrayContent[i] === '{') {
+      const end = findMatchingBracket(arrayContent, i, '{', '}')
+      const objStr = arrayContent.slice(i + 1, end)
+      const obj = parseObjectLiteral(objStr)
+      if (Object.keys(obj).length > 0) objects.push(obj)
+      i = end + 1
+    } else { i++ }
+  }
+  return objects
+}
+
+function findMatchingBracket(source: string, start: number, open: string, close: string): number {
+  let depth = 1
+  let i = start + 1
+  while (i < source.length && depth > 0) {
+    const ch = source[i]!
+    if (ch === "'" || ch === '"') {
+      i++
+      while (i < source.length && source[i] !== ch) i++
+    } else if (ch === open) {
+      depth++
+    } else if (ch === close) {
+      depth--
+    }
+    i++
+  }
+  return i - 1
+}
+
+function parseObjectLiteral(objStr: string): Record<string, unknown> {
+  const obj: Record<string, unknown> = {}
+  let i = 0
+  while (i < objStr.length) {
+    while (i < objStr.length && /[\s,]/.test(objStr[i]!)) i++
+    if (i >= objStr.length) break
+    const keyMatch = objStr.slice(i).match(/^(\w+)\s*:\s*/)
+    if (!keyMatch) { i++; continue }
+    const key = keyMatch[1]!
+    i += keyMatch[0].length
+    const ch = objStr[i]
+    if (ch === "'" || ch === '"') {
+      let j = i + 1
+      while (j < objStr.length && objStr[j] !== ch) j++
+      obj[key] = objStr.slice(i + 1, j)
+      i = j + 1
+    } else if (ch === '[') {
+      const end = findMatchingBracket(objStr, i, '[', ']')
+      const innerContent = objStr.slice(i + 1, end)
+      const hasObjects = /\{/.test(innerContent)
+      if (hasObjects) {
+        obj[key] = extractInlineArrayValues(innerContent, true, false)
+      } else {
+        const items: string[] = []
+        const strRegex = /['"]([^'"]+)['"]/g
+        let sm: RegExpExecArray | null
+        while ((sm = strRegex.exec(innerContent)) !== null) items.push(sm[1]!)
+        obj[key] = items
+      }
+      i = end + 1
+    } else if (ch === '{') {
+      const end = findMatchingBracket(objStr, i, '{', '}')
+      obj[key] = parseObjectLiteral(objStr.slice(i + 1, end))
+      i = end + 1
+    } else if (ch && /\d/.test(ch)) {
+      const numMatch = objStr.slice(i).match(/^(\d+(?:\.\d+)?)/)
+      if (numMatch) { obj[key] = Number(numMatch[1]); i += numMatch[0].length }
+    } else if (objStr.slice(i, i + 4) === 'true') {
+      obj[key] = true; i += 4
+    } else if (objStr.slice(i, i + 5) === 'false') {
+      obj[key] = false; i += 5
+    } else {
+      while (i < objStr.length && objStr[i] !== ',') i++
+    }
+  }
+  return obj
+}
+
+// ---------------------------------------------------------------------------
+// Template content extraction — Steps 0-11 unchanged, Step 12 rewritten
+// ---------------------------------------------------------------------------
+
+interface ExtractResult {
+  fields: InferredField[]
+  repeatedGroups: RepeatedGroup[]
+}
+
+async function extractTemplateFields(template: string, frontmatter: string = ''): Promise<ExtractResult> {
+  const fields: Array<InferredField & { _pos: number }> = []
+  const usedKeys = new Set<string>()
+  const repeatedGroups: RepeatedGroup[] = []
+
+  let ast: AstNode
+  try {
+    const wrappedSource = `---\n---\n${template}`
+    const result = await parse(wrappedSource)
+    ast = result.ast as unknown as AstNode
+    convertAstPositions(ast, buildByteToCharMap(wrappedSource))
+  } catch (err) {
+    console.error('[setzkasten] section-analyzer: parse() failed:', err)
+    return { fields, repeatedGroups }
+  }
+
+  function addField(field: InferredField, pos?: number) {
+    if (!usedKeys.has(field.key)) {
+      usedKeys.add(field.key)
+      let finalPos = pos ?? -1
+      if (finalPos === -1) {
+        if (typeof field.defaultValue === 'string' && field.defaultValue.length >= 3) {
+          finalPos = template.indexOf(field.defaultValue)
+        } else if (Array.isArray(field.defaultValue) && field.defaultValue.length > 0) {
+          const firstItem = typeof field.defaultValue[0] === 'string'
+            ? field.defaultValue[0]
+            : typeof field.defaultValue[0] === 'object' && field.defaultValue[0]
+              ? Object.values(field.defaultValue[0])[0]
+              : null
+          if (typeof firstItem === 'string' && firstItem.length >= 2) {
+            finalPos = template.indexOf(firstItem)
+          }
+        }
+      }
+      if (finalPos === -1) finalPos = template.indexOf(`?.${field.key}`)
+      if (finalPos === -1) {
+        const keyRegex = new RegExp(`(?<![\\w-])${field.key}(?![\\w-])`)
+        const keyMatch = keyRegex.exec(template)
+        if (keyMatch) finalPos = keyMatch.index
+      }
+      fields.push({ ...field, _pos: finalPos === -1 ? Infinity : finalPos })
+    }
+  }
+
+  function numberedKey(base: string, count: number): string {
+    return count === 1 ? base : `${base}${count}`
+  }
+
+  function numberedLabel(base: string, count: number): string {
+    return count === 1 ? base : `${base} ${count}`
+  }
+
+  // Collect aria-hidden ranges
+  const ariaHiddenRanges: Array<{ start: number; end: number }> = []
+  walkAst(ast, (node) => {
+    if (node.type !== 'element' && node.type !== 'component') return
+    const isHidden = isAriaHidden(node) || getAttr(node, 'role')?.value === 'img'
+    if (isHidden) {
+      const start = nodeOffset(node)
+      const end = node.position?.end?.offset ? node.position.end.offset - WRAPPER_OFFSET : start + 1
+      ariaHiddenRanges.push({ start, end })
+    }
+  })
+
+  // Collect .map() expression ranges
+  const mapExpressionRanges: Array<{ start: number; end: number }> = []
+  walkAst(ast, (node) => {
+    if (node.type !== 'expression') return
+    const exprCode = (node.children ?? []).map((c) => c.value ?? '').join('')
+    if (/\.map\s*\(/.test(exprCode)) {
+      const start = nodeOffset(node)
+      const end = node.position?.end?.offset ? node.position.end.offset - WRAPPER_OFFSET : start + 1
+      mapExpressionRanges.push({ start, end })
+    }
+  })
+
+  // Collect repeated sibling element groups
+  const SEMANTIC_REPEATED_TAGS = new Set(['article', 'aside', 'figure', 'details', 'blockquote'])
+  const repeatedElementGroups: Array<{ tag: string; instances: AstNode[] }> = []
+  const repeatedElementRanges: Array<{ start: number; end: number }> = []
+
+  walkAst(ast, (node) => {
+    if (node.type !== 'element' && node.type !== 'fragment') return
+    if (!node.children || node.children.length < 2) return
+    const childrenByTag = new Map<string, AstNode[]>()
+    for (const child of node.children) {
+      if (child.type !== 'element') continue
+      const tag = child.name ?? ''
+      if (!tag) continue
+      if (!childrenByTag.has(tag)) childrenByTag.set(tag, [])
+      childrenByTag.get(tag)!.push(child)
+    }
+    for (const [tag, siblings] of childrenByTag) {
+      if (siblings.length < 2) continue
+      if (!SEMANTIC_REPEATED_TAGS.has(tag)) continue
+      repeatedElementGroups.push({ tag, instances: siblings })
+      for (const inst of siblings) {
+        const start = nodeOffset(inst)
+        const end = inst.position?.end?.offset ? inst.position.end.offset - WRAPPER_OFFSET : start + 1
+        repeatedElementRanges.push({ start, end })
+      }
+    }
+  })
+
+  // Table rows: <tbody><tr> rows → repeatedElementGroup
+  // Detects only tbody rows (not thead) so column headers are excluded.
+  walkAst(ast, (node) => {
+    if (node.type !== 'element' || node.name !== 'tbody') return
+    const trRows = (node.children ?? []).filter(c => c.type === 'element' && c.name === 'tr')
+    if (trRows.length < 2) return
+    repeatedElementGroups.push({ tag: 'tr', instances: trRows })
+    for (const row of trRows) {
+      const start = nodeOffset(row)
+      const end = row.position?.end?.offset ? row.position.end.offset - WRAPPER_OFFSET : start + 1
+      repeatedElementRanges.push({ start, end })
+    }
+  })
+
+  function isInAriaHidden(offset: number): boolean {
+    return ariaHiddenRanges.some((r) => offset >= r.start && offset < r.end)
+  }
+  function isInMapExpression(offset: number): boolean {
+    return mapExpressionRanges.some((r) => offset >= r.start && offset < r.end)
+  }
+  function isInRepeatedElement(offset: number): boolean {
+    return repeatedElementRanges.some((r) => offset >= r.start && offset < r.end)
+  }
+
+  const cmsBoundOffsets = new Set<number>()
+
+  // ── 0. ALREADY-BOUND CMS FIELDS ────────────────────────────────────────
+  walkAst(ast, (node) => {
+    if (node.type !== 'expression') return
+    const exprCode = (node.children ?? []).map((c) => c.value ?? '').join('')
+    const cmsVarMatch = exprCode.match(/^\s*\(?\s*\w+\?\.\s*(\w+)/)
+    if (cmsVarMatch) {
+      const fieldKey = cmsVarMatch[1]!
+      // Array fallback: (skData?.items ?? ['a', 'b']).map(
+      const arrayFallbackMatch = exprCode.match(/\?\?\s*\[([^\]]*)\]\s*\)\.map\(/)
+      if (arrayFallbackMatch) {
+        const items: string[] = []
+        const itemRe = /`([^`]*)`|'([^']*)'|"([^"]*)"/g
+        let m: RegExpExecArray | null
+        while ((m = itemRe.exec(arrayFallbackMatch[1]!)) !== null) {
+          items.push(m[1] ?? m[2] ?? m[3] ?? '')
+        }
+        const hasFormatting = items.some(s => /<[a-z]/.test(s))
+        addField({
+          key: fieldKey, type: 'array', label: camelToLabel(fieldKey), confidence: 'high',
+          defaultValue: items.length > 0 ? items : undefined,
+          options: { arrayItem: { type: 'text', ...(hasFormatting ? { formatting: true } : {}) } },
+        }, nodeOffset(node))
+      } else {
+        // String fallback or no fallback
+        const strFallback = exprCode.match(/\?\?\s*(?:`([\s\S]*?)`|'([^']*)'|"([^"]*)")/)
+        const defaultValue = strFallback ? (strFallback[1] ?? strFallback[2] ?? strFallback[3] ?? '').trim() : undefined
+        const hasHtml = defaultValue ? /<[a-z]/.test(defaultValue) : false
+        addField({
+          key: fieldKey, type: 'text', label: camelToLabel(fieldKey), confidence: 'high',
+          ...(defaultValue ? { defaultValue } : {}),
+          ...(hasHtml ? { options: { formatting: true } } : {}),
+        }, nodeOffset(node))
+      }
+      cmsBoundOffsets.add(nodeOffset(node))
+    }
+  })
+
+  walkAst(ast, (node) => {
+    if (node.type !== 'element' && node.type !== 'component') return
+    for (const attr of node.attributes ?? []) {
+      if (attr.kind !== 'expression') continue
+      const cmsAttrMatch = attr.value.match(/^\s*\w+\?\.\s*(\w+)\s*\?\?\s*(?:`([\s\S]*?)`|'([^']*)'|"([^"]*)")/)
+      if (cmsAttrMatch) {
+        const fieldKey = cmsAttrMatch[1]!
+        const fallback = (cmsAttrMatch[2] ?? cmsAttrMatch[3] ?? cmsAttrMatch[4] ?? '').trim()
+        const pos = attr.position?.start?.offset ? attr.position.start.offset - WRAPPER_OFFSET : nodeOffset(node)
+        // formatting: true when fallback contains HTML tags,
+        // OR when the attribute is set:html without a fallback (content is always HTML then)
+        const isSetHtml = attr.name === 'set:html'
+        const fallbackHasHtml = fallback ? /<[a-z]/.test(fallback) : false
+        const hasHtml = fallbackHasHtml || (isSetHtml && !fallback)
+        addField({
+          key: fieldKey, type: 'text', label: camelToLabel(fieldKey), confidence: 'high',
+          ...(fallback ? { defaultValue: fallback } : {}),
+          ...(hasHtml ? { options: { formatting: true } } : {}),
+        }, pos)
+        cmsBoundOffsets.add(nodeOffset(node))
+      }
+    }
+  })
+
+  function shouldSkipForContent(node: AstNode): boolean {
+    const offset = nodeOffset(node)
+    return isInAriaHidden(offset) || cmsBoundOffsets.has(offset) || isInRepeatedElement(offset)
+  }
+
+  function shouldSkipMapChild(node: AstNode): boolean {
+    return isInMapExpression(nodeOffset(node))
+  }
+
+  // ── 1. OVERLINE / EYEBROW ──────────────────────────────────────────────
+  walkAst(ast, (node) => {
+    if (node.type !== 'element') return
+    if (node.name !== 'p' && node.name !== 'span') return
+    if (shouldSkipForContent(node)) return
+    const classVal = getClassValue(node)
+    if (!/uppercase|tracking-widest/.test(classVal)) return
+    const text = extractTextContent(node, true).trim()
+    if (text.length >= 2 && text.length <= 80) {
+      addField({ key: 'overline', type: 'text', label: 'Overline', confidence: 'medium', defaultValue: text }, nodeOffset(node))
+    }
+  })
+
+  // ── 2. HEADINGS (h1-h6) ───────────────────────────────────────────────
+  // Start from the count of already-registered heading* keys (from Section 0)
+  // so new headings get non-colliding keys (heading3, heading4, ...).
+  let headingCount = Array.from(usedKeys).filter(k => k === 'heading' || /^heading\d+$/.test(k)).length
+  walkAst(ast, (node) => {
+    if (node.type !== 'element') return
+    if (!/^h[1-6]$/.test(node.name ?? '')) return
+    if (shouldSkipForContent(node)) return
+    const text = extractTextContent(node, true).replace(/\s+/g, ' ').trim()
+    if (text.length >= 2) {
+      headingCount++
+      const headingOpts: Record<string, unknown> = { required: true }
+      if (hasInlineFormatting(node)) headingOpts.formatting = true
+      addField({
+        key: numberedKey('heading', headingCount), type: 'text',
+        label: numberedLabel('Heading', headingCount), confidence: 'high',
+        defaultValue: text, options: headingOpts,
+      }, nodeOffset(node))
+    }
+  })
+
+  // ── 3. PARAGRAPHS / DESCRIPTION TEXT ───────────────────────────────────
+  // Start from the count of already-registered description* keys (from Section 0)
+  // so new description fields get non-colliding keys (description2, description3, ...).
+  let descCount = Array.from(usedKeys).filter(k => k === 'description' || /^description\d+$/.test(k)).length
+  walkAst(ast, (node) => {
+    if (node.type !== 'element') return
+    if (node.name !== 'p' && node.name !== 'div') return
+    if (shouldSkipForContent(node)) return
+    const classVal = getClassValue(node)
+    const serialized = serializeNode(node)
+    if (/uppercase|tracking-widest/.test(classVal) && serialized.length < 250) return
+    if (/text-2xl|text-3xl|text-\[11px\]|text-\[10px\]|text-\[9px\]|text-\[8px\]/.test(classVal)) return
+    if (node.name === 'div' && (containsElement(node, 'a') || containsElement(node, 'button'))) {
+      // Allow mixed-text divs (callouts with inline links) — skip only pure-element
+      // containers like nav/card wrappers that have no direct text nodes.
+      const hasMixedText = (node.children ?? []).some(
+        c => c.type === 'text' && (c.value ?? '').trim().length > 0,
+      )
+      if (!hasMixedText) return
+    }
+    if (node.name === 'div' && ['h1','h2','h3','h4','h5','h6'].some(h => containsElement(node, h))) return
+    if (node.name === 'div') {
+      const contentChildren = (node.children ?? []).filter(c => c.type !== 'text' || (c.value ?? '').trim().length > 0)
+      const hasOnlyElementChildren = contentChildren.length > 0 && contentChildren.every(c => c.type === 'element' || c.type === 'component')
+      if (hasOnlyElementChildren) return
+    }
+    const text = extractTextContent(node, true).replace(/\s+/g, ' ').trim()
+    if (text.length < 15) return
+    descCount++
+    const descOpts: Record<string, unknown> = { multiline: true }
+    if (hasInlineFormatting(node)) descOpts.formatting = true
+    addField({
+      key: numberedKey('description', descCount), type: 'text',
+      label: numberedLabel('Beschreibung', descCount), confidence: 'medium',
+      defaultValue: text, options: descOpts,
+    }, nodeOffset(node))
+  })
+
+  // ── 4. RICH TEXT (set:html) ────────────────────────────────────────────
+  let richCount = 0
+  walkAst(ast, (node) => {
+    if (node.type !== 'element' && node.type !== 'component') return
+    const setHtmlAttr = node.attributes?.find((a) => a.name === 'set:html')
+    if (!setHtmlAttr || setHtmlAttr.kind !== 'expression') return
+    const expr = setHtmlAttr.value.trim()
+    if (/^\w+\?\.\w+/.test(expr)) return
+    if (expr.startsWith("'") || expr.startsWith('"') || expr.includes('??')) {
+      richCount++
+      const strMatch = expr.match(/['"]([^'"]+)['"]/)
+      const fallbackMatch = expr.match(/\?\?\s*['"]([^'"]+)['"]/)
+      const value = fallbackMatch?.[1] ?? strMatch?.[1] ?? ''
+      addField({
+        key: numberedKey('richText', richCount), type: 'text',
+        label: numberedLabel('Rich Text', richCount), confidence: 'high',
+        defaultValue: value, options: { multiline: true, formatting: true },
+      }, nodeOffset(node))
+    }
+  })
+
+  // ── 5. BUTTONS & CTA TEXT ──────────────────────────────────────────────
+  let ctaCount = 0
+  walkAst(ast, (node) => {
+    if (node.type !== 'element') return
+    if (node.name !== 'a' && node.name !== 'button') return
+    if (shouldSkipForContent(node)) return
+    const classVal = getClassValue(node)
+    if (!/rounded|px-|py-|font-semibold|bg-/.test(classVal)) return
+    const text = extractTextContent(node, true).replace(/\s+/g, ' ').trim()
+    if (text.length >= 2 && text.length <= 60) {
+      ctaCount++
+      addField({
+        key: numberedKey('ctaText', ctaCount), type: 'text',
+        label: numberedLabel('Button Text', ctaCount), confidence: 'medium',
+        defaultValue: text,
+      }, nodeOffset(node))
+    }
+  })
+
+  // ── 6. CTA LINKS (href values) ─────────────────────────────────────────
+  let linkCount = 0
+  walkAst(ast, (node) => {
+    if (node.type !== 'element' || node.name !== 'a') return
+    if (shouldSkipForContent(node)) return
+    const classVal = getClassValue(node)
+    if (!/rounded|px-|py-|font-semibold|bg-/.test(classVal)) return
+    const hrefAttr = getAttr(node, 'href')
+    if (!hrefAttr) return
+    let href: string | undefined
+    if (hrefAttr.kind === 'quoted') {
+      href = hrefAttr.value
+    } else if (hrefAttr.kind === 'expression') {
+      if (/^\s*\w+\?\.\w+/.test(hrefAttr.value)) return
+      const fallback = hrefAttr.value.match(/\?\?\s*['"]([^'"]+)['"]/)
+      if (fallback) href = fallback[1]
+    }
+    if (!href) return
+    if (href.startsWith('#') || href.startsWith('javascript:')) return
+    linkCount++
+    addField({
+      key: numberedKey('ctaLink', linkCount), type: 'text',
+      label: numberedLabel('Button Link', linkCount), confidence: 'medium',
+      defaultValue: href,
+    }, nodeOffset(node))
+  })
+
+  // ── 7. IMAGES ──────────────────────────────────────────────────────────
+  let imgCount = 0
+  let altCount = 0
+  walkAst(ast, (node) => {
+    if (node.type !== 'element' && node.type !== 'component') return
+    const tagName = node.name ?? ''
+    if (tagName !== 'img' && tagName !== 'Image' && tagName !== 'picture') return
+    if (shouldSkipForContent(node)) return
+    const srcAttr = getAttr(node, 'src')
+    if (srcAttr) {
+      let src: string | undefined
+      if (srcAttr.kind === 'quoted') src = srcAttr.value
+      else if (srcAttr.kind === 'expression') {
+        const strMatch = srcAttr.value.match(/['"]([^'"]+)['"]/)
+        if (strMatch) src = strMatch[1]
+      }
+      if (src) {
+        imgCount++
+        addField({
+          key: numberedKey('image', imgCount), type: 'image',
+          label: numberedLabel('Bild', imgCount), confidence: 'high',
+          defaultValue: { path: src.trim(), alt: '' },
+        }, nodeOffset(node))
+      }
+    }
+    if (tagName === 'img' || tagName === 'Image') {
+      const altAttr = getAttr(node, 'alt')
+      if (altAttr && altAttr.kind === 'quoted' && altAttr.value.trim().length >= 2) {
+        altCount++
+        addField({
+          key: numberedKey('imageAlt', altCount), type: 'text',
+          label: numberedLabel('Bild Alt-Text', altCount), confidence: 'medium',
+          defaultValue: altAttr.value.trim(),
+        }, nodeOffset(node))
+      }
+    }
+  })
+
+  // ── 8. ICONS ───────────────────────────────────────────────────────────
+  let iconCount = 0
+  walkAst(ast, (node, parentNode) => {
+    if (node.type !== 'element' || node.name !== 'svg') return
+    if (shouldSkipForContent(node) || shouldSkipMapChild(node)) return
+    const svgSource = serializeNode(node)
+    if (svgSource.length < 100) return
+    if (parentNode && (parentNode.name === 'a' || parentNode.name === 'button')) return
+    iconCount++
+    addField({
+      key: numberedKey('icon', iconCount), type: 'icon',
+      label: numberedLabel('Icon', iconCount), confidence: 'low',
+    }, nodeOffset(node))
+  })
+  let foundIconProp = false
+  walkAst(ast, (node) => {
+    if (foundIconProp) return
+    if (node.type !== 'component') return
+    if (shouldSkipMapChild(node)) return
+    const iconAttr = getAttr(node, 'icon')
+    if (iconAttr) {
+      addField({ key: 'icon', type: 'icon', label: 'Icon', confidence: 'high' }, nodeOffset(node))
+      foundIconProp = true
+    }
+  })
+
+  // ── 9. INLINE ARRAYS: {[...].map()} ───────────────────────────────────
+  let arrayCount = 0
+  walkAst(ast, (node) => {
+    if (node.type !== 'expression') return
+    const exprCode = (node.children ?? []).map((c) => c.value ?? '').join('')
+    const inlineArrayMatch = exprCode.match(/^\s*\[([\s\S]*?)\]\s*\.map\s*\(\s*\(?\s*(\{[^}]*\}|\w+)/)
+    if (!inlineArrayMatch) return
+    arrayCount++
+    const arrayContent = inlineArrayMatch[1]!
+    const callbackParam = inlineArrayMatch[2]!
+    let objectKeys: string[] = []
+    if (callbackParam.startsWith('{')) {
+      objectKeys = callbackParam.replace(/[{}]/g, '').split(',')
+        .map((p: string) => p.trim().split(':')[0]!.trim())
+        .filter((p: string) => p && !p.startsWith('...'))
+    } else {
+      const firstObjMatch = arrayContent.match(/\{\s*([\s\S]*?)\}/)
+      if (firstObjMatch) {
+        const keyRegex = /(\w+)\s*:/g
+        let km: RegExpExecArray | null
+        while ((km = keyRegex.exec(firstObjMatch[1]!)) !== null) objectKeys.push(km[1]!)
+      }
+      if (objectKeys.length === 0) {
+        const accessRegex = new RegExp(`${callbackParam}\\.(\\w+)`, 'g')
+        let am: RegExpExecArray | null
+        const accessedProps = new Set<string>()
+        while ((am = accessRegex.exec(exprCode)) !== null) accessedProps.add(am[1]!)
+        objectKeys = [...accessedProps]
+      }
+    }
+    const isObjectArray = objectKeys.length > 0
+    const isStringArray = /^\s*'[^']*'\s*,/.test(arrayContent) || /^\s*"[^"]*"\s*,/.test(arrayContent)
+    const arrayDefaultValue = extractInlineArrayValues(arrayContent, isObjectArray, isStringArray)
+    if (isObjectArray && !isStringArray) {
+      const innerFields: InferredField[] = objectKeys.map((prop: string) => ({
+        key: prop, type: inferInnerFieldType(prop), label: camelToLabel(prop), confidence: 'medium' as const,
+      }))
+      addField({
+        key: numberedKey('items', arrayCount), type: 'array',
+        label: numberedLabel('Liste', arrayCount), confidence: 'high',
+        defaultValue: arrayDefaultValue,
+        options: { arrayItem: { type: 'object', fields: innerFields } },
+      }, nodeOffset(node))
+    } else {
+      addField({
+        key: numberedKey('items', arrayCount), type: 'array',
+        label: numberedLabel('Liste', arrayCount), confidence: 'high',
+        defaultValue: arrayDefaultValue,
+        options: { arrayItem: { type: 'text' } },
+      }, nodeOffset(node))
+    }
+  })
+
+  // ── 9b. STATIC LISTS (<ul>/<ol> with no .map()) → ARRAY ─────────────────
+  // Only processes simple flat lists (no nested <ul>/<ol> inside <li> items).
+  // Complex nested structures (like phase lists with sub-lists) are handled
+  // by section 12 (repeated groups) via walkContentNodes.
+  let staticListCount = 0
+  walkAst(ast, (node) => {
+    if (node.type !== 'element') return
+    if (node.name !== 'ul' && node.name !== 'ol') return
+    if (shouldSkipForContent(node)) return
+    if (shouldSkipMapChild(node)) return
+    // Skip if any .map() expression exists inside (already dynamic)
+    let hasMap = false
+    walkAst(node, (n) => {
+      if (hasMap) return
+      if (n.type === 'expression') {
+        const code = (n.children ?? []).map(c => c.value ?? '').join('')
+        if (/\.map\s*\(/.test(code)) hasMap = true
+      }
+    })
+    if (hasMap) return
+    // Skip complex lists: <li> items that themselves contain nested <ul>/<ol>
+    let hasNestedList = false
+    for (const li of node.children ?? []) {
+      if (li.type !== 'element' || li.name !== 'li') continue
+      for (const child of li.children ?? []) {
+        if (child.type === 'element' && (child.name === 'ul' || child.name === 'ol')) {
+          hasNestedList = true
+          break
+        }
+      }
+      if (hasNestedList) break
+    }
+    if (hasNestedList) return
+    // Collect <li> items — detect formatting elements (<strong>, <em>, etc.)
+    // If present, store innerHTML of the content span so the MiniRTE can handle it.
+    const FORMATTING_TAGS = new Set(['strong', 'em', 'b', 'i', 'code', 'a', 's', 'u'])
+    let listHasFormatting = false
+    const listItems: string[] = []
+    for (const li of node.children ?? []) {
+      if (li.type !== 'element' || li.name !== 'li') continue
+      // Check for formatting elements inside this <li>
+      let liHasFormatting = false
+      walkAst(li, (n) => {
+        if (liHasFormatting) return
+        if (n.type === 'element' && FORMATTING_TAGS.has(n.name ?? '')) liHasFormatting = true
+      })
+      if (liHasFormatting) {
+        listHasFormatting = true
+        // Extract innerHTML of the content span via <li> source + regex.
+        // Child span positions from @astrojs/compiler point after the opening tag,
+        // so we slice the full <li> source and use regex to find the content span.
+        let contentHTML: string | null = null
+        const liSrcStart = li.position?.start?.offset
+        const liSrcEnd = li.position?.end?.offset
+        if (liSrcStart != null && liSrcEnd != null) {
+          const liSrc = template.slice(liSrcStart, liSrcEnd)
+          const spanRegex = /<span[^>]*>([\s\S]*?)<\/span>/g
+          let spanMatch: RegExpExecArray | null
+          while ((spanMatch = spanRegex.exec(liSrc)) !== null) {
+            const inner = spanMatch[1]!
+            if (!inner.trim()) continue // empty bullet-dot span — skip
+            contentHTML = inner.replace(/\s+/g, ' ').trim()
+            break
+          }
+        }
+        listItems.push(contentHTML ?? extractTextContent(li, true).replace(/\s+/g, ' ').trim())
+      } else {
+        const t = extractTextContent(li, true).replace(/\s+/g, ' ').trim()
+        if (t.length >= 1) listItems.push(t)
+      }
+    }
+    if (listItems.length < 1) return
+    staticListCount++
+    addField({
+      key: numberedKey('items', arrayCount + staticListCount), type: 'array',
+      label: numberedLabel('Liste', arrayCount + staticListCount), confidence: 'high',
+      defaultValue: listItems,
+      options: { arrayItem: { type: 'text', ...(listHasFormatting ? { formatting: true } : {}) } },
+    }, nodeOffset(node))
+  })
+
+  // ── 10. COMPONENT PROPS (content-bearing) ─────────────────────────────
+  const componentCounts = new Map<string, number>()
+  walkAst(ast, (node) => {
+    if (node.type !== 'component' || shouldSkipMapChild(node)) return
+    componentCounts.set(node.name ?? '', (componentCounts.get(node.name ?? '') ?? 0) + 1)
+  })
+
+  walkAst(ast, (node) => {
+    if (node.type !== 'component') return
+    if (shouldSkipMapChild(node)) return
+    if ((componentCounts.get(node.name ?? '') ?? 0) >= 2) return
+    for (const attr of node.attributes ?? []) {
+      if (attr.kind === 'quoted') {
+        const propName = attr.name
+        const propValue = attr.value
+        if (/^(class|className|id|style|type|role|width|height|viewBox|fill|stroke|xmlns|d|cx|cy|r|rx|ry|x|y|x1|y1|x2|y2)$/.test(propName)) continue
+        if (/^(lang|language|filename|file|format|variant|size|loading|decoding|transition|client:.*)$/.test(propName)) continue
+        if (/^(aria-|data-)/.test(propName)) continue
+        if (propValue.length < 2) continue
+        if (propValue === 'true' || propValue === 'false' || /^\d+$/.test(propValue)) continue
+        if (propValue.includes('/') && !propValue.includes(' ')) continue
+        addField({
+          key: propName,
+          type: propName === 'icon' ? 'icon' : propName === 'src' ? 'image' : 'text',
+          label: camelToLabel(propName), confidence: 'medium', defaultValue: propValue,
+        }, nodeOffset(node))
+      } else if (attr.kind === 'expression') {
+        const propName = attr.name
+        if (/^(class|className|id|style|type|role|lang|language|filename|file|format|variant|size|loading|decoding)$/.test(propName)) continue
+        if (/^\s*\w+\s*$/.test(attr.value)) continue
+        const fallbackMatch = attr.value.match(/\?\?\s*['"]([^'"]+)['"]/)
+        if (fallbackMatch) {
+          addField({
+            key: propName,
+            type: propName === 'icon' ? 'icon' : propName === 'src' ? 'image' : 'text',
+            label: camelToLabel(propName), confidence: 'medium', defaultValue: fallbackMatch[1]!,
+          }, nodeOffset(node))
+        }
+      }
+    }
+  })
+
+  // ── 11. REPEATED COMPONENTS → ARRAY ───────────────────────────────────
+  const componentInstances = new Map<string, AstNode[]>()
+  walkAst(ast, (node) => {
+    if (node.type !== 'component') return
+    if (shouldSkipMapChild(node)) return
+    const name = node.name ?? ''
+    if (!name) return
+    if (!componentInstances.has(name)) componentInstances.set(name, [])
+    componentInstances.get(name)!.push(node)
+  })
+
+  for (const [compName, instances] of componentInstances) {
+    if (instances.length < 2) continue
+    const allProps = new Set<string>()
+    const instanceValues: Array<Record<string, unknown>> = []
+    for (const inst of instances) {
+      const item: Record<string, unknown> = {}
+      for (const attr of inst.attributes ?? []) {
+        const name = attr.name
+        if (/^(class|className|id|style|type|role)$/.test(name)) continue
+        if (/^(aria-|data-)/.test(name)) continue
+        if (attr.kind === 'quoted') {
+          allProps.add(name); item[name] = attr.value
+        } else if (attr.kind === 'expression') {
+          allProps.add(name)
+          const expr = attr.value.trim()
+          if (expr === 'true') item[name] = true
+          else if (expr === 'false') item[name] = false
+          else if (/^\w+$/.test(expr) && frontmatter) {
+            const extractedValue = extractFrontmatterValue(frontmatter, expr)
+            if (extractedValue !== undefined) item[name] = extractedValue
+          }
+        }
+      }
+      if (Object.keys(item).length > 0) instanceValues.push(item)
+    }
+    if (allProps.size > 0) {
+      const cardKey = compName.replace(/([A-Z])/g, (_m: string, c: string, i: number) => i === 0 ? c.toLowerCase() : '_' + c.toLowerCase()).replace(/_/g, '') + 's'
+      if (!usedKeys.has(cardKey)) {
+        const innerFields: InferredField[] = [...allProps].map((p) => {
+          const isArray = instanceValues.some(iv => Array.isArray(iv[p]))
+          if (isArray) {
+            return { key: p, type: 'array' as const, label: camelToLabel(p), confidence: 'medium' as const, options: { arrayItem: { type: 'text' as const } } }
+          }
+          return { key: p, type: inferInnerFieldType(p), label: camelToLabel(p), confidence: 'medium' as const }
+        })
+        addField({
+          key: cardKey, type: 'array', label: `${compName} Liste`, confidence: 'medium',
+          defaultValue: instanceValues.length > 0 ? instanceValues : undefined,
+          options: { arrayItem: { type: 'object', fields: innerFields } },
+        }, nodeOffset(instances[0]!))
+      }
+    }
+  }
+
+  // ── 12. REPEATED HTML ELEMENTS → ARRAY (v2: position-based) ───────────
+  // Phase 1: Pure structural detection — no CSS heuristics.
+  // Produces RepeatedGroup objects with position info for the patcher.
+  for (const group of repeatedElementGroups) {
+    const instanceCount = group.instances.length
+
+    // Build instance bounds
+    const instanceBounds: RepeatedGroupInstance[] = group.instances.map(inst => ({
+      start: nodeOffset(inst),
+      end: nodeEnd(inst),
+    }))
+
+    // Phase 1a: Extract structural fingerprint from each instance
+    const instanceFingerprints: Array<ContentItem[]> = []
+
+    for (const inst of group.instances) {
+      const items: ContentItem[] = []
+      walkContentNodes(inst, 0, items, frontmatter)
+      instanceFingerprints.push(items)
+    }
+
+    if (instanceFingerprints.length === 0) continue
+
+    // Phase 1b: Use MAJORITY structure as canonical (most common tag sequence)
+    // This avoids using an instance with optional elements as the template.
+    const signatures = instanceFingerprints.map(fp => fp.map(i => i.tag).join(','))
+    const sigCounts = new Map<string, number>()
+    for (const sig of signatures) sigCounts.set(sig, (sigCounts.get(sig) ?? 0) + 1)
+    const mostCommonSig = [...sigCounts.entries()].sort((a, b) => b[1] - a[1])[0]![0]
+    const canonicalIdx = signatures.indexOf(mostCommonSig)
+    const canonical = instanceFingerprints[canonicalIdx]!
+
+    // Track which items in each instance have been consumed (prevents double-matching)
+    const consumedPerInstance: Array<Set<number>> = instanceFingerprints.map(() => new Set())
+
+    // For each canonical item, check if it exists in all other instances
+    const innerFields: InnerFieldInfo[] = []
+    const typeCounts: Record<string, number> = {}
+
+    for (let ci = 0; ci < canonical.length; ci++) {
+      const cItem = canonical[ci]!
+      const tag = cItem.tag
+      const isHeading = /^h[1-6]$/.test(tag)
+      const isLink = tag === 'a'
+      const isArray = tag === '__array__'
+
+      // Determine field type and key
+      let fieldType: 'text' | 'array' | 'link'
+      let keyBase: string
+
+      if (isHeading) {
+        fieldType = 'text'
+        keyBase = 'heading'
+      } else if (isLink) {
+        fieldType = 'link'
+        keyBase = 'link'
+      } else if (isArray) {
+        fieldType = 'array'
+        keyBase = 'list'
+      } else {
+        fieldType = 'text'
+        keyBase = 'text'
+      }
+
+      typeCounts[keyBase] = (typeCounts[keyBase] ?? 0) + 1
+      const key = typeCounts[keyBase] === 1 ? keyBase : `${keyBase}${typeCounts[keyBase]}`
+
+      // Find matching item in each instance (track consumed items per instance)
+      const positions: Array<FieldPosition | null> = []
+      const defaultValues: unknown[] = []
+      let presentCount = 0
+
+      for (let ii = 0; ii < instanceCount; ii++) {
+        const fp = instanceFingerprints[ii]!
+        const consumed = consumedPerInstance[ii]!
+        const match = findMatchingItem(fp, cItem, ci, canonical, consumed)
+        if (match) {
+          presentCount++
+          positions.push({
+            offset: nodeOffset(match.node),
+            length: nodeEnd(match.node) - nodeOffset(match.node),
+            source: match.exprSource,
+          })
+          if (isArray && match.exprSource) {
+            defaultValues.push(extractFrontmatterValue(frontmatter, match.exprSource) ?? [])
+          } else if (isLink) {
+            // For link fields, use the href value (text is extracted separately as linkText)
+            defaultValues.push(match.hrefValue || null)
+          } else {
+            defaultValues.push(match.text || match.hrefValue || null)
+          }
+        } else {
+          positions.push(null)
+          defaultValues.push(null)
+        }
+      }
+
+      innerFields.push({
+        key,
+        type: fieldType,
+        tag,
+        required: presentCount === instanceCount,
+        positions,
+        defaultValues,
+      })
+
+      // For links, also extract link text as a separate field
+      if (isLink) {
+        typeCounts['linkText'] = (typeCounts['linkText'] ?? 0) + 1
+        const ltKey = typeCounts['linkText'] === 1 ? 'linkText' : `linkText${typeCounts['linkText']}`
+        const ltPositions: Array<FieldPosition | null> = []
+        const ltDefaults: unknown[] = []
+
+        for (let ii = 0; ii < instanceCount; ii++) {
+          // Reuse the same match (link node) — text is a sub-field, not a separate consumed item
+          const fp = instanceFingerprints[ii]!
+          const consumed = consumedPerInstance[ii]!
+          // Don't consume again — find same link node via tag+position
+          const match = findMatchingItemPeek(fp, cItem, ci, canonical, consumed)
+          if (match) {
+            ltPositions.push({
+              offset: nodeOffset(match.node),
+              length: nodeEnd(match.node) - nodeOffset(match.node),
+            })
+            ltDefaults.push(match.text || null)
+          } else {
+            ltPositions.push(null)
+            ltDefaults.push(null)
+          }
+        }
+
+        innerFields.push({
+          key: ltKey,
+          type: 'text',
+          tag: 'a',
+          required: presentCount === instanceCount,
+          positions: ltPositions,
+          defaultValues: ltDefaults,
+        })
+      }
+    }
+
+    // Phase 1c: Detect optional elements from longer instances
+    // Items in non-canonical instances that weren't consumed are optional fields.
+    for (let ii = 0; ii < instanceCount; ii++) {
+      if (ii === canonicalIdx) continue
+      const fp = instanceFingerprints[ii]!
+      const consumed = consumedPerInstance[ii]!
+      for (let fi = 0; fi < fp.length; fi++) {
+        if (consumed.has(fi)) continue
+        const item = fp[fi]!
+        // This is an optional element only present in this instance
+        const tag = item.tag
+        const isArray = tag === '__array__'
+        const isLink = tag === 'a'
+        let fieldType: 'text' | 'array' | 'link' = isArray ? 'array' : isLink ? 'link' : 'text'
+        let keyBase = /^h[1-6]$/.test(tag) ? 'heading' : isLink ? 'link' : isArray ? 'list' : 'text'
+        typeCounts[keyBase] = (typeCounts[keyBase] ?? 0) + 1
+        const key = typeCounts[keyBase] === 1 ? keyBase : `${keyBase}${typeCounts[keyBase]}`
+
+        const positions: Array<FieldPosition | null> = new Array(instanceCount).fill(null)
+        const defaultValues: unknown[] = new Array(instanceCount).fill(null)
+        positions[ii] = {
+          offset: nodeOffset(item.node),
+          length: nodeEnd(item.node) - nodeOffset(item.node),
+          source: item.exprSource,
+        }
+        if (isArray && item.exprSource) {
+          defaultValues[ii] = extractFrontmatterValue(frontmatter, item.exprSource) ?? []
+        } else {
+          defaultValues[ii] = item.text || item.hrefValue || null
+        }
+
+        innerFields.push({ key, type: fieldType, tag, required: false, positions, defaultValues })
+
+        if (isLink) {
+          typeCounts['linkText'] = (typeCounts['linkText'] ?? 0) + 1
+          const ltKey = typeCounts['linkText'] === 1 ? 'linkText' : `linkText${typeCounts['linkText']}`
+          const ltPositions: Array<FieldPosition | null> = new Array(instanceCount).fill(null)
+          const ltDefaults: unknown[] = new Array(instanceCount).fill(null)
+          ltPositions[ii] = positions[ii] ?? null
+          ltDefaults[ii] = item.text || null
+          innerFields.push({ key: ltKey, type: 'text', tag: 'a', required: false, positions: ltPositions, defaultValues: ltDefaults })
+        }
+      }
+    }
+
+    if (innerFields.length === 0) continue
+
+    arrayCount++
+    let fieldKey = numberedKey('items', arrayCount)
+    while (usedKeys.has(fieldKey)) {
+      arrayCount++
+      fieldKey = numberedKey('items', arrayCount)
+    }
+
+    // Build defaultValue array for backwards compatibility
+    const defaultValue: Array<Record<string, unknown>> = []
+    for (let ii = 0; ii < instanceCount; ii++) {
+      const item: Record<string, unknown> = {}
+      for (const f of innerFields) {
+        if (f.defaultValues[ii] != null) {
+          item[f.key] = f.defaultValues[ii]
+        }
+      }
+      defaultValue.push(item)
+    }
+
+    // Build inner field definitions for the field schema
+    const innerFieldDefs: InferredField[] = innerFields.map(f => {
+      if (f.type === 'array') {
+        return {
+          key: f.key,
+          type: 'array' as const,
+          label: f.label ?? camelToLabel(f.key),
+          confidence: 'medium' as const,
+          options: { arrayItem: { type: 'text' as const } },
+        }
+      }
+      return {
+        key: f.key,
+        type: f.type === 'link' ? 'text' as const : 'text' as const,
+        label: f.label ?? camelToLabel(f.key),
+        confidence: 'medium' as const,
+      }
+    })
+
+    // Add as top-level field
+    const groupLabel = group.tag === 'tr'
+      ? 'Tabellen-Zeilen'
+      : `${group.tag.charAt(0).toUpperCase() + group.tag.slice(1)} Liste`
+    addField({
+      key: fieldKey,
+      type: 'array',
+      label: groupLabel,
+      confidence: 'high',
+      defaultValue,
+      options: {
+        arrayItem: { type: 'object', fields: innerFieldDefs },
+        _repeatedTag: group.tag,
+        _instanceCount: instanceCount,
+      } as any,
+    }, instanceBounds[0]!.start)
+
+    // Collect class attributes per instance (AST-based, for dynamic class detection in patcher)
+    // Positions are relative to `template` here; posAdjust is applied after extractTemplateFields returns
+    const classAttrs = group.instances.map(inst => collectClassAttrs(inst, '', template))
+
+    // Store RepeatedGroup for the patcher
+    repeatedGroups.push({
+      tag: group.tag,
+      fieldKey,
+      instances: instanceBounds,
+      templateIndex: 0,
+      fields: innerFields,
+      classAttrs,
+    })
+  }
+
+  fields.sort((a, b) => a._pos - b._pos)
+  return { fields: fields.map(({ _pos, ...field }) => field), repeatedGroups }
+}
+
+// ---------------------------------------------------------------------------
+// Phase 1: Structural content node walker (no CSS heuristics)
+// ---------------------------------------------------------------------------
+
+interface ContentItem {
+  tag: string        // h2, p, span, a, __array__
+  depth: number
+  node: AstNode
+  text: string
+  exprSource?: string
+  hrefValue?: string
+}
+
+/**
+ * Walk an element's subtree and collect content nodes structurally.
+ * No CSS class checking — purely based on HTML tags and position.
+ */
+function walkContentNodes(
+  root: AstNode,
+  depth: number,
+  items: ContentItem[],
+  frontmatter: string,
+): void {
+  for (const child of root.children ?? []) {
+    if (child.type === 'element' && isAriaHidden(child)) continue
+
+    // Heading
+    if (child.type === 'element' && /^h[1-6]$/.test(child.name ?? '')) {
+      const text = extractTextContent(child, true).replace(/\s+/g, ' ').trim()
+      if (text.length >= 1) {
+        items.push({ tag: child.name!, depth, node: child, text })
+      }
+      continue // don't recurse into headings
+    }
+
+    // Paragraph with meaningful text
+    if (child.type === 'element' && child.name === 'p') {
+      const text = extractTextContent(child, true).replace(/\s+/g, ' ').trim()
+      if (text.length >= 1) {
+        items.push({ tag: 'p', depth, node: child, text })
+      }
+      continue
+    }
+
+    // Standalone span with text (not inside a deeper context we already handle)
+    if (child.type === 'element' && child.name === 'span') {
+      const text = extractTextContent(child, true).replace(/\s+/g, ' ').trim()
+      if (text.length >= 1) {
+        items.push({ tag: 'span', depth, node: child, text })
+      }
+      continue
+    }
+
+    // Link
+    if (child.type === 'element' && child.name === 'a') {
+      const text = extractTextContent(child, true).replace(/\s+/g, ' ').trim()
+      const href = getAttr(child, 'href')
+      let hrefValue: string | undefined
+      if (href?.kind === 'quoted') hrefValue = href.value
+      else if (href?.kind === 'expression') {
+        const fb = href.value.match(/['"]([^'"]+)['"]/)
+        if (fb) hrefValue = fb[1]
+      }
+      if (text.length >= 1 || hrefValue) {
+        items.push({ tag: 'a', depth, node: child, text, hrefValue })
+      }
+      continue
+    }
+
+    // Table cell (inside a <tr> repeatedGroup instance)
+    if (child.type === 'element' && child.name === 'td') {
+      const text = extractTextContent(child, true).replace(/\s+/g, ' ').trim()
+      if (text.length >= 1) {
+        items.push({ tag: 'td', depth, node: child, text })
+      }
+      continue
+    }
+
+    // List with .map() expression or static items
+    if (child.type === 'element' && (child.name === 'ul' || child.name === 'ol')) {
+      // Check for .map() expression inside
+      let mapSource: string | undefined
+      walkAst(child, (expr) => {
+        if (mapSource) return
+        if (expr.type !== 'expression') return
+        const code = (expr.children ?? []).map(c => c.value ?? '').join('')
+        const mapMatch = code.match(/(\w+)\.map\s*\(/)
+        if (mapMatch) mapSource = mapMatch[1]
+      })
+      if (mapSource) {
+        items.push({ tag: '__array__', depth, node: child, text: '', exprSource: mapSource })
+      } else {
+        // Static list items
+        const listTexts: string[] = []
+        for (const li of child.children ?? []) {
+          if (li.type === 'element' && li.name === 'li') {
+            const t = extractTextContent(li, true).trim()
+            if (t.length >= 1) listTexts.push(t)
+          }
+        }
+        if (listTexts.length > 0) {
+          items.push({ tag: '__array__', depth, node: child, text: listTexts.join('\n') })
+        }
+      }
+      continue
+    }
+
+    // Recurse into div/section/other container elements
+    if (child.type === 'element') {
+      walkContentNodes(child, depth + 1, items, frontmatter)
+    }
+  }
+}
+
+/**
+ * Find a matching content item in another instance's fingerprint.
+ * Uses tag + relative position among same-tag items.
+ */
+/**
+ * Find a matching content item, marking it as consumed so it won't be reused.
+ */
+function findMatchingItem(
+  targetFp: ContentItem[],
+  canonicalItem: ContentItem,
+  canonicalIndex: number,
+  allCanonical: ContentItem[],
+  consumed: Set<number>,
+): ContentItem | null {
+  const result = findMatchingItemCore(targetFp, canonicalItem, canonicalIndex, allCanonical, consumed)
+  if (result) consumed.add(result.idx)
+  return result?.item ?? null
+}
+
+/**
+ * Find a matching content item WITHOUT consuming it (for sub-fields like link text).
+ */
+function findMatchingItemPeek(
+  targetFp: ContentItem[],
+  canonicalItem: ContentItem,
+  canonicalIndex: number,
+  allCanonical: ContentItem[],
+  consumed: Set<number>,
+): ContentItem | null {
+  // For peek, we look for the already-consumed link node (it was consumed by the link field)
+  // So we search WITHOUT the consumed filter
+  const tag = canonicalItem.tag
+  const candidates = targetFp
+    .map((item, idx) => ({ item, idx }))
+    .filter(c => c.item.tag === tag)
+  if (candidates.length === 0) return null
+  if (candidates.length === 1) return candidates[0]!.item
+  const canonicalRelPos = canonicalIndex / Math.max(allCanonical.length - 1, 1)
+  candidates.sort((a, b) => {
+    const relA = a.idx / Math.max(targetFp.length - 1, 1)
+    const relB = b.idx / Math.max(targetFp.length - 1, 1)
+    return Math.abs(relA - canonicalRelPos) - Math.abs(relB - canonicalRelPos)
+  })
+  return candidates[0]!.item
+}
+
+function findMatchingItemCore(
+  targetFp: ContentItem[],
+  canonicalItem: ContentItem,
+  canonicalIndex: number,
+  allCanonical: ContentItem[],
+  consumed: Set<number>,
+): { item: ContentItem; idx: number } | null {
+  const tag = canonicalItem.tag
+  const candidates = targetFp
+    .map((item, idx) => ({ item, idx }))
+    .filter(c => c.item.tag === tag && !consumed.has(c.idx))
+
+  if (candidates.length === 0) return null
+  if (candidates.length === 1) return candidates[0]!
+
+  const canonicalRelPos = canonicalIndex / Math.max(allCanonical.length - 1, 1)
+  candidates.sort((a, b) => {
+    const relA = a.idx / Math.max(targetFp.length - 1, 1)
+    const relB = b.idx / Math.max(targetFp.length - 1, 1)
+    return Math.abs(relA - canonicalRelPos) - Math.abs(relB - canonicalRelPos)
+  })
+  return candidates[0]!
+}