import { describe, it, expect } from 'vitest'
import { generate } from '../generate.js'
import type { ScaffoldComponentInput, PageSpecMin } from '../types.js'
import { buildNavApiPath } from '../../../../../../lib/url-conventions.js'

function fixture(overrides: Partial<ScaffoldComponentInput> = {}): ScaffoldComponentInput {
  return {
    module: 'crm',
    appCode: 'TestV2',
    entity: 'Contact',
    section: 'directory',
    views: ['list', 'detail', 'form'],
    // Full sibling view set — single-view overrides below still emit the
    // cross-view navs (the 3a orchestrator passes this per invocation).
    entityViews: ['list', 'detail', 'form'],
    fields: [
      { name: 'firstName', type: 'string', required: true },
      { name: 'lastName', type: 'string', required: true },
      { name: 'email', type: 'string', required: false },
    ],
    projectPath: '/web',
    ...overrides,
  }
}

describe('scaffold-component / generate', () => {
  it('emits no local usePermissions stub anywhere in any page', () => {
    const files = generate(fixture())
    for (const file of files.filter((f) => f.path.endsWith('Page.tsx'))) {
      expect(file.content).not.toMatch(/function\s+usePermissions\s*\(/)
      expect(file.content).not.toMatch(/const\s+usePermissions\s*=/)
    }
  })

  it('every page imports PageTemplate from @/components/ui/PageTemplate', () => {
    const files = generate(fixture())
    const pages = files.filter((f) => f.path.endsWith('Page.tsx'))
    expect(pages.length).toBeGreaterThan(0)
    for (const page of pages) {
      expect(page.content).toMatch(/import\s*\{\s*PageTemplate\s*\}\s*from\s*['"]@\/components\/ui\/PageTemplate['"]/)
    }
  })

  it('every permission="…" literal matches {module}.{section}.{action} (3 lowercase segments, no appCode prefix)', () => {
    const files = generate(fixture())
    const permRe = /permission\s*=\s*['"]([^'"]+)['"]/g
    const validShape = /^[a-z][a-z0-9-]*\.[a-z][a-z0-9-]*\.[a-z][a-z0-9-]*$/
    let matched = 0
    for (const page of files.filter((f) => f.path.endsWith('Page.tsx'))) {
      let m: RegExpExecArray | null
      while ((m = permRe.exec(page.content)) !== null) {
        matched++
        expect(m[1]).toMatch(validShape)
        expect(m[1].split('.').length).toBe(3)
        expect(m[1].startsWith('crm.')).toBe(true)
      }
    }
    expect(matched).toBeGreaterThan(0)
  })

  it('list / detail / form pages wrap content in <PageTemplate>', () => {
    const files = generate(fixture())
    // List uses plural ('ContactsListPage'); detail/form stay singular
    // (matches the SmartStack project convention).
    const expectedNames: Record<string, string> = {
      List: 'ContactsListPage.tsx',
      Detail: 'ContactDetailPage.tsx',
      Form: 'ContactFormPage.tsx',
    }
    for (const [, fileName] of Object.entries(expectedNames)) {
      const page = files.find((f) => f.path.endsWith(fileName))!
      expect(page).toBeDefined()
      expect(page.content).toMatch(/<PageTemplate\b/)
    }
  })

  it('dashboard view renders typed widgets via WidgetRenderer/DashboardGrid (no bogus consolidated.metrics, no native date)', () => {
    const files = generate(fixture({
      views: ['dashboard'],
      pageSpec: {
        i18nKeys: {},
        widgets: [
          { key: 'active', label: 'Active', type: 'kpi', col: 3 },
          { key: 'byDept', label: 'By department', type: 'chart-pie', col: 6, permission: 'crm.directory.read' },
          { key: 'recent', label: 'Recent', type: 'list', col: 12 },
        ],
      } as unknown as PageSpecMin,
    }))
    const page = files.find((f) => f.path.endsWith('ContactDashboardPage.tsx'))!
    expect(page, 'ContactDashboardPage.tsx').toBeDefined()
    // local dashboard primitives + themed DateInput (never native date)
    expect(page.content).toMatch(/import \{ WidgetRenderer \} from '@\/components\/dashboard\/WidgetRenderer'/)
    expect(page.content).toMatch(/import \{ DashboardGrid \} from '@\/components\/dashboard\/DashboardGrid'/)
    expect(page.content).toMatch(/import \{ DateInput \} from '@\/components\/ui\/DateInput'/)
    expect(page.content).not.toMatch(/type="date"/)
    // typed widgets baked from the pageSpec
    expect(page.content).toMatch(/const WIDGETS: DashboardWidget\[\]/)
    expect(page.content).toMatch(/key: "active"/)
    expect(page.content).toMatch(/type: "chart-pie"/)
    expect(page.content).toMatch(/<WidgetRenderer/)
    // per-widget permission wrapping
    expect(page.content).toMatch(/permission=\{w\.permission\}/)
    // the bogus contract is gone; still resolves data through the hook
    expect(page.content).not.toMatch(/consolidated\.metrics/)
    expect(page.content).not.toMatch(/consolidated, alerts/)
    expect(page.content).toMatch(/useDashboardContact\(/)
  })

  it('preserves PermissionGuard from @atlashub/smartstack on mutating actions', () => {
    const files = generate(fixture())
    const list = files.find((f) => f.path.endsWith('ContactsListPage.tsx'))!
    expect(list.content).toMatch(/from\s+['"]@atlashub\/smartstack['"]/)
    // Create button is wrapped
    expect(list.content).toMatch(/<PermissionGuard\s+permission=['"]crm\.directory\.create['"]/)
  })

  it('emits stable data-testids for UAT and marks the page-level guard', () => {
    const files = generate(fixture({ views: ['list', 'detail', 'form'] }))
    const list = files.find((f) => f.path.endsWith('ContactsListPage.tsx'))!
    // Row action affordances carry a per-id testid the UAT driver keys on.
    expect(list.content).toContain('data-testid={`row-edit-${item.id}`}')
    expect(list.content).toContain('data-testid={`row-delete-${item.id}`}')
    // The page-level read guard renders a permission-denied marker (not a blank page).
    expect(list.content).toMatch(/<PermissionGuard\s+permission="crm\.directory\.read"\s+page>/)
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    expect(form.content).toContain('data-testid="form-submit"')
  })

  it('derives the guard prefix from the PAGESPEC permission (resource grain honoured — chantier 4.1)', () => {
    // The generator used to ALWAYS recompute `{module}.{section}` and ignore
    // spec.permission (H11 — the stale comment even claimed the opposite): a
    // narrower resource-grain page silently guarded on the wider section key.
    const files = generate(fixture({
      views: ['list'],
      pageSpec: {
        view: 'list',
        permission: 'crm.directory.vip.read',
        i18nKeys: {},
      } as unknown as PageSpecMin,
    }))
    const list = files.find((f) => f.path.endsWith('ContactsListPage.tsx'))!
    expect(list.content).toMatch(/<PermissionGuard\s+permission="crm\.directory\.vip\.read"\s+page>/)
    expect(list.content).toMatch(/<PermissionGuard\s+permission=['"]crm\.directory\.vip\.create['"]/)
    // The wider section-only key must be GONE from the guards.
    expect(list.content).not.toMatch(/permission=['"]crm\.directory\.read['"]/)
  })

  it('keeps the legacy {module}.{section} derivation when no pageSpec permission is provided', () => {
    const files = generate(fixture({ views: ['list'], pageSpec: undefined }))
    const list = files.find((f) => f.path.endsWith('ContactsListPage.tsx'))!
    expect(list.content).toMatch(/<PermissionGuard\s+permission="crm\.directory\.read"\s+page>/)
  })

  it('generates hub pages (app-home / module-home / section-home) with PageTemplate + tokens', () => {
    const files = generate(fixture({ views: ['app-home', 'module-home', 'section-home'] }))
    const expectedFiles = ['ContactsAppHomePage.tsx', 'ContactsModuleHomePage.tsx', 'ContactsSectionHomePage.tsx']
    for (const filename of expectedFiles) {
      const page = files.find((f) => f.path.endsWith(filename))!
      expect(page, `missing ${filename}`).toBeDefined()
      // Wraps content in <PageTemplate>
      expect(page.content).toMatch(/<PageTemplate\b/)
      // Uses CSS tokens (no raw Tailwind colors)
      expect(page.content).not.toMatch(/bg-white\b/)
      expect(page.content).not.toMatch(/bg-(red|blue|green|yellow|gray|slate|zinc)-\d/)
      // Permission check is 4-seg with appCode prefix
      expect(page.content).toMatch(/<PermissionGuard\s+permission=['"]crm\.directory\.read['"]/)
      // useTranslation namespace is the module
      expect(page.content).toMatch(/useTranslation\(['"]crm['"]\)/)
      // No hand-written legacy imports
      expect(page.content).not.toMatch(/from\s+['"]@\/hooks\//)
      expect(page.content).not.toMatch(/from\s+['"]@\/services\//)
    }
  })

  it('hub pages are LIVE (plan UI 1.3): wired count via the list hook, resolved quickLinks, no dead mockup', () => {
    const files = generate(fixture({
      views: ['section-home'],
      pageSpec: {
        i18nKeys: {},
        widgets: [
          { key: 'total', labelKey: 'widgets.total', type: 'kpi', entity: 'Contact', aggregation: 'count' },
          { key: 'foreign', labelKey: 'widgets.foreign', type: 'kpi', entity: 'Invoice', aggregation: 'sum', field: 'amount' },
        ],
        quickLinks: [
          { key: 'all', labelKey: 'quicklinks.all', icon: 'list', screenTarget: 'SCR-CRM-DIRECTORY-LIST-001' },
          { key: 'new', labelKey: 'quicklinks.new', icon: 'plus', screenTarget: 'SCR-CRM-DIRECTORY-FORM-001', permission: 'crm.directory.create' },
          { key: 'ghost', labelKey: 'quicklinks.ghost', screenTarget: 'SCR-OTHER-MODULE-LIST-001' },
        ],
      } as unknown as PageSpecMin,
    }))
    const page = files.find((f) => f.path.endsWith('ContactsSectionHomePage.tsx'))!.content
    // Own-entity count widget reads the list hook's totalCount through StatCard.
    expect(page).toMatch(/import \{ StatCard \} from '@\/components\/ui\/StatCard'/)
    expect(page).toMatch(/const \{ data: countData, isLoading: countLoading \} = useContacts\(\{ page: 1, pageSize: 1 \}\)/)
    expect(page).toMatch(/value=\{countData\?\.totalCount \?\? 0\}/)
    expect(page).toMatch(/loading=\{countLoading\}/)
    // A non-wirable widget stays visibly unwired — never a fake live figure.
    expect(page).toMatch(/label=\{t\('contact\.widgets\.foreign'\)\}\n\s+value="—"/)
    // QuickLinks resolve to real route helpers; the unresolvable one is OMITTED.
    expect(page).toMatch(/onClick=\{\(\) => navigate\(routes\.directory\.list\(\)\)\}/)
    expect(page).toMatch(/onClick=\{\(\) => navigate\(routes\.directory\.create\(\)\)\}/)
    expect(page).toMatch(/import \{ routes \} from '@\/extensions\/testv2-crmRoutes'/)
    expect(page).not.toMatch(/quicklinks\.ghost/)
    // The permissioned link is gated.
    expect(page).toMatch(/<PermissionGuard permission="crm\.directory\.create">/)
    // The dead-mockup era markers are gone.
    expect(page).not.toMatch(/navigate\('#'\)/)
    expect(page).not.toMatch(/>—</)
  })

  it('hub pages: legacy mode (no pageSpec) keeps Slot placeholders and imports nothing dead', () => {
    const files = generate(fixture({ views: ['module-home'] }))
    const page = files.find((f) => f.path.endsWith('ContactsModuleHomePage.tsx'))!.content
    expect(page).toMatch(/<Slot name="contact\.home\.kpis" \/>/)
    expect(page).toMatch(/<Slot name="contact\.home\.navigation" \/>/)
    // No quickLink resolved → no navigate/routes imports (type-check gate).
    expect(page).not.toMatch(/useNavigate/)
    expect(page).not.toMatch(/from '@\/extensions\//)
    expect(page).not.toMatch(/StatCard/)
  })

  it('emits 4 locale files per entity (fr/en/it/de)', () => {
    const files = generate(fixture())
    const locales = files.filter((f) => /\/i18n\/locales\/(fr|en|it|de)\/crm\.json$/.test(f.path))
    expect(locales).toHaveLength(4)
    for (const loc of locales) {
      const parsed = JSON.parse(loc.content)
      expect(parsed).toHaveProperty('contact')
      expect(parsed.contact).toHaveProperty('list')
      expect(parsed.contact).toHaveProperty('detail')
      expect(parsed.contact).toHaveProperty('form')
    }
  })

  it('isolates i18n keys when two entities share the same module', () => {
    const filesA = generate(fixture({ entity: 'Contact', module: 'crm' }))
    const filesB = generate(fixture({
      entity: 'Company',
      module: 'crm',
      section: 'companies',
      fields: [
        { name: 'name', type: 'string', required: true },
        { name: 'industry', type: 'string', required: false },
      ],
    }))
    const frA = JSON.parse(filesA.find((f) => /fr\/crm\.json$/.test(f.path))!.content)
    const frB = JSON.parse(filesB.find((f) => /fr\/crm\.json$/.test(f.path))!.content)

    // Each entity has its own top-level key — no collision
    expect(frA).toHaveProperty('contact')
    expect(frB).toHaveProperty('company')
    expect(frA.contact).toHaveProperty('list')
    expect(frA.contact).toHaveProperty('detail')
    expect(frB.company).toHaveProperty('list')
    expect(frB.company).toHaveProperty('detail')

    // Titles are entity-specific
    expect(frA.contact.list.title).not.toBe(frB.company.list.title)
  })

  it('prefixes all t() calls with entity key in generated pages', () => {
    const files = generate(fixture())
    const pages = files.filter((f) => f.path.endsWith('Page.tsx'))
    for (const page of pages) {
      // Every t('...') call must start with the entity prefix 'contact.'
      // (word-gated: useListParamOpt('sort') must not read as t('sort')).
      const tCalls = page.content.match(/(?<![A-Za-z])t\('([^']+)'\)/g) ?? []
      for (const call of tCalls) {
        const key = call.match(/t\('([^']+)'\)/)![1]
        expect(key.startsWith('contact.'), `bare key: ${call}`).toBe(true)
      }
      // No bare t('list.'), t('form.'), t('detail.'), t('breadcrumb.') etc.
      expect(page.content).not.toMatch(/t\('(?:list|form|detail|dashboard|home|breadcrumb)\./)
    }
  })

  it('converts kebab-case section to camelCase for routes.* property access', () => {
    // Regression guard for the REFERENTIELS class of crashes: when the
    // section is multi-word kebab (e.g. `types-affaire`), the generated
    // `navigate(routes.types-affaire.detail(id))` is parsed by JS as
    // `routes.types - affaire.detail(id)` and throws ReferenceError at the
    // first interaction. The fix mirrors what scaffold-routes already does
    // (`kebabToCamel(entity.section)`) so both CLIs agree on the property
    // name: `routes.typesAffaire`.
    const files = generate(fixture({ section: 'types-affaire' }))
    const pages = files.filter(f => f.path.endsWith('Page.tsx'))
    for (const page of pages) {
      // Camel form MUST appear wherever routes.<section>.<view>() is referenced.
      if (page.content.includes('routes.')) {
        expect(page.content, page.path).toMatch(/routes\.typesAffaire\./)
        expect(page.content, page.path).not.toMatch(/routes\.types-affaire\./)
      }
    }
  })

  it('leaves single-word sections unchanged (camel of `contacts` is `contacts`)', () => {
    const files = generate(fixture()) // section: 'directory'
    const pages = files.filter(f => f.path.endsWith('Page.tsx'))
    for (const page of pages) {
      if (page.content.includes('routes.')) {
        expect(page.content, page.path).toMatch(/routes\.directory\./)
      }
    }
  })
})

// ─── Enriched mode (Phase 3a, post-pageSpec) ────────────────────────────

function pageSpecFixture(overrides: Partial<PageSpecMin> = {}): PageSpecMin {
  return {
    screenCode: 'SCR-CONTACT-LIST',
    module: 'crm',
    appCode: 'testv2',
    section: 'directory',
    entity: 'Contact',
    view: 'list',
    filePath: 'src/pages/testv2/crm/directory/ContactListPage.tsx',
    permission: 'crm.directory.read',
    actions: [
      { code: 'create', scope: 'header', labelKey: 'list.create', permission: 'crm.directory.create', variant: 'primary' },
    ],
    columns: [
      { key: 'firstName', labelKey: 'list.columns.firstName', sortable: true },
      { key: 'lastName', labelKey: 'list.columns.lastName', sortable: true },
    ],
    i18nKeys: {
      fr: {
        'list.title': 'Contacts métier',
        'list.subtitle': 'Annuaire CRM personnalisé',
        'list.create': 'Nouveau contact',
        'list.search': 'Filtrer…',
        'list.loading': 'Chargement…',
        'list.empty': 'Aucun contact à afficher',
        'list.columns.firstName': 'Prénom',
        'list.columns.lastName': 'Nom',
      },
      en: {
        'list.title': 'Business contacts',
        'list.subtitle': 'CRM custom directory',
        'list.create': 'New contact',
        'list.search': 'Filter…',
        'list.loading': 'Loading…',
        'list.empty': 'No contact to show',
        'list.columns.firstName': 'First name',
        'list.columns.lastName': 'Last name',
      },
      it: {
        'list.title': 'Contatti business',
        'list.subtitle': 'Rubrica CRM',
        'list.create': 'Nuovo contatto',
        'list.search': 'Filtra…',
        'list.loading': 'Caricamento…',
        'list.empty': 'Nessun contatto',
        'list.columns.firstName': 'Nome',
        'list.columns.lastName': 'Cognome',
      },
      de: {
        'list.title': 'Geschäftskontakte',
        'list.subtitle': 'Benutzerdefiniertes CRM-Verzeichnis',
        'list.create': 'Neuer Kontakt',
        'list.search': 'Filtern…',
        'list.loading': 'Wird geladen…',
        'list.empty': 'Kein Kontakt anzuzeigen',
        'list.columns.firstName': 'Vorname',
        'list.columns.lastName': 'Nachname',
      },
    },
    needsRefinement: false,
    specHash: 'a'.repeat(64),
    ...overrides,
  }
}

describe('scaffold-component / generate — enriched mode', () => {
  it('layers pageSpec.i18nKeys overrides on top of the buildTranslations floor', () => {
    const files = generate(fixture({ pageSpec: pageSpecFixture() }))
    const fr = files.find((f) => /\/i18n\/locales\/fr\/crm\.json$/.test(f.path))!
    expect(fr).toBeDefined()
    const parsed = JSON.parse(fr.content)
    // The pageSpec catalogue overrides the auto-generated floor — these are
    // project-specific values that buildTranslations() would never produce on
    // its own (humanize 'firstName' → 'First name', not 'Prénom métier').
    expect(parsed.contact.list.title).toBe('Contacts métier')
    expect(parsed.contact.list.subtitle).toBe('Annuaire CRM personnalisé')
    expect(parsed.contact.list.create).toBe('Nouveau contact')
    expect(parsed.contact.list.empty).toBe('Aucun contact à afficher')
    expect(parsed.contact.list.columns.firstName).toBe('Prénom')
    expect(parsed.contact.list.columns.lastName).toBe('Nom')
  })

  it('emits a COMPLETE structural floor even when pageSpec.i18nKeys is thin', () => {
    // Regression for the RH raw-key bug: a thin PRD i18nKeys block (only
    // list.title) must NOT leave the structural keys the templates render bare
    // untranslated — the generator seeds the full buildTranslations() floor
    // underneath, in all 4 locales, then lets the PRD override what it provides.
    const thin = pageSpecFixture({
      i18nKeys: {
        fr: { 'list.title': 'Employés' },
        en: { 'list.title': 'Employees' },
        it: { 'list.title': 'Dipendenti' },
        de: { 'list.title': 'Mitarbeiter' },
      },
    })
    const files = generate(fixture({ pageSpec: thin }))
    // Every structural key rendered WITHOUT a defaultValue must resolve in
    // each locale (these are exactly the keys that showed raw in the RH module).
    const structural = [
      ['breadcrumb', 'section'],
      ['list', 'actionsColumn'], ['list', 'edit'], ['list', 'delete'],
      ['list', 'empty'], ['list', 'error'], ['list', 'filters', 'all'],
      ['detail', 'edit'], ['detail', 'notFound'],
      ['form', 'submitCreate'], ['form', 'submitUpdate'], ['form', 'cancel'],
      ['form', 'required'], ['form', 'section', 'essential'], ['form', 'section', 'details'],
      ['kanban', 'title'], ['kanban', 'unassigned'],
      ['reconduction', 'action', 'refuse'], ['reconduction', 'columns', 'identifier'],
    ]
    for (const locale of ['fr', 'en', 'it', 'de'] as const) {
      const file = files.find((f) => f.path === `src/i18n/locales/${locale}/crm.json`)!
      const c = JSON.parse(file.content).contact
      for (const path of structural) {
        const leaf = path.reduce<unknown>((node, seg) => (node as Record<string, unknown>)?.[seg], c)
        expect(leaf, `${locale} ${path.join('.')}`).toBeTypeOf('string')
      }
    }
    // …and the one key the PRD does supply still wins over the floor.
    const frC = JSON.parse(files.find((f) => /\/fr\/crm\.json$/.test(f.path))!.content).contact
    expect(frC.list.title).toBe('Employés')
  })

  it('drops "[en]/[it]/[de] …" placeholder values so the floor wins (PRD-089 self-heal)', () => {
    // Legacy "author FR, defer the rest" pagespecs carry bracket-tagged
    // placeholders in en/it/de. They must NEVER override the floor: dropping
    // them here ships the floor's real translation (or humanised label)
    // instead of a raw "[en] …" on screen. PRD-089 still gates the PRD —
    // this is the belt-and-suspenders heal at the scaffolder input edge.
    const ps = pageSpecFixture({
      i18nKeys: {
        fr: { 'list.title': 'Contacts métier', 'list.create': 'Nouveau contact' },
        en: { 'list.title': '[en] Contacts métier', 'list.create': 'New contact' },
        it: { 'list.title': '[it] Contacts métier', 'list.create': '[it] Nouveau contact' },
        de: { 'list.title': '[de] Contacts métier' },
      },
    })
    const files = generate(fixture({ pageSpec: ps }))
    const read = (locale: string) =>
      JSON.parse(files.find((f) => f.path === `src/i18n/locales/${locale}/crm.json`)!.content).contact
    // Real translations ride through untouched.
    expect(read('fr').list.title).toBe('Contacts métier')
    expect(read('en').list.create).toBe('New contact')
    // Placeholders are dropped — the buildTranslations() floor wins.
    expect(read('en').list.title).toBe('Contacts')
    expect(read('it').list.title).toBe('Contacts')
    expect(read('it').list.create).toBe('Crea')
    expect(read('de').list.title).toBe('Contacts')
    // No bracket-tagged placeholder survives in ANY locale payload.
    for (const locale of ['fr', 'en', 'it', 'de'] as const) {
      const content = files.find((f) => f.path === `src/i18n/locales/${locale}/crm.json`)!.content
      expect(content, `${locale} catalogue must not ship placeholders`).not.toMatch(/\[(en|it|de)\] /)
    }
  })

  it('normalizes PascalCase field keys from pageSpec.i18nKeys to camelCase', () => {
    const ps = pageSpecFixture({
      i18nKeys: {
        fr: {
          'list.title': 'Contacts',
          'list.columns.FirstName': 'Prénom',
          'list.columns.LastName': 'Nom',
          'form.fields.FirstName': 'Prénom',
          'form.fields.EstActif': 'Actif',
          'detail.fields.Code': 'Code',
          'list.filters.SecteurId': 'Secteur',
        },
        en: { 'list.title': 'Contacts', 'list.columns.FirstName': 'First name', 'form.fields.FirstName': 'First name', 'form.fields.EstActif': 'Active', 'detail.fields.Code': 'Code', 'list.filters.SecteurId': 'Sector' },
        it: { 'list.title': 'Contatti', 'list.columns.FirstName': 'Nome', 'form.fields.FirstName': 'Nome', 'form.fields.EstActif': 'Attivo', 'detail.fields.Code': 'Codice', 'list.filters.SecteurId': 'Settore' },
        de: { 'list.title': 'Kontakte', 'list.columns.FirstName': 'Vorname', 'form.fields.FirstName': 'Vorname', 'form.fields.EstActif': 'Aktiv', 'detail.fields.Code': 'Code', 'list.filters.SecteurId': 'Sektor' },
      },
    })
    const files = generate(fixture({ pageSpec: ps }))
    const fr = files.find((f) => /\/i18n\/locales\/fr\/crm\.json$/.test(f.path))!
    const parsed = JSON.parse(fr.content)
    // PascalCase field keys normalized to camelCase (matching t() calls)
    expect(parsed.contact.list.columns.firstName).toBe('Prénom')
    expect(parsed.contact.list.columns.lastName).toBe('Nom')
    expect(parsed.contact.form.fields.firstName).toBe('Prénom')
    expect(parsed.contact.form.fields.estActif).toBe('Actif')
    expect(parsed.contact.detail.fields.code).toBe('Code')
    expect(parsed.contact.list.filters.secteurId).toBe('Secteur')
    // Non-field keys stay as-is
    expect(parsed.contact.list.title).toBe('Contacts')
    // PascalCase originals should NOT exist
    expect(parsed.contact.list.columns.FirstName).toBeUndefined()
    expect(parsed.contact.form.fields.FirstName).toBeUndefined()
  })

  it('produces parallel locale catalogues from pageSpec.i18nKeys (4 locales nested)', () => {
    const files = generate(fixture({ pageSpec: pageSpecFixture() }))
    for (const locale of ['fr', 'en', 'it', 'de'] as const) {
      const file = files.find((f) => f.path === `src/i18n/locales/${locale}/crm.json`)!
      expect(file, `missing locale ${locale}`).toBeDefined()
      const parsed = JSON.parse(file.content)
      expect(parsed.contact).toBeDefined()
      expect(parsed.contact.list).toBeDefined()
      expect(parsed.contact.list.columns).toBeDefined()
      expect(parsed.contact.list.columns.firstName).toBeDefined()
    }
  })

  it('emits i18n catalogues under src/i18n relative to the web root (same base as pages)', () => {
    // projectPath IS the validated web root (assertWebProjectRoot) — a
    // web/<app>-web prefix here would double-nest into a phantom folder the
    // runtime never loads (business pages then render raw i18n keys).
    const files = generate(fixture({ pageSpec: pageSpecFixture() }))
    const i18nFiles = files.filter((f) => /\.json$/.test(f.path))
    expect(i18nFiles.length).toBeGreaterThan(0)
    for (const f of i18nFiles) {
      expect(f.path, 'i18n path must be web-root relative, like pages').toMatch(/^src\/i18n\/locales\//)
    }
    expect(files.some((f) => f.path.startsWith('web/')), 'no emitted path may start with web/').toBe(false)
  })

  it('falls back to buildTranslations() (legacy) when pageSpec is absent', () => {
    // No pageSpec → legacy dictionary outputs 'Contacts' (plural humanize) for list.title
    const files = generate(fixture())
    const fr = files.find((f) => /\/i18n\/locales\/fr\/crm\.json$/.test(f.path))!
    const parsed = JSON.parse(fr.content)
    expect(parsed.contact.list.title).toBe('Contacts')
    // No 'subtitle' override from pageSpec — legacy "Gérer les contacts"
    expect(parsed.contact.list.subtitle).toContain('Gérer')
  })

  it('legacy mode and enriched mode emit the same number of files (no schema drift)', () => {
    const legacyFiles = generate(fixture()).map((f) => f.path).sort()
    const enrichedFiles = generate(fixture({ pageSpec: pageSpecFixture() })).map((f) => f.path).sort()
    // Enriched mode honours pageSpec.filePath as the page output target;
    // legacy mode uses the derived `src/pages/{appCode}/{module}/{section}/...` path.
    // The PATHS may differ (e.g. legacy folder name) but the FILE COUNT
    // must stay identical so no view is silently dropped.
    expect(enrichedFiles.length).toBe(legacyFiles.length)
  })

  it('honours pageSpec.filePath verbatim — output target matches the legacy folder', () => {
    // pageSpec.filePath = 'src/pages/testv2/crm/directory/ContactListPage.tsx' (the
    // fixture path, lifted as-is from the canonical PageSpec contract). Even when
    // the project's actual folder layout differs from the derived
    // `src/pages/{module}/{section}/...`, the scaffold MUST write at the path
    // declared in the pageSpec — that's the contract's "source of truth" rule.
    const ps = pageSpecFixture({ filePath: 'src/pages/legacy-budgeting/budgets/BudgetsListPage.tsx' })
    const files = generate(fixture({
      pageSpec: ps,
      module: 'budgets',
      entity: 'Budget',
      section: 'budgets',
      views: ['list'],
    }))
    const listPage = files.find((f) => f.path.endsWith('BudgetsListPage.tsx'))!
    expect(listPage).toBeDefined()
    expect(listPage.path).toBe('src/pages/legacy-budgeting/budgets/BudgetsListPage.tsx')
  })

  it('a bare pageSpec.filePath (no directory) never becomes the base directory itself', () => {
    // A filePath like 'BudgetsListPage.tsx' has no '/' — the directory-strip
    // regex used to leave base = 'BudgetsListPage.tsx', landing SIBLING files
    // under 'BudgetsListPage.tsx/…'. The base must fall back to the canonical
    // src/pages/{app}/{module}/{section}/ directory instead.
    const ps = pageSpecFixture({ filePath: 'BudgetsListPage.tsx' })
    const files = generate(fixture({
      pageSpec: ps,
      module: 'budgets',
      entity: 'Budget',
      section: 'budgets',
      views: ['list'],
    }))
    expect(files.some((f) => f.path.includes('BudgetsListPage.tsx/'))).toBe(false)
  })

  it('uses pageSpec.columns verbatim — does NOT pull legacy columns from spec.fields', () => {
    // The data model can carry attributes the BA did NOT include in the list
    // view (e.g. legacy `description` column). Without honouring pageSpec.columns
    // the scaffold renders them as untranslated `LIST.COLUMNS.DESCRIPTION` headers.
    const ps = pageSpecFixture({
      columns: [
        { key: 'code', labelKey: 'list.columns.code', sortable: true },
        { key: 'label', labelKey: 'list.columns.label', sortable: true },
        { key: 'initialAmount', labelKey: 'list.columns.initialAmount', sortable: true },
      ],
    })
    const files = generate(fixture({
      pageSpec: ps,
      // Inject a legacy `description` field that the BA did NOT declare for this view.
      fields: [
        { name: 'code', type: 'string', required: true },
        { name: 'label', type: 'string', required: true },
        { name: 'description', type: 'string', required: false },
        { name: 'initialAmount', type: 'number', required: true },
      ],
      module: 'budgets',
      entity: 'Budget',
      section: 'budgets',
      views: ['list'],
    }))
    const list = files.find((f) => f.path.endsWith('ContactsListPage.tsx'))
      ?? files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // The pageSpec-declared columns appear:
    expect(list.content).toMatch(/key:\s*'code'/)
    expect(list.content).toMatch(/key:\s*'label'/)
    expect(list.content).toMatch(/key:\s*'initialAmount'/)
    // The legacy `description` column does NOT appear (would surface as
    // `LIST.COLUMNS.DESCRIPTION` in the rendered page header).
    expect(list.content).not.toMatch(/key:\s*'description'/)
    // labelKey from pageSpec is honoured (path verbatim, leaf normalised to
    // camelCase by normalizeI18nKey — symmetric with the JSON catalogue which
    // goes through normalizeI18nFieldKeys). camelCase leaves are idempotent
    // so this test still passes verbatim.
    expect(list.content).toMatch(/t\('budget\.list\.columns\.code'\)/)
    expect(list.content).toMatch(/t\('budget\.list\.columns\.initialAmount'\)/)
  })

  it('renders a FilterBar when pageSpec.filters[] is non-empty', () => {
    const ps = pageSpecFixture({
      columns: [{ key: 'label', labelKey: 'list.columns.label', sortable: true }],
      // Add filters: text + select + date-range — each produces a different control.
      filters: [
        { field: 'label', labelKey: 'list.filters.label', control: 'text' },
        {
          field: 'status',
          labelKey: 'list.filters.status',
          control: 'select',
          options: ['active', 'archived'],
        },
        { field: 'startDate', labelKey: 'list.filters.startDate', control: 'date-range' },
      ],
    } as Parameters<typeof pageSpecFixture>[0])
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // The component imports useState + useMemo (filter state + chips) and
    // useEffect (search/filter debounces — the list is always server-driven).
    expect(list.content).toMatch(/import\s*\{\s*useMemo,\s*useState,\s*useEffect\s*\}\s*from\s*'react'/)
    // The FilterBar primitive hosts the toolbar (search + filters + chips).
    expect(list.content).toMatch(/import \{ FilterBar \} from '@\/components\/ui\/FilterBar'/)
    expect(list.content).toMatch(/<FilterBar/)
    // Text filter input is wired:
    expect(list.content).toMatch(/onFilterChange\(\s*'label'/)
    // Select filter renders a themed EnumSelect (not a native <select>) with its
    // option set + "all" default, and imports the primitive on the list page:
    expect(list.content).toMatch(/<EnumSelect/)
    expect(list.content).not.toMatch(/<select/)
    expect(list.content).toMatch(/import \{ EnumSelect \} from '@\/components\/ui\/EnumSelect'/)
    expect(list.content).toMatch(/\{ value: 'active', label: 'active' \}/)
    expect(list.content).toMatch(/\{ value: 'archived', label: 'archived' \}/)
    expect(list.content).toMatch(/contact\.list\.filters\.all/)
    // Date-range produces 2 themed DateInputs (not native <input type="date">):
    expect(list.content).toMatch(/<DateInput/)
    expect(list.content).toMatch(/import \{ DateInput \} from '@\/components\/ui\/DateInput'/)
    expect(list.content).toMatch(/onFilterChange\('startDateFrom'/)
    expect(list.content).toMatch(/onFilterChange\('startDateTo'/)
    // DataTable consumes the filtered list.
    expect(list.content).toMatch(/data=\{filtered\}/)
    // Global search now lives INSIDE the filter toolbar (controlled), not as a
    // separate input below it — URL-backed like the rest of the list state.
    expect(list.content).toMatch(/const \[search, setSearch\] = useListParam\('q', ''\)/)
    expect(list.content).toMatch(/value=\{search\}/)
    expect(list.content).toMatch(/onChange=\{\(event\) => setSearch\(event\.target\.value\)\}/)
    expect(list.content).toMatch(/placeholder=\{t\('\w+\.list\.search'\)\}/)
    // Search/X icons are hoisted into the base lucide import (no duplicate identifier).
    expect(list.content).toMatch(/import \{ Plus, Pencil, Trash2, List, Search, X/)
    // The table runs in controlled-search mode — no built-in `searchable` input.
    expect(list.content).toMatch(/searchTerm=\{search\}/)
    expect(list.content).toMatch(/onSearchChange=\{setSearch\}/)
    expect(list.content).not.toMatch(/\bsearchable\b/)
  })

  it('drives the server (pagination + search + sort) when pageSpec.filters is empty', () => {
    const ps = pageSpecFixture({ filters: [] } as Parameters<typeof pageSpecFixture>[0])
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // Server state lives on the page (page / size / search / sort) — the debounce
    // needs useEffect.
    expect(list.content).toMatch(/const \[page, setPage\] = useListNumberParam\('page', 1\)/)
    expect(list.content).toMatch(/const \[search, setSearch\] = useListParam\('q', ''\)/)
    expect(list.content).toMatch(/const \[sortBy, setSortBy\]/)
    expect(list.content).toMatch(/import\s*\{[^}]*\buseEffect\b[^}]*\}\s*from\s*'react'/)
    // The list hook is called WITH server params (not the bare, client-only form).
    expect(list.content).toMatch(/use\w+\(\{ page, pageSize, search: debouncedSearch \|\| undefined, sortBy, sortDir \}\)/)
    // The table is server-driven: no local filter / sort / slice.
    expect(list.content).toMatch(/serverMode/)
    expect(list.content).toMatch(/page=\{page\}/)
    expect(list.content).toMatch(/totalCount=\{totalCount\}/)
    expect(list.content).toMatch(/onPageChange=\{setPage\}/)
    expect(list.content).toMatch(/onSortChange=\{handleSort\}/)
    expect(list.content).toMatch(/const totalCount = data\?\.totalCount \?\? 0/)
    // Controlled search box in a toolbar — NOT the DataTable's built-in `searchable`.
    expect(list.content).toMatch(/searchTerm=\{search\}/)
    expect(list.content).toMatch(/onSearchChange=\{setSearch\}/)
    expect(list.content).not.toMatch(/\bsearchable\b/)
    // The search box lives in the FilterBar toolbar even without filters.
    expect(list.content).toMatch(/<FilterBar/)
    expect(list.content).toMatch(/data=\{filtered\}/)
    expect(list.content).toMatch(/const filtered = data\?\.items \?\? \[\]/)
  })

  it('Fix #9 — normalises pagespec column labelKey leaf to match the JSON i18n catalogue (PascalCase → camelCase)', () => {
    // The PRD sometimes emits PascalCase leaves (`list.columns.Code`,
    // `list.columns.EstActif`). The JSON catalogue normalises them to
    // camelCase via normalizeI18nFieldKeys (line ~1400). Without the
    // symmetric normalisation on the TSX side, t('…Code') resolves nothing
    // and the screen shows the raw key. This is THE reason every table
    // column header rendered the literal key on REFERENTIELS.
    const ps = pageSpecFixture({
      columns: [
        { key: 'code', labelKey: 'list.columns.Code', sortable: true },
        { key: 'estActif', labelKey: 'list.columns.EstActif', sortable: true },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // The leaf is camelCased in the t() call:
    expect(list.content).toMatch(/t\('contact\.list\.columns\.code'\)/)
    expect(list.content).toMatch(/t\('contact\.list\.columns\.estActif'\)/)
    // Negative — the PascalCase leaf must NOT leak into the TSX:
    expect(list.content).not.toMatch(/t\('contact\.list\.columns\.Code'\)/)
    expect(list.content).not.toMatch(/t\('contact\.list\.columns\.EstActif'\)/)
  })

  it('Fix #9 — normalises pagespec filter labelKey leaf across every control type', () => {
    // Same normalisation applied at the source — one pass on pageSpecFilters
    // covers text, select, date-range and boolean labels + placeholders
    // (6 substitution sites in renderFilterInput) without touching them.
    const ps = pageSpecFixture({
      filters: [
        { field: 'code', labelKey: 'list.filters.Code', control: 'text' },
        { field: 'status', labelKey: 'list.filters.Status', control: 'select', options: ['a'] },
        { field: 'startDate', labelKey: 'list.filters.StartDate', control: 'date-range' },
        { field: 'estActif', labelKey: 'list.filters.EstActif', control: 'boolean' },
      ],
    } as Parameters<typeof pageSpecFixture>[0])
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // All four control types resolve the camelCased leaf:
    expect(list.content).toMatch(/t\('contact\.list\.filters\.code'\)/)
    expect(list.content).toMatch(/t\('contact\.list\.filters\.status'\)/)
    expect(list.content).toMatch(/t\('contact\.list\.filters\.startDate'\)/)
    expect(list.content).toMatch(/t\('contact\.list\.filters\.estActif'\)/)
    // Negative — no PascalCase leaves leak into any of the 6 render sites:
    expect(list.content).not.toMatch(/t\('contact\.list\.filters\.Code'\)/)
    expect(list.content).not.toMatch(/t\('contact\.list\.filters\.Status'\)/)
    expect(list.content).not.toMatch(/t\('contact\.list\.filters\.StartDate'\)/)
    expect(list.content).not.toMatch(/t\('contact\.list\.filters\.EstActif'\)/)
  })

  it('Fix #9 — does NOT mangle action labelKey (parent not in I18N_FIELD_PARENTS)', () => {
    // Action labels live under `list.<code>` / `form.actions.<code>` —
    // their parent is NOT one of {fields, columns, filters, help}, so
    // normalizeI18nFieldKeys leaves them alone in the JSON. The TSX must
    // mirror that and keep them verbatim too, otherwise we would break
    // kebab-case action codes like `toggle-actif`.
    const ps = pageSpecFixture({
      actions: [
        { code: 'create', scope: 'header', labelKey: 'list.create', permission: 'crm.directory.create', variant: 'primary' },
        { code: 'toggle-actif', scope: 'row', labelKey: 'list.toggle-actif', permission: 'crm.directory.update', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // Action labels stay verbatim (2-seg path: parts.length < 3 → skip),
    // and the kebab-case `toggle-actif` is preserved exactly:
    expect(list.content).toMatch(/t\('contact\.list\.create'\)/)
    expect(list.content).toMatch(/t\('contact\.list\.toggle-actif'\)/)
  })

  it('collapses row-scope custom actions into the "…" overflow menu (RowActionsMenu)', () => {
    const ps = pageSpecFixture({
      actions: [
        { code: 'create', scope: 'header', labelKey: 'list.create', permission: 'crm.directory.create', variant: 'primary' },
        { code: 'archive', scope: 'row', labelKey: 'list.archive', permission: 'crm.directory.update', variant: 'secondary' },
        { code: 'duplicate', scope: 'row', labelKey: 'list.duplicate', permission: 'crm.directory.create', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // Hooks for archive + duplicate imported alongside CRUD hooks
    expect(list.content).toMatch(/import\s*\{\s*useContacts,\s*useDeleteContact, useArchiveContact, useDuplicateContact\s*\}/)
    // Mutation declarations
    expect(list.content).toMatch(/const archiveMutation = useArchiveContact\(\)/)
    expect(list.content).toMatch(/const duplicateMutation = useDuplicateContact\(\)/)
    // Handler functions wired to mutations
    expect(list.content).toMatch(/const handleArchive = async \(item: ContactListDto\) => \{[\s\S]*?archiveMutation\.mutateAsync\(item\.id\)/)
    expect(list.content).toMatch(/const handleDuplicate = async \(item: ContactListDto\) => \{[\s\S]*?duplicateMutation\.mutateAsync\(item\.id\)/)
    // Icon imports include Archive + Copy (from the lucide map)
    expect(list.content).toMatch(/Archive,/)
    expect(list.content).toMatch(/Copy/)
    // Row custom actions render inside a single overflow menu, not an inline strip.
    expect(list.content).toMatch(/import \{ RowActionsMenu \} from '@\/components\/ui\/RowActionsMenu'/)
    expect(list.content).toMatch(/<RowActionsMenu\s+items=\{\[/)
    // Each action is a menu item: key + localized label + permission-gate + handler.
    expect(list.content).toMatch(/\{ key: 'archive', label: t\('contact\.list\.archive'\), icon: <Archive className="w-4 h-4" \/>, permission: 'crm\.directory\.update', onClick: \(\) => \{ void handleArchive\(item\) \} \}/)
    expect(list.content).toMatch(/\{ key: 'duplicate', label: t\('contact\.list\.duplicate'\), icon: <Copy className="w-4 h-4" \/>, permission: 'crm\.directory\.create', onClick: \(\) => \{ void handleDuplicate\(item\) \} \}/)
    // The old per-row icon-button strip (title tooltip) is gone for custom actions.
    expect(list.content).not.toMatch(/title=\{t\('contact\.list\.archive'\)\}/)
  })

  it('renders header-scope custom actions next to the Create button', () => {
    const ps = pageSpecFixture({
      actions: [
        { code: 'create', scope: 'header', labelKey: 'list.create', permission: 'crm.directory.create', variant: 'primary' },
        { code: 'export', scope: 'header', labelKey: 'list.export', permission: 'crm.directory.read', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // The header actions wrapper WRAPS: without flex-wrap the buttons cannot stack
    // when the row runs out of room, and their labels break in two instead.
    expect(list.content).toMatch(/actions=\{[\s\S]*?<div className="flex flex-wrap items-center gap-2">/)
    // Export button uses the secondary variant style + Download icon
    expect(list.content).toMatch(/\{t\('contact\.list\.export'\)\}/)
    expect(list.content).toMatch(/Download/)
    // Header action handler does NOT take an item parameter
    expect(list.content).toMatch(/const handleExport = async \(\) => \{[\s\S]*?exportMutation\.mutateAsync\(\)/)
  })

  it('Priority+ header cluster: ≤ 2 promoted buttons at lg+, every action rides the HeaderActionsMenu', () => {
    const ps = pageSpecFixture({
      actions: [
        { code: 'create', scope: 'header', labelKey: 'list.create', permission: 'crm.directory.create', variant: 'primary' },
        { code: 'export', scope: 'header', labelKey: 'list.export', permission: 'crm.directory.read', variant: 'secondary' },
        { code: 'archive', scope: 'header', labelKey: 'list.archive', permission: 'crm.directory.update', variant: 'secondary' },
        { code: 'duplicate', scope: 'header', labelKey: 'list.duplicate', permission: 'crm.directory.create', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // The menu primitive is imported once header actions exist.
    expect(list.content).toMatch(/import \{ HeaderActionsMenu \} from '@\/components\/ui\/HeaderActionsMenu'/)
    // First two authored actions stay visible buttons, hidden below lg.
    expect(list.content).toMatch(/className="btn btn-secondary hidden lg:inline-flex"[\s\S]{0,200}\{t\('contact\.list\.export'\)\}/)
    expect(list.content).toMatch(/className="btn btn-secondary hidden lg:inline-flex"[\s\S]{0,200}\{t\('contact\.list\.archive'\)\}/)
    // The third action never gets a visible button — menu item only (the braced
    // `{t('…')}` form only exists as button JSX children; the menu carries the
    // unbraced `label: t('…')`).
    expect(list.content).not.toMatch(/\{t\('contact\.list\.duplicate'\)\}/)
    // Every action rides the menu; promoted ones flagged so the menu drops them at lg+.
    expect(list.content).toMatch(/\{ key: 'export',[\s\S]*?promoted: true,[\s\S]*?onClick: \(\) => \{ void handleExport\(\) \} \},/)
    expect(list.content).toMatch(/\{ key: 'archive',[\s\S]*?promoted: true,[\s\S]*?onClick: \(\) => \{ void handleArchive\(\) \} \},/)
    expect(list.content).toMatch(/\{ key: 'duplicate', label: t\('contact\.list\.duplicate'\), icon: <Copy className="w-4 h-4" \/>, permission: 'crm\.directory\.create', onClick: \(\) => \{ void handleDuplicate\(\) \} \},/)
  })

  it('Priority+ header cluster: primary-variant actions claim the visible budget first', () => {
    const ps = pageSpecFixture({
      actions: [
        { code: 'export', scope: 'header', labelKey: 'list.export', permission: 'crm.directory.read', variant: 'secondary' },
        { code: 'archive', scope: 'header', labelKey: 'list.archive', permission: 'crm.directory.update', variant: 'secondary' },
        { code: 'launchCampaign', scope: 'header', labelKey: 'list.launchCampaign', permission: 'crm.directory.execute', variant: 'primary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // The primary action is promoted (visible button, btn-primary) even though
    // it was authored last; the stable sort keeps export as the second slot and
    // overflows archive into the menu.
    expect(list.content).toMatch(/className="btn btn-primary hidden lg:inline-flex"[\s\S]{0,200}\{t\('contact\.list\.launchCampaign'\)\}/)
    expect(list.content).toMatch(/\{ key: 'launchCampaign',[\s\S]*?promoted: true/)
    expect(list.content).toMatch(/\{ key: 'export',[\s\S]*?promoted: true/)
    expect(list.content).not.toMatch(/\{ key: 'archive',[\s\S]{0,200}promoted: true/)
    expect(list.content).not.toMatch(/\{t\('contact\.list\.archive'\)\}/)
  })

  it('emits no HeaderActionsMenu when the page has no header custom action', () => {
    const files = generate(fixture({ pageSpec: pageSpecFixture(), views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    expect(list.content).not.toMatch(/HeaderActionsMenu/)
  })

  it('detail Priority+ cluster: promoted anchors on the button, overflowed anchors on the menu item (DEV-UI-032)', () => {
    const ps = pageSpecFixture({
      view: 'detail',
      filePath: 'src/pages/testv2/crm/directory/ContactDetailPage.tsx',
      actions: [
        { code: 'duplicate', scope: 'header', labelKey: 'detail.duplicate', permission: 'crm.directory.create', variant: 'secondary' },
        { code: 'archive', scope: 'header', labelKey: 'detail.archive', permission: 'crm.directory.update', variant: 'secondary' },
        { code: 'export', scope: 'header', labelKey: 'detail.export', permission: 'crm.directory.read', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['detail'], entityViews: ['list', 'detail', 'form'] }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!
    expect(detail.content).toMatch(/import \{ HeaderActionsMenu \} from '@\/components\/ui\/HeaderActionsMenu'/)
    // Promoted (visible budget): the data-testid rides the button.
    expect(detail.content).toMatch(/data-testid="detail-action-duplicate"/)
    expect(detail.content).toMatch(/data-testid="detail-action-archive"/)
    // Overflowed: the anchor rides the menu item's testId prop — never a second
    // DOM node with the same data-testid.
    expect(detail.content).not.toMatch(/data-testid="detail-action-export"/)
    expect(detail.content).toMatch(/\{ key: 'export',[\s\S]*?testId: 'detail-action-export', onClick: \(\) => \{ void handleExport\(\) \} \},/)
    // Edit + Delete keep their historical anchors untouched.
    expect(detail.content).toMatch(/data-testid="detail-action-edit"/)
    expect(detail.content).toMatch(/data-testid="detail-action-delete"/)
  })

  it('renders bulk-scope actions in a selection toolbar wired to DataTable selection', () => {
    const ps = pageSpecFixture({
      actions: [
        { code: 'create', scope: 'header', labelKey: 'list.create', permission: 'crm.directory.create', variant: 'primary' },
        {
          code: 'bulkArchive', scope: 'bulk', labelKey: 'list.bulkArchive',
          permission: 'crm.directory.update', payloadDto: 'BulkArchiveRequest',
          payloadParameters: [{ name: 'reason', type: 'text', required: true }],
        },
        { code: 'bulkDelete', scope: 'bulk', labelKey: 'list.bulkDelete', permission: 'crm.directory.delete' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // Controlled DataTable selection: state + selectable + selectedKeys + onSelectionChange
    expect(list.content).toMatch(/const \[selectedKeys, setSelectedKeys\] = useState<Set<string>>\(new Set\(\)\)/)
    expect(list.content).toMatch(/selectable/)
    expect(list.content).toMatch(/selectedKeys=\{selectedKeys\}/)
    expect(list.content).toMatch(/onSelectionChange=\{setSelectedKeys\}/)
    // Selection toolbar rendered only when rows are checked
    expect(list.content).toMatch(/selectedKeys\.size > 0 &&/)
    // Bulk WITH payload → opens a dialog, fires mutateAsync({ ids, payload })
    expect(list.content).toMatch(/const \[bulkArchiveDialogOpen, setBulkArchiveDialogOpen\] = useState\(false\)/)
    expect(list.content).toMatch(/const handleBulkArchive = \(\) => \{ setBulkArchiveDialogOpen\(true\) \}/)
    expect(list.content).toMatch(/bulkArchiveMutation\.mutateAsync\(\{ ids: \[\.\.\.selectedKeys\], payload: payload as never \}\)/)
    expect(list.content).toMatch(/import \{ CustomActionDialog \} from '@\/components\/ui\/CustomActionDialog'/)
    // Bulk WITHOUT payload → fires against the selection directly then clears it
    expect(list.content).toMatch(/const handleBulkDelete = async \(\) => \{[\s\S]*?bulkDeleteMutation\.mutateAsync\(\[\.\.\.selectedKeys\]\)[\s\S]*?setSelectedKeys\(new Set\(\)\)/)
  })

  it('renders a CustomActionDialog for a payload header action on detail AND form pages', () => {
    const ps = pageSpecFixture({
      actions: [
        {
          code: 'generateReport', scope: 'header', labelKey: 'detail.generateReport',
          permission: 'crm.directory.execute', payloadDto: 'GenerateReportRequest',
          payloadParameters: [{ name: 'year', type: 'number', required: true }],
        },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['detail', 'form'] }))
    for (const suffix of ['DetailPage.tsx', 'FormPage.tsx']) {
      const page = files.find((f) => f.path.endsWith(suffix))!
      expect(page.content, suffix).toMatch(/import \{ CustomActionDialog \} from '@\/components\/ui\/CustomActionDialog'/)
      expect(page.content, suffix).toMatch(/const \[generateReportDialogOpen, setGenerateReportDialogOpen\] = useState\(false\)/)
      expect(page.content, suffix).toMatch(/const handleGenerateReport = \(\) => \{ setGenerateReportDialogOpen\(true\) \}/)
      expect(page.content, suffix).toMatch(/generateReportMutation\.mutateAsync\(payload as never\)/)
      // A payload action must NOT fall back to the old mutateAsync(id) shape.
      expect(page.content, suffix).not.toMatch(/generateReportMutation\.mutateAsync\(id\)/)
    }
  })

  it('skips standard CRUD codes from custom actions iteration (no double-emit)', () => {
    const ps = pageSpecFixture({
      actions: [
        // 'edit' and 'delete' are standard CRUD — already hardcoded; skip
        { code: 'edit', scope: 'row', labelKey: 'list.edit', permission: 'crm.directory.update', variant: 'secondary' },
        { code: 'delete', scope: 'row', labelKey: 'list.delete', permission: 'crm.directory.delete', variant: 'danger' },
        // 'archive' is non-CRUD → renders
        { code: 'archive', scope: 'row', labelKey: 'list.archive', permission: 'crm.directory.update', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // No useEditContact import (CRUD codes are skipped from custom iteration)
    expect(list.content).not.toMatch(/useEditContact/)
    // archive IS imported as a custom action hook
    expect(list.content).toMatch(/useArchiveContact/)
    // useDeleteContact is the standard hardcoded import (appears in both
    // import statement AND in `useDelete${e}()` call — 2 occurrences total).
    // Custom-action iteration must NOT add a third reference.
    expect(list.content.match(/useDeleteContact/g)?.length).toBe(2)
  })

  it('flags a danger-variant row action with danger:true in the overflow menu', () => {
    const ps = pageSpecFixture({
      actions: [
        { code: 'reject', scope: 'row', labelKey: 'list.reject', permission: 'crm.directory.update', variant: 'danger' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // The danger variant is carried on the menu item (RowActionsMenu styles it with
    // the --error-* tokens); no more inline per-button className.
    expect(list.content).toMatch(/\{ key: 'reject',[\s\S]*?onClick: \(\) => \{ void handleReject\(item\) \}, danger: true \}/)
  })

  it('emits NO custom action artefacts when pageSpec.actions is empty (legacy)', () => {
    // The fixture pageSpec has no actions[] beyond a default 'create' header
    // (which is a standard CRUD code skipped from custom iteration).
    const files = generate(fixture({ pageSpec: pageSpecFixture(), views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // No extra hook imports beyond the standard CRUD ones
    expect(list.content).not.toMatch(/useArchive|useDuplicate|useApprove|useReject/)
    // No mutation declarations beyond `deleteMutation`
    expect(list.content).not.toMatch(/Mutation = use(?!Delete|Contacts)/)
    // No overflow menu when there are no custom row actions — the column is just Edit/Delete.
    expect(list.content).not.toMatch(/RowActionsMenu/)
  })
})

describe('scaffold-component / generate — list page custom actions kind:navigate', () => {
  it('emits a navigate(targetRoute) handler for a kind:navigate row action, no hook', () => {
    const ps = pageSpecFixture({
      actions: [
        // A kind:navigate row action must emit a navigate() handler (no hook,
        // no POST → no phantom 405). Target a NON-detail page so it survives the
        // row-nav dedup: a navigate-to-detail row action is dropped because
        // onRowClick already opens the detail.
        {
          code: 'history',
          kind: 'navigate',
          scope: 'row',
          labelKey: 'list.history',
          permission: 'crm.directory.read',
          targetRoute: 'routes.directory.history(item.id)',
        },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // NO hook import for the navigate action
    expect(list.content).not.toMatch(/useHistoryContact/)
    // NO mutation declaration
    expect(list.content).not.toMatch(/historyMutation/)
    // The handler navigates via React Router — synchronous, no mutateAsync
    expect(list.content).toMatch(/const handleHistory = \(item: ContactListDto\) => \{[\s\S]*?navigate\(routes\.directory\.history\(item\.id\)\)/)
    // The button still renders (PermissionGuard + onClick → handleHistory)
    expect(list.content).toMatch(/handleHistory\(item\)/)
  })

  it('emits a navigate(targetRoute) handler for a kind:navigate header action', () => {
    const ps = pageSpecFixture({
      actions: [
        {
          code: 'openHistory',
          kind: 'navigate',
          scope: 'header',
          labelKey: 'list.openHistory',
          permission: 'crm.directory.read',
          targetRoute: 'routes.directory.history()',
        },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // Synchronous handler — no `async`, no `await`
    expect(list.content).toMatch(/const handleOpenHistory = \(\) => \{[\s\S]*?navigate\(routes\.directory\.history\(\)\)/)
    expect(list.content).not.toMatch(/useOpenHistoryContact/)
    expect(list.content).not.toMatch(/openHistoryMutation/)
  })

  it('mixes kind:api and kind:navigate actions on the same page', () => {
    const ps = pageSpecFixture({
      actions: [
        // CRUD standard — skipped from custom iteration
        { code: 'create', scope: 'header', labelKey: 'list.create', permission: 'crm.directory.create', variant: 'primary' },
        // api-bound custom — needs hook + mutation
        { code: 'archive', kind: 'api', scope: 'row', labelKey: 'list.archive', permission: 'crm.directory.update', variant: 'secondary' },
        // navigate-bound custom — needs router only; non-detail target so it
        // survives the row-nav dedup (navigate-to-detail rows are dropped).
        { code: 'history', kind: 'navigate', scope: 'row', labelKey: 'list.history', permission: 'crm.directory.read', targetRoute: 'routes.directory.history(item.id)' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // api action: hook + mutation
    expect(list.content).toMatch(/useArchiveContact/)
    expect(list.content).toMatch(/archiveMutation\.mutateAsync\(item\.id\)/)
    // navigate action: NO hook, NO mutation, just navigate()
    expect(list.content).not.toMatch(/useHistoryContact/)
    expect(list.content).not.toMatch(/historyMutation/)
    expect(list.content).toMatch(/handleHistory = \(item: ContactListDto\) => \{[\s\S]*?navigate\(routes\.directory\.history\(item\.id\)\)/)
    // Both buttons reach the actions column
    expect(list.content).toMatch(/handleArchive\(item\)/)
    expect(list.content).toMatch(/handleHistory\(item\)/)
  })

  it('hook name follows endpoint when code != endpoint (override pattern)', () => {
    // The BA wants the UI label "Sync from PCE" but the backend route is the
    // legacy `sync-from-proconcept`. scaffold-api-client generates the hook
    // named after the endpoint so the request URL and the React Query key
    // stay aligned. scaffold-component MUST import the same name.
    const ps = pageSpecFixture({
      actions: [
        {
          code: 'syncFromPce',
          kind: 'api',
          scope: 'header',
          labelKey: 'list.syncFromPce',
          permission: 'crm.directory.update',
          endpoint: 'sync-from-proconcept',
        },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // Hook name derived from endpoint (the URL is the source of truth)
    expect(list.content).toMatch(/useSyncFromProconceptContact/)
    expect(list.content).toMatch(/syncFromProconceptMutation = useSyncFromProconceptContact\(\)/)
    expect(list.content).toMatch(/handleSyncFromPce = async \(\) => \{[\s\S]*?syncFromProconceptMutation\.mutateAsync\(\)/)
    // The button label still uses the BA labelKey (camelCase) — UI label stays
    // independent of the URL segment.
    expect(list.content).toMatch(/\{t\('contact\.list\.syncFromPce'\)\}/)
  })
})

describe('scaffold-component / generate — FK fields render as <EntityLookup>', () => {
  it('emits <EntityLookup> for a same-module FK (no dead per-target hook import)', () => {
    const files = generate(fixture({
      entity: 'Employee',
      module: 'hr',
      section: 'employees',
      views: ['form'], entityViews: ['list', 'form'],
      fields: [
        { name: 'firstName', type: 'string', required: true },
        {
          name: 'departmentId',
          type: 'guid',
          required: true,
          fkTo: { entity: 'Department', module: 'hr' },
        },
      ],
    }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // Import surface — EntityLookup for the EDIT control, plus the per-target
    // use{Entity}Lookup hook the READ-FIRST grid consumes to resolve the FK's
    // displayName (never the raw Guid). The hook import must be USED, not dead:
    // its LookupData is read by the section's read grid.
    expect(form.content).toMatch(/import \{ EntityLookup \} from '@\/components\/ui\/EntityLookup'/)
    expect(form.content).toMatch(/useDepartmentLookup/)
    expect(form.content).toMatch(/departmentIdLookupData\?\.items/)
    // FK field is rendered as <EntityLookup>, not <input>. The default lookup URL is
    // the target's NavRoute-resolved route /api/{module}/{section}/lookup (here the
    // fallback {module}.{plural} = hr.departments). The dead /api/v1/integration
    // literal is never emitted.
    expect(form.content).toMatch(
      /<EntityLookup\s+apiEndpoint="\/api\/hr\/departments\/lookup"\s+value=\{\(formData\.departmentId as string \| null\) \?\? null\}/,
    )
    expect(form.content).toMatch(/label=\{t\('employee\.form\.fields\.departmentId'\)\}/)
    // Non-FK fields still get the plain <input>
    expect(form.content).toMatch(/id="firstName"[\s\S]*?type="text"/)
    // FK field never gets a plain <input> with name/id ending in "Id"
    expect(form.content).not.toMatch(/<input[^>]*id="departmentId"/)
  })

  it('emits the required attribute on the EntityLookup when the FK is required', () => {
    const files = generate(fixture({
      entity: 'Employee',
      module: 'hr',
      section: 'employees',
      views: ['form'], entityViews: ['list', 'form'],
      fields: [
        { name: 'mgrId', type: 'guid', required: true, fkTo: { entity: 'Manager', module: 'hr' } },
      ],
    }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // The `required` attribute is present (no value — JSX boolean attribute shorthand)
    expect(form.content).toMatch(/<EntityLookup[\s\S]*?\brequired\b[\s\S]*?disabled=\{isPending\}/)
  })

  it('wires a Core FK with a non-standard endpoint (TenantOrganisation) via the selectItems adapter', () => {
    const files = generate(fixture({
      entity: 'Client',
      module: 'crm',
      section: 'clients',
      views: ['form'], entityViews: ['list', 'form'],
      fields: [
        { name: 'name', type: 'string', required: true },
        { name: 'organisationId', type: 'guid', required: false, fkTo: { entity: 'TenantOrganisation', module: 'core' } },
      ],
    }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // The org picker reads the combined references endpoint — there is no
    // /api/core/tenant-organisations/lookup (ref_Companies + its /lookup were dropped).
    expect(form.content).toContain('apiEndpoint="/api/administration/users/organization-references"')
    expect(form.content).not.toMatch(/\/api\/core\/tenant-organisations\/lookup/)
    // …and adapts the combined DTO to the {id,displayName} shape via selectItems.
    expect(form.content).toContain('selectItems={(r) =>')
    expect(form.content).toContain('.companies')
  })

  it('a list column for a non-standard Core FK (TenantOrganisation) emits NO dangling use<E>Lookup import', () => {
    const files = generate(fixture({
      entity: 'Client',
      module: 'crm',
      section: 'clients',
      views: ['list'],
      fields: [
        { name: 'name', type: 'string', required: true },
        { name: 'organisationId', type: 'guid', required: false, fkTo: { entity: 'TenantOrganisation', module: 'core' } },
      ],
    }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // No use<E>Lookup hook exists for a Core target → the list must neither import nor call it.
    expect(list.content).not.toMatch(/useTenantOrganisationLookup/)
  })

  it('omits the EntityLookup import when no FK is declared (legacy form unchanged)', () => {
    const files = generate(fixture()) // no fkTo in fixture fields
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    expect(form.content).not.toMatch(/EntityLookup/)
    expect(form.content).not.toMatch(/use[A-Z]\w*Lookup/)
  })

  it('honours a custom apiEndpoint override (cross-module / Core)', () => {
    const files = generate(fixture({
      entity: 'Demand',
      module: 'requests',
      section: 'demands',
      views: ['form'], entityViews: ['list', 'form'],
      fields: [
        {
          name: 'requesterUserId',
          type: 'guid',
          required: true,
          currentUserFk: true,
          fkTo: { entity: 'User', module: 'core', apiEndpoint: '/api/core/users/lookup' },
        },
      ],
    }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    expect(form.content).toMatch(/apiEndpoint="\/api\/core\/users\/lookup"/)
    // A FK flagged currentUserFk gets a one-click "Me" button bound to useAuth;
    // the read-first grid additionally resolves the label via the per-target
    // lookup hook (consumed, not dead).
    expect(form.content).toMatch(/useUserLookup/)
    expect(form.content).toMatch(/requesterUserIdLookupData\?\.items/)
    expect(form.content).toMatch(/import \{ useAuth \} from '@\/business\/auth\/useAuth'/)
    expect(form.content).toMatch(/user\?\.id \?\? ''/)
    expect(form.content).toMatch(/t\('demand\.form\.me'/)
  })

  it('imports useAuth exactly once even with multiple user FKs (no per-target hook)', () => {
    const files = generate(fixture({
      entity: 'Assignment',
      module: 'hr',
      section: 'assignments',
      views: ['form'], entityViews: ['list', 'form'],
      fields: [
        { name: 'fromEmployeeId', type: 'guid', required: true, currentUserFk: true, fkTo: { entity: 'Employee', module: 'hr' } },
        { name: 'toEmployeeId', type: 'guid', required: true, currentUserFk: true, fkTo: { entity: 'Employee', module: 'hr' } },
      ],
    }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // Both FKs are flagged currentUserFk → the "Me" shortcut needs useAuth, imported ONCE.
    const matches = form.content.match(/import \{ useAuth \}/g) ?? []
    expect(matches.length).toBe(1)
    // Two FKs to the SAME target: the read-grid lookup hook imports dedupe by
    // entity (one import line) while each field keeps its own LookupData.
    const lookupImports = form.content.match(/import \{ useEmployeeLookup \}/g) ?? []
    expect(lookupImports.length).toBe(1)
    expect(form.content).toMatch(/fromEmployeeIdLookupData\?\.items/)
    expect(form.content).toMatch(/toEmployeeIdLookupData\?\.items/)
    // Both FK fields are rendered.
    expect(form.content).toMatch(/label=\{t\('assignment\.form\.fields\.fromEmployeeId'\)\}/)
    expect(form.content).toMatch(/label=\{t\('assignment\.form\.fields\.toEmployeeId'\)\}/)
  })

  it('a FK lookup uses fkTo.navRoute when set (the target\'s NavRoute-resolved route)', () => {
    const files = generate(fixture({
      entity: 'Order', module: 'sales', section: 'orders', views: ['form'], entityViews: ['list', 'form'],
      fields: [{ name: 'clientId', type: 'guid', required: true, fkTo: { entity: 'Client', module: 'crm', navRoute: 'repertoire.clients' } }],
    }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // navRoute wins over the heuristic fallback → /api/{targetModule}/{targetSection}/lookup.
    expect(form.content).toContain('apiEndpoint="/api/repertoire/clients/lookup"')
    expect(form.content).not.toMatch(/apiEndpoint="\/api\/v1\/integration\//)
  })

  it('default FK lookup URL falls back to the target module\'s NavRoute path /api/{module}/{plural}/lookup', () => {
    const files = generate(fixture({
      entity: 'Employee', module: 'hr', section: 'employees', views: ['form'], entityViews: ['list', 'form'],
      fields: [{ name: 'departmentId', type: 'guid', required: true, fkTo: { entity: 'Department', module: 'hr' } }],
    }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // No navRoute/apiEndpoint on fkTo → best-effort fallback `{module}.{plural}` via
    // buildNavApiPath. When the section == the entity plural (common), it matches the
    // real route; audit-dev-wire flags it otherwise.
    const expected = `${buildNavApiPath('hr.departments')}/lookup`
    expect(expected).toBe('/api/hr/departments/lookup')
    expect(form.content).toContain(`apiEndpoint="${expected}"`)
    // The dead /api/v1/integration/... literal (the platform rewrote it away) must never appear.
    expect(form.content).not.toMatch(/apiEndpoint="\/api\/v1\/integration\//)
  })

  it('a cross-module FK resolves to the TARGET module\'s NavRoute path', () => {
    const files = generate(fixture({
      entity: 'Order', module: 'sales', section: 'orders', views: ['form'], entityViews: ['list', 'form'],
      fields: [{ name: 'productId', type: 'guid', required: true, fkTo: { entity: 'Product', module: 'catalog' } }],
    }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // The lookup lives on the TARGET's controller → its module is in the URL.
    expect(form.content).toContain('apiEndpoint="/api/catalog/products/lookup"')
    expect(form.content).not.toMatch(/apiEndpoint="\/api\/v1\/integration\//)
  })

  it('a Core FK without an explicit apiEndpoint falls back to /api/core/{plural}/lookup', () => {
    const files = generate(fixture({
      entity: 'Demand', module: 'requests', section: 'demands', views: ['form'], entityViews: ['list', 'form'],
      fields: [{ name: 'ownerUserId', type: 'guid', required: true, fkTo: { entity: 'User', module: 'core' } }],
    }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    expect(form.content).toContain('apiEndpoint="/api/core/users/lookup"')
  })

  it('uses fkTo.plural for irregular plurals; otherwise pluralises heuristically (Category → categories)', () => {
    const heuristic = generate(fixture({
      entity: 'Task', module: 'todo', section: 'tasks', views: ['form'], entityViews: ['list', 'form'],
      fields: [{ name: 'categoryId', type: 'guid', required: true, fkTo: { entity: 'Category', module: 'todo' } }],
    })).find((f) => /FormPage\.tsx$/.test(f.path))!
    // Category → Categories → categories (NOT the naive `categorys`).
    expect(heuristic.content).toContain('apiEndpoint="/api/todo/categories/lookup"')

    const explicit = generate(fixture({
      entity: 'Job', module: 'ops', section: 'jobs', views: ['form'], entityViews: ['list', 'form'],
      fields: [{ name: 'statusId', type: 'guid', required: true, fkTo: { entity: 'Status', module: 'ops', plural: 'Statuses' } }],
    })).find((f) => /FormPage\.tsx$/.test(f.path))!
    expect(explicit.content).toContain('apiEndpoint="/api/ops/statuses/lookup"')
  })

  it('never emits a raw <input name="...Id"> or <select value={...Id}> when fkTo is present (DEV-UI-022 contract)', () => {
    const files = generate(fixture({
      entity: 'Order',
      module: 'sales',
      section: 'orders',
      views: ['form'], entityViews: ['list', 'form'],
      fields: [
        { name: 'clientId', type: 'guid', required: true, fkTo: { entity: 'Client', module: 'crm' } },
      ],
    }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // The patterns DEV-UI-022 will reject
    expect(form.content).not.toMatch(/<input[^>]*\b(name|id)\s*=\s*["']clientId["']/)
    expect(form.content).not.toMatch(/<select[^>]*value=\{[^}]*clientId/)
  })
})

// ─── Form page custom actions ──────────────────────────────────────────

describe('scaffold-component / generate — form page custom actions', () => {
  it('renders header-scoped custom actions on form page, guarded by isEdit', () => {
    const ps = pageSpecFixture({
      view: 'form',
      filePath: 'src/pages/testv2/crm/directory/ContactFormPage.tsx',
      actions: [
        { code: 'create', scope: 'header', labelKey: 'form.create', permission: 'crm.directory.create', variant: 'primary' },
        { code: 'duplicate', scope: 'header', labelKey: 'form.actions.duplicate', permission: 'crm.directory.create', variant: 'secondary' },
        { code: 'toggle-actif', scope: 'header', labelKey: 'form.actions.toggle-actif', permission: 'crm.directory.execute', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['form'] }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // Hook imports for api-bound actions (create is CRUD — skipped)
    expect(form.content).toMatch(/useDuplicateContact/)
    expect(form.content).toMatch(/useToggleActifContact/)
    // Mutation declarations
    expect(form.content).toMatch(/duplicateMutation = useDuplicateContact\(\)/)
    expect(form.content).toMatch(/toggleActifMutation = useToggleActifContact\(\)/)
    // Non-payload header actions call the header hook with no argument (matches
    // the api-client () signature; passing `id` to a bodyless header endpoint was
    // a latent arity mismatch that never compiled).
    expect(form.content).toMatch(/const handleDuplicate = async \(\) => \{[\s\S]*?await duplicateMutation\.mutateAsync\(\)/)
    expect(form.content).toMatch(/const handleToggleActif = async \(\) => \{[\s\S]*?await toggleActifMutation\.mutateAsync\(\)/)
    // actions prop guarded by isEdit
    expect(form.content).toMatch(/actions=\{isEdit \?/)
    // PermissionGuard with 4-seg permission
    expect(form.content).toMatch(/<PermissionGuard permission="crm\.directory\.create">[\s\S]*?handleDuplicate/)
    expect(form.content).toMatch(/<PermissionGuard permission="crm\.directory\.execute">[\s\S]*?handleToggleActif/)
  })

  it('renders navigate-kind form action without hooks', () => {
    const ps = pageSpecFixture({
      view: 'form',
      filePath: 'src/pages/testv2/crm/directory/ContactFormPage.tsx',
      actions: [
        {
          code: 'openHistory',
          kind: 'navigate',
          scope: 'header',
          labelKey: 'form.actions.openHistory',
          permission: 'crm.directory.read',
          targetRoute: 'routes.directory.history()',
        },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['form'] }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // NO hook import or mutation for navigate action
    expect(form.content).not.toMatch(/useOpenHistoryContact/)
    expect(form.content).not.toMatch(/openHistoryMutation/)
    // Synchronous navigate handler
    expect(form.content).toMatch(/const handleOpenHistory = \(\) => \{[\s\S]*?navigate\(routes\.directory\.history\(\)\)/)
  })

  it('emits NO action artefacts on form page when no custom actions (backward compat)', () => {
    const files = generate(fixture({ views: ['form'] }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // No custom hook imports
    expect(form.content).not.toMatch(/useArchive|useDuplicate|useToggle/)
    // No actions prop on PageTemplate
    expect(form.content).not.toMatch(/actions=\{/)
    // Standard save/cancel still present
    expect(form.content).toMatch(/form\.cancel/)
    expect(form.content).toMatch(/form\.submitCreate/)
  })

  it('ignores row-scoped actions on form page (forms have no rows)', () => {
    const ps = pageSpecFixture({
      view: 'form',
      filePath: 'src/pages/testv2/crm/directory/ContactFormPage.tsx',
      actions: [
        { code: 'archive', scope: 'row', labelKey: 'list.archive', permission: 'crm.directory.update', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['form'] }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!
    // Row-scoped action MUST NOT appear on the form page
    expect(form.content).not.toMatch(/useArchiveContact/)
    expect(form.content).not.toMatch(/handleArchive/)
    expect(form.content).not.toMatch(/actions=\{/)
  })
})

// ─── Detail page custom actions ────────────────────────────────────────

describe('scaffold-component / generate — detail page custom actions', () => {
  it('renders custom header actions alongside the Edit button on detail page', () => {
    const ps = pageSpecFixture({
      view: 'detail',
      filePath: 'src/pages/testv2/crm/directory/ContactDetailPage.tsx',
      actions: [
        { code: 'duplicate', scope: 'header', labelKey: 'detail.actions.duplicate', permission: 'crm.directory.create', variant: 'secondary' },
        { code: 'toggle-actif', scope: 'header', labelKey: 'detail.actions.toggle-actif', permission: 'crm.directory.execute', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['detail'] }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!
    // Hook imports for custom actions
    expect(detail.content).toMatch(/useDuplicateContact/)
    expect(detail.content).toMatch(/useToggleActifContact/)
    // The Edit button is still present alongside custom actions
    expect(detail.content).toMatch(/detail\.edit/)
    // Custom action buttons appear inside the actions div
    expect(detail.content).toMatch(/handleDuplicate/)
    expect(detail.content).toMatch(/handleToggleActif/)
    // Non-payload header actions call the header hook with no argument.
    expect(detail.content).toMatch(/const handleDuplicate = async \(\) => \{[\s\S]*?await duplicateMutation\.mutateAsync\(\)/)
  })

  it('detail page with no custom actions still renders Edit button', () => {
    const files = generate(fixture({ views: ['detail'] }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!
    expect(detail.content).toMatch(/detail\.edit/)
    expect(detail.content).not.toMatch(/useDuplicate|useToggle|useArchive/)
  })

  // DEV-UI-032 — detail-page action completeness. The detail page must carry
  // anchored Edit + Delete buttons + a detail-action-<code> anchor per header
  // custom action, so the audit + the smoke/UAT driver can find them.
  it('emits detail-action-edit + detail-action-delete anchors and wires Delete', () => {
    const files = generate(fixture({ views: ['detail'] }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!
    expect(detail.content).toContain('data-testid="detail-action-edit"')
    expect(detail.content).toContain('data-testid="detail-action-delete"')
    // Delete is fully wired: hook import, mutation decl, handler, i18n key, icon.
    expect(detail.content).toMatch(/useDeleteContact/)
    expect(detail.content).toContain('const deleteMutation = useDeleteContact()')
    expect(detail.content).toMatch(/const handleDelete = async \(\) => \{[\s\S]*?await deleteMutation\.mutateAsync\(id\)/)
    expect(detail.content).toMatch(/detail\.delete/)
    expect(detail.content).toMatch(/import \{ Loader2, Pencil, Trash2, FileText/)
  })

  it('anchors each header custom action with data-testid="detail-action-<code>"', () => {
    const ps = pageSpecFixture({
      view: 'detail',
      filePath: 'src/pages/testv2/crm/directory/ContactDetailPage.tsx',
      actions: [
        { code: 'duplicate', scope: 'header', labelKey: 'detail.actions.duplicate', permission: 'crm.directory.create', variant: 'secondary' },
        { code: 'toggle-actif', scope: 'header', labelKey: 'detail.actions.toggle-actif', permission: 'crm.directory.execute', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['detail'], entityViews: ['list', 'detail'] }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!
    expect(detail.content).toContain('data-testid="detail-action-duplicate"')
    expect(detail.content).toContain('data-testid="detail-action-toggle-actif"')
  })

  it('does NOT leak detail-action-* anchors into the list page', () => {
    const ps = pageSpecFixture({
      view: 'list',
      filePath: 'src/pages/testv2/crm/directory/ContactListPage.tsx',
      actions: [
        { code: 'duplicate', scope: 'header', labelKey: 'list.actions.duplicate', permission: 'crm.directory.create', variant: 'secondary' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    expect(list.content).not.toContain('detail-action-')
  })
})

// ─── Tab strip: delegated to the TabStrip primitive, guards DEV-UI-027 ─────

describe('scaffold-component / generate — detail page tab strip (DEV-UI-027)', () => {
  function tabbedDetailContent(): string {
    const ps = pageSpecFixture({
      view: 'detail',
      filePath: 'src/pages/testv2/crm/directory/ContactDetailPage.tsx',
      tabs: [
        { key: 'general', labelKey: 'detail.tabs.general', fields: ['firstName', 'lastName'] },
        { key: 'coords', labelKey: 'detail.tabs.coords', fields: ['email'] },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['detail'], entityViews: ['list', 'detail'] }))
    return files.find((f) => /DetailPage\.tsx$/.test(f.path))!.content
  }

  it('delegates the strip container to the TabStrip primitive (arrows on overflow, no scrollbar)', () => {
    const c = tabbedDetailContent()
    // The two-layer divider + -mb-px contract AND the scroll/arrow mechanics
    // live inside TabStrip (scaffold-ui-primitives); the page only mounts it.
    expect(c).toContain("import { TabStrip } from '@/components/ui/TabStrip'")
    expect(c).toMatch(/<TabStrip label=\{t\('contact\.detail\.tabs\.label', \{ defaultValue: 'Sections' \}\)\} activeKey=\{activeTab\}>/)
    // No inline strip container left in the page.
    expect(c).not.toMatch(/<div className="border-b border-\[var\(--border-color\)\] mb-6">/)
    expect(c).not.toMatch(/overflow-x-auto" role="tablist"/)
  })

  it('NEVER emits `flex` and `border-b border-[var(--border-color)]` on the same tab element (the single-layer bug)', () => {
    const c = tabbedDetailContent()
    // The faulty single-layer signature that produced the doubled/misaligned underline.
    expect(c).not.toMatch(/flex gap-1 border-b border-\[var\(--border-color\)\]/)
    // The strip container MUST be the primitive whenever a tab strip is rendered.
    expect(c).toContain('<TabStrip')
  })

  it('tab buttons mirror the canonical UnderlinedTabs (accent-600 active, text-secondary inactive, border-b-2)', () => {
    const c = tabbedDetailContent()
    expect(c).toContain('flex-shrink-0 flex items-center gap-2 px-4 py-2 text-sm font-medium whitespace-nowrap border-b-2')
    // Active tab: accent-600 (NOT the old accent-500).
    expect(c).toContain('border-[var(--color-accent-600)] text-[var(--color-accent-600)]')
    expect(c).not.toContain('border-[var(--color-accent-500)] text-[var(--color-accent-500)]')
    // Inactive tab text: secondary (NOT the old text-muted).
    expect(c).toMatch(/border-transparent text-\[var\(--text-secondary\)\] hover:text-\[var\(--text-primary\)\]/)
  })

  it('wires the ARIA tab / tabpanel contract (tablist role lives inside TabStrip)', () => {
    const c = tabbedDetailContent()
    expect(c).toMatch(/<TabStrip /)
    expect(c).toMatch(/role="tab"/)
    expect(c).toMatch(/role="tabpanel"/)
    expect(c).toContain("aria-selected={activeTab === 'general'}")
    expect(c).toContain('id="tab-general"')
    expect(c).toContain('aria-controls="tabpanel-general"')
    expect(c).toContain('id="tabpanel-general"')
    expect(c).toContain('aria-labelledby="tab-general"')
  })
})

// ─── Detail tabs: pagespec camelCase × entité.md PascalCase (§17) ─────

describe('scaffold-component / generate — detail tab fields casing', () => {
  // The real pipeline feeds fields[] with entité.md PascalCase names while the
  // pagespec tabs[] carry camelCase keys. A strict membership compare shipped
  // every tabpanel with an empty <dl> (77 declared fields, zero rendered) —
  // the resolution is camel-insensitive on both sides.
  const pascalFields = [
    { name: 'FirstName', type: 'string', required: true },
    { name: 'MobilePhone', type: 'string', required: false },
    { name: 'DepartmentId', type: 'guid', required: false, fkTo: { entity: 'Department', module: 'core', apiEndpoint: '/api/core/departments/lookup' } },
    { name: 'Email', type: 'string', required: false },
  ] as ScaffoldComponentInput['fields']
  const detailOf = (tabs: object[]) => {
    const ps = pageSpecFixture({
      view: 'detail',
      filePath: 'src/pages/testv2/crm/directory/ContactDetailPage.tsx',
      tabs,
    } as Partial<PageSpecMin>)
    const files = generate(fixture({ fields: pascalFields, pageSpec: ps, views: ['detail'], entityViews: ['list', 'detail'] }))
    return files.find((f) => /DetailPage\.tsx$/.test(f.path))!.content
  }

  it('camelCase tab fields resolve PascalCase fields[] — every declared dt/dd renders', () => {
    const c = detailOf([
      { key: 'identite', labelKey: 'detail.tabs.identite', fields: ['firstName', 'mobilePhone'] },
      { key: 'rattachement', labelKey: 'detail.tabs.rattachement', fields: ['departmentId'] },
    ])
    expect(c).toContain("t('contact.detail.fields.firstName')")
    expect(c).toContain("t('contact.detail.fields.mobilePhone')")
    expect(c).toContain("t('contact.detail.fields.departmentId')")
    // No tabpanel ships an empty grid — the §17 regression signature.
    expect(c).not.toMatch(/<dl className="grid grid-cols-1 md:grid-cols-2 gap-x-6 gap-y-4">\s*<\/dl>/)
  })

  it('a field in NO tab renders nowhere and emits NO FK lookup hook (dead binding)', () => {
    const c = detailOf([
      { key: 'identite', labelKey: 'detail.tabs.identite', fields: ['firstName', 'mobilePhone', 'email'] },
    ])
    expect(c).not.toContain('detail.fields.departmentId')
    expect(c).not.toContain('departmentIdLookupData')
    expect(c).not.toContain('useDepartmentLookup')
  })

  it('a FK inside a tab keeps its lookup hook and consumes it in the dd', () => {
    const c = detailOf([
      { key: 'rattachement', labelKey: 'detail.tabs.rattachement', fields: ['departmentId'] },
    ])
    expect(c).toContain('useDepartmentLookup')
    expect(c).toMatch(/departmentIdLookupData\?\.items/)
  })
})

// ─── Heuristic: "open" row action without explicit kind → navigate ─────

describe('scaffold-component / generate — open action heuristic', () => {
  it('drops a kind-less row "open" as redundant (navigate to detail = onRowClick), never a POST', () => {
    const ps = pageSpecFixture({
      actions: [
        { code: 'create', scope: 'header', labelKey: 'list.create', permission: 'crm.directory.create', variant: 'primary' },
        { code: 'open', scope: 'row', labelKey: 'list.actions.open', permission: 'crm.directory.read' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // The heuristic still classifies a kind-less row "open" as navigate (never an
    // API POST → no 405), but since it would just re-open the detail it is dropped.
    expect(list.content).not.toMatch(/useOpenContact/)
    expect(list.content).not.toMatch(/openMutation/)
    expect(list.content).not.toMatch(/handleOpen\b/)
    expect(list.content).not.toMatch(/<ExternalLink\b/)
    // onRowClick is the single detail affordance.
    expect(list.content).toMatch(/onRowClick=\{\(item\) => navigate\(routes\.directory\.detail\(item\.id\)\)\}/)
  })

  it('respects explicit kind:api on "open" (override heuristic)', () => {
    const ps = pageSpecFixture({
      actions: [
        { code: 'open', kind: 'api', scope: 'row', labelKey: 'list.actions.open', permission: 'crm.directory.execute' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    expect(list.content).toMatch(/useOpenContact/)
    expect(list.content).toMatch(/openMutation\.mutateAsync\(item\.id\)/)
  })

  it('drops a row navigate action with no explicit target (defaults to detail = redundant)', () => {
    const ps = pageSpecFixture({
      actions: [
        { code: 'view-report', kind: 'navigate', scope: 'row', labelKey: 'list.actions.view-report', permission: 'crm.directory.read' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // No targetRoute → the legacy default was routes.<section>.detail, which
    // onRowClick already covers → the button is dropped (not rendered).
    expect(list.content).not.toMatch(/handleViewReport/)
    // onRowClick remains the single detail affordance.
    expect(list.content).toMatch(/onRowClick=\{\(item\) => navigate\(routes\.directory\.detail\(item\.id\)\)\}/)
  })
})

// ─── Filter q → fused into the global search box ───────────────────────

describe('scaffold-component / generate — filter q cross-field search', () => {
  it('fuses a "q" text filter into the global search box (no dead field input)', () => {
    const ps = pageSpecFixture({
      filters: [
        { field: 'q', labelKey: 'list.filters.q', control: 'text' },
        { field: 'estActif', labelKey: 'list.filters.estActif', control: 'boolean' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // No per-field input, state entry or matcher for 'q' — the global search
    // box already covers it (DataTable searchTerm client filter). The old
    // rendering emitted a dead duplicate input filtering item['q'].
    expect(list.content).not.toMatch(/filters\['q'\]/)
    expect(list.content).not.toMatch(/onFilterChange\(\s*'q'/)
    // The remaining boolean filter keeps the client-filtered path alive.
    expect(list.content).toMatch(/onFilterChange\('estActif'/)
    expect(list.content).toMatch(/value=\{search\}/)
  })

  it('Bug 4 (superseded) — no in-memory filter matchers, and never a bare single-cast', () => {
    // The client-side matcher block (the historical home of every
    // `as unknown as Record<string, unknown>` cast) is GONE with the
    // client-filtered path: filters ride the server on both strata. The
    // defence-in-depth on the cast shape stays for anything that remains.
    const ps = pageSpecFixture({
      filters: [
        { field: 'q', labelKey: 'list.filters.q', control: 'text' },
        { field: 'estActif', labelKey: 'list.filters.estActif', control: 'boolean' },
        { field: 'createdAt', labelKey: 'list.filters.createdAt', control: 'date-range' },
        { field: 'category', labelKey: 'list.filters.category', control: 'text' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    // No single-cast occurrence anywhere.
    expect(list.content).not.toMatch(/[^n] as Record<string, unknown>/)
    // No in-memory filter walk at all — the list reads the server page as-is.
    expect(list.content).not.toMatch(/items\.filter\(\(item\)/)
    expect(list.content).toMatch(/const filtered = data\?\.items \?\? \[\]/)
    // The filters reach the hook args instead.
    expect(list.content).toMatch(/category: debouncedFilters\['category'\] \|\| undefined/)
  })
})

// ─── Bug 9 — fieldToCamel on headerField in DetailPage ───────────────

describe('scaffold-component / generate — Bug 9 (header field normalised to camelCase)', () => {
  // Reproducer: BA pagespec declared the detail header field as `Numero`
  // (PascalCase). The generated DemandeDetailPage.tsx emitted
  // `data.Numero` while the DTO serialises camelCase `numero` → TS2551
  // "Property 'Numero' does not exist on type 'DemandeDetailDto'. Did you mean
  // 'numero'?" (Typescript actually suggests the correct casing.)
  it('headerTitle uses camelCase field accessor even when BA field name is PascalCase', () => {
    const files = generate(fixture({
      fields: [
        { name: 'Numero', type: 'string', labelKey: 'detail.fields.numero' },
        { name: 'Status', type: 'string', labelKey: 'detail.fields.status' },
      ],
      views: ['detail'], entityViews: ['list', 'detail'],
    }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!
    expect(detail.content).toMatch(/data\.numero/)
    expect(detail.content).not.toMatch(/data\.Numero/)
  })

  it('normalises kebab-style field names too (defence-in-depth)', () => {
    // Defensive : even though BA convention is camelCase or PascalCase, ensure
    // the normaliser handles odd shapes without leaking into the page.
    const files = generate(fixture({
      fields: [
        { name: 'CreatedAt', type: 'datetime', labelKey: 'detail.fields.createdAt' },
      ],
      views: ['detail'], entityViews: ['list', 'detail'],
    }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!
    expect(detail.content).toMatch(/data\.createdAt/)
    expect(detail.content).not.toMatch(/data\.CreatedAt/)
  })
})

// ─── Detail date fields — platform display settings ───────────────────

describe('scaffold-component / generate — detail date fields formatted through the display settings', () => {
  it('renders date fields with formatDate, datetime fields with formatDateTime, and imports both', () => {
    const files = generate(fixture({
      fields: [
        { name: 'name', type: 'string', required: true },
        { name: 'startDate', type: 'date', labelKey: 'detail.fields.startDate' },
        { name: 'closedAt', type: 'datetime', labelKey: 'detail.fields.closedAt' },
      ],
      views: ['detail'], entityViews: ['list', 'detail'],
    }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!
    expect(detail.content).toMatch(/\{formatDate\(data\.startDate\)\}/)
    expect(detail.content).toMatch(/\{formatDateTime\(data\.closedAt\)\}/)
    expect(detail.content).toMatch(/import \{ Slot, formatDate, formatDateTime \} from '@atlashub\/smartstack'/)
    // The ISO string never renders raw for a date field.
    expect(detail.content).not.toMatch(/String\(data\.startDate/)
  })

  it('a detail without date fields keeps the bare package import', () => {
    const files = generate(fixture({
      fields: [{ name: 'name', type: 'string', required: true }],
      views: ['detail'], entityViews: ['list', 'detail'],
    }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!
    expect(detail.content).toMatch(/import \{ Slot \} from '@atlashub\/smartstack'/)
    expect(detail.content).not.toMatch(/formatDate/)
  })
})

/**
 * The cards representation carries its own compact pager, whose prev/next
 * buttons legitimately use chevrons. Row-ACTION icon assertions must not trip
 * over them, so strip that branch first.
 */
function withoutCardsBranch(content: string): string {
  const start = content.indexOf("viewMode === 'cards' ? (")
  if (start === -1) return content
  const end = content.indexOf('<ResponsiveDataTable', start)
  return end === -1 ? content.slice(0, start) : content.slice(0, start) + content.slice(end)
}

// ─── Icon mapping ─────────────────────────────────────────────────────

describe('scaffold-component / generate — action icon mapping', () => {
  it('maps "open" → ExternalLink, "set-availability" → CalendarCheck, unknown → kind-aware fallback (never Circle nor ChevronRight)', () => {
    const ps = pageSpecFixture({
      actions: [
        // 'open' as an explicit non-detail navigate so it survives the row-nav
        // dedup and still exercises the open→ExternalLink icon mapping.
        { code: 'open', kind: 'navigate', scope: 'row', labelKey: 'list.actions.open', permission: 'crm.directory.read', targetRoute: 'routes.directory.history(item.id)' },
        { code: 'set-availability', kind: 'api', scope: 'row', labelKey: 'list.actions.set-availability', permission: 'crm.directory.update' },
        { code: 'some-unknown-action', kind: 'api', scope: 'row', labelKey: 'list.actions.unknown', permission: 'crm.directory.execute' },
        { code: 'some-unknown-target', kind: 'navigate', scope: 'row', labelKey: 'list.actions.unknownNav', permission: 'crm.directory.read', targetRoute: 'routes.directory.history(item.id)' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    expect(list.content).toMatch(/<ExternalLink className="w-4 h-4"/)
    expect(list.content).toMatch(/<CalendarCheck className="w-4 h-4"/)
    // Unknown codes fall back by KIND — Zap (api, "does something") /
    // ArrowUpRight (navigate, "takes you somewhere") — never the meaningless
    // Circle ring, never the navigation-looking chevron that produced the
    // bogus ">" buttons.
    expect(list.content).toMatch(/<Zap className="w-4 h-4"/)
    expect(list.content).toMatch(/<ArrowUpRight className="w-4 h-4"/)
    expect(list.content).not.toMatch(/<Circle className="w-4 h-4"/)
    expect(withoutCardsBranch(list.content)).not.toMatch(/<ChevronRight className="w-4 h-4"/)
  })

  it('resolves free-form business codes through the keyword net (verbs first, diacritics stripped, nouns behind)', () => {
    // The AtlasHub portfolio header: none of these codes sits in the exact
    // table, all must resolve through diacritic-stripped keyword stems instead
    // of shipping the bare Circle ring. Verb stems outrank noun stems, so
    // constater* → ClipboardCheck even though échéance also matches.
    const ps = pageSpecFixture({
      actions: [
        { code: 'constaterEcheances', kind: 'api', scope: 'header', labelKey: 'list.actions.constaterEcheances', permission: 'crm.directory.execute' },
        { code: 'pipelineDesPropositions', kind: 'navigate', scope: 'header', labelKey: 'list.actions.pipeline', permission: 'crm.directory.read', targetRoute: 'routes.directory.list()' },
        { code: 'openRoleCostRates', kind: 'navigate', scope: 'header', labelKey: 'list.actions.costRates', permission: 'crm.directory.read', targetRoute: 'routes.directory.list()' },
        // Accented code — exercises the NFD diacritic strip before tokenising.
        { code: 'suiviEchéances', kind: 'api', scope: 'bulk', labelKey: 'list.actions.suiviEcheances', permission: 'crm.directory.execute' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    expect(list.content).toMatch(/<ClipboardCheck className="w-4 h-4"/)
    expect(list.content).toMatch(/<Workflow className="w-4 h-4"/)
    expect(list.content).toMatch(/<Coins className="w-4 h-4"/)
    expect(list.content).toMatch(/<CalendarClock className="w-4 h-4"/)
    expect(list.content).not.toMatch(/<Circle className="w-4 h-4"/)
  })

  it('resolves camelCase multi-word action codes to their icon (kebab-map normalisation)', () => {
    // The PRD/pagespec emits camelCase codes (dashes are forbidden in `code`); the
    // ICON_FOR_CODE keys are kebab. Before normalisation these all fell back to the
    // ChevronRight ">" glyph — the reported bug. They must now resolve to real icons.
    const ps = pageSpecFixture({
      actions: [
        { code: 'toggleActif', kind: 'api', scope: 'row', labelKey: 'list.actions.toggleActif', permission: 'crm.directory.update' },
        { code: 'mapToPce', kind: 'api', scope: 'row', labelKey: 'list.actions.mapToPce', permission: 'crm.directory.update' },
        { code: 'syncFromPce', kind: 'api', scope: 'row', labelKey: 'list.actions.syncFromPce', permission: 'crm.directory.update' },
      ],
    })
    const files = generate(fixture({ pageSpec: ps, views: ['list'] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!
    expect(list.content).toMatch(/<ToggleRight className="w-4 h-4"/)
    expect(list.content).toMatch(/<ArrowRightLeft className="w-4 h-4"/)
    expect(list.content).toMatch(/<RefreshCw className="w-4 h-4"/)
    // No fallback glyphs — every code resolved.
    expect(withoutCardsBranch(list.content)).not.toMatch(/<ChevronRight className="w-4 h-4"/)
    expect(list.content).not.toMatch(/<Circle className="w-4 h-4"/)
  })
})

// ─── #6 — custom-action payload dialogs ─────────────────────────────────

describe('scaffold-component / generate — custom-action payload dialogs (#6)', () => {
  const psWithPayloadActions = () => pageSpecFixture({
    entity: 'Client',
    section: 'clients',
    screenCode: 'SCR-CLIENT-LIST',
    filePath: 'src/pages/testv2/crm/clients/ClientsListPage.tsx',
    actions: [
      { code: 'create', scope: 'header', labelKey: 'list.create', permission: 'crm.directory.create', variant: 'primary' },
      { code: 'transferer', kind: 'api', scope: 'row', endpoint: 'transferer', httpMethod: 'POST', labelKey: 'list.actions.transferer', permission: 'crm.directory.update', ucReference: 'UC-CRM-001', payloadType: 'TransfererPayload', payloadParameters: [{ name: 'targetId', type: 'lookup', entity: 'Client', module: 'crm', required: true }] },
      { code: 'joindreDocument', kind: 'api', scope: 'header', endpoint: 'joindre-document', httpMethod: 'POST', labelKey: 'list.actions.joindreDocument', permission: 'crm.directory.update', ucReference: 'UC-CRM-002', payloadType: 'JoindrePayload', payloadParameters: [{ name: 'file', type: 'file', accept: '.pdf,.docx', required: true }] },
    ],
  })
  const listOf = () => generate(fixture({
    entity: 'Client', section: 'clients', pageSpec: psWithPayloadActions(),
    fields: [{ name: 'name', type: 'string', required: true }], views: ['list'],
  })).find(f => /ListPage\.tsx$/.test(f.path))!

  it('wires a row payload action (target picker) to a CustomActionDialog opened from the row button', () => {
    const list = listOf()
    expect(list.content).toMatch(/import \{ CustomActionDialog \} from '@\/components\/ui\/CustomActionDialog'/)
    expect(list.content).toMatch(/import \{[^}]*useState[^}]*\} from 'react'/)
    expect(list.content).toMatch(/const \[transfererDialogItem, setTransfererDialogItem\] = useState<ClientListDto \| null>\(null\)/)
    // The button handler OPENS the dialog (no direct mutate); the dialog submits the payload.
    expect(list.content).toMatch(/const handleTransferer = \(item: ClientListDto\) => \{ setTransfererDialogItem\(item\) \}/)
    expect(list.content).toMatch(/apiEndpoint: '\/api\/crm\/clients\/lookup'/)
    expect(list.content).toMatch(/mutateAsync\(\{ id: transfererDialogItem\.id, payload: payload as never \}\)/)
  })

  it('wires a header file-upload action to a CustomActionDialog opened from the header button', () => {
    const list = listOf()
    expect(list.content).toMatch(/const \[joindreDocumentDialogOpen, setJoindreDocumentDialogOpen\] = useState\(false\)/)
    expect(list.content).toMatch(/const handleJoindreDocument = \(\) => \{ setJoindreDocumentDialogOpen\(true\) \}/)
    expect(list.content).toMatch(/type: 'file'[\s\S]*?accept: '\.pdf,\.docx'/)
    expect(list.content).toMatch(/await joindreDocumentMutation\.mutateAsync\(payload as never\)/)
  })

  it('a custom action WITHOUT payloadParameters still fires the mutation directly (no dialog)', () => {
    const ps = pageSpecFixture({
      entity: 'Client', section: 'clients', screenCode: 'SCR-CLIENT-LIST',
      filePath: 'src/pages/testv2/crm/clients/ClientsListPage.tsx',
      actions: [{ code: 'archive', kind: 'api', scope: 'row', endpoint: 'archive', httpMethod: 'POST', labelKey: 'list.actions.archive', permission: 'crm.directory.update', ucReference: 'UC-CRM-003' }],
    })
    const list = generate(fixture({ entity: 'Client', section: 'clients', pageSpec: ps, fields: [{ name: 'name', type: 'string', required: true }], views: ['list'] })).find(f => /ListPage\.tsx$/.test(f.path))!
    expect(list.content).not.toMatch(/CustomActionDialog/)
    expect(list.content).toMatch(/await archiveMutation\.mutateAsync\(item\.id\)/)
  })
})

// ─── Kanban — the board viewMode of the LIST page (pagespec.kanban fold) ──

const KANBAN_FIELDS = [
  { name: 'firstName', type: 'string', required: true },
  { name: 'lastName', type: 'string', required: true },
  { name: 'status', type: 'string', required: true },
]

function kanbanPageSpec(overrides: Partial<PageSpecMin> = {}): PageSpecMin {
  return pageSpecFixture({
    viewModes: ['table', 'kanban'],
    columns: [
      { key: 'firstName', labelKey: 'list.columns.firstName', sortable: true },
      { key: 'status', labelKey: 'list.columns.status', sortable: true },
    ],
    actions: [
      { code: 'create', scope: 'header', labelKey: 'list.create', permission: 'crm.directory.create', variant: 'primary' },
      {
        code: 'move', kind: 'api', scope: 'row', endpoint: 'move', labelKey: 'list.actions.move',
        permission: 'crm.directory.update', ucReference: 'UC-CRM-001',
        payloadParameters: [{ name: 'status', type: 'select', required: true, field: 'status' }],
      },
    ],
    kanban: {
      statusField: 'status',
      columns: [
        { key: 'open', labelKey: 'kanban.columns.open', color: 'blue' },
        { key: 'review', labelKey: 'kanban.columns.review', color: 'orange', initiallyHidden: true },
        { key: 'closed', labelKey: 'kanban.columns.closed', color: 'green' },
      ],
      titleField: 'firstName',
      subtitleField: 'lastName',
      transitions: [
        { from: 'open', to: 'review', rule: 'BR-001' },
        { from: 'review', to: 'closed', rule: 'BR-001' },
        { from: 'review', to: 'open' },
      ],
    },
    ...overrides,
  })
}

function kanbanListPage(overrides: Partial<ScaffoldComponentInput> = {}): string {
  const files = generate(fixture({
    fields: KANBAN_FIELDS,
    views: ['list'],
    pageSpec: kanbanPageSpec(),
    ...overrides,
  }))
  return files.find(f => /ListPage\.tsx$/.test(f.path))!.content
}

describe('scaffold-component / generate — kanban board branch (list viewMode)', () => {
  it('renders the board INSIDE the list page — single-line scroll, no standalone KanbanPage', () => {
    const files = generate(fixture({ fields: KANBAN_FIELDS, views: ['list'], pageSpec: kanbanPageSpec() }))
    expect(files.some(f => /KanbanPage\.tsx$/.test(f.path))).toBe(false)
    const list = files.find(f => /ListPage\.tsx$/.test(f.path))!.content
    expect(list).toMatch(/data-testid="list-kanban-board"/)
    // One line, horizontal scroll — never a wrapping grid.
    expect(list).toMatch(/flex gap-3 overflow-x-auto/)
    expect(list).toMatch(/w-64 shrink-0/)
    expect(list).not.toMatch(/grid-cols-1 md:grid-cols-2 lg:grid-cols-4/)
    // Columns inlined in BA order, keys verbatim, tone from the closed palette.
    expect(list).toMatch(/key: 'open', labelKey: 'kanban\.columns\.open', toneClass: 'border-t-\[var\(--info-border\)\]'/)
    expect(list).toMatch(/key: 'review', labelKey: 'kanban\.columns\.review', toneClass: 'border-t-\[var\(--warning-border\)\]', initiallyHidden: true/)
  })

  it('shares the list state: same data hook (filters/search), board page size, toggle with the kanban option', () => {
    const list = kanbanListPage()
    expect(list).toMatch(/KANBAN_FETCH_SIZE = 200/)
    expect(list).toMatch(/page: boardActive \? 1 : page, pageSize: boardActive \? KANBAN_FETCH_SIZE : pageSize/)
    expect(list).toMatch(/useListParamOpt<'table' \| 'cards' \| 'kanban'>\('view'\)/)
    expect(list).toMatch(/value: 'kanban', label: t\('contact\.list\.viewKanban'/)
    // The measured representation never receives the board pin.
    expect(list).toMatch(/pinned: pinnedView === 'kanban' \? undefined : pinnedView/)
    // Truncation stays visible, never silent.
    expect(list).toMatch(/kanban\.truncated/)
  })

  it('inlines the BR Flow matrix and refuses drops outside it (no unconditional preventDefault)', () => {
    const list = kanbanListPage()
    expect(list).toMatch(/const ALLOWED_TRANSITIONS: Record<string, readonly string\[\]> = \{\n  open: \['review'\],\n  review: \['closed', 'open'\],\n\}/)
    // closed has no outgoing edge → derived terminal, cards not draggable out.
    expect(list).toMatch(/TERMINAL_COLUMNS: ReadonlySet<string> = new Set\(\['closed'\]\)/)
    expect(list).toMatch(/draggable=\{canMoveCards && !TERMINAL_COLUMNS\.has\(col\.key\)\}/)
    expect(list).toMatch(/canDropTo = \(from: string, target: string\)/)
    expect(list).toMatch(/if \(draggedCard && canDropTo\(draggedCard\.from, col\.key\)\) event\.preventDefault\(\)/)
    expect(list).toMatch(/aria-disabled=\{draggedCard \? !canDropTo\(draggedCard\.from, col\.key\) : undefined\}/)
  })

  it('drop posts through the move mutation with optimistic overlay, error banner and permission gate', () => {
    const list = kanbanListPage()
    expect(list).toMatch(/useMoveContact/)
    expect(list).toMatch(/moveMutation\.mutateAsync\(\{ id, payload: \{ status: target \} as never \}\)/)
    expect(list).toMatch(/setPendingMoves/)
    expect(list).toMatch(/pendingMoves\.get\(item\.id\) \?\?/)
    expect(list).toMatch(/kanban\.moveError/)
    expect(list).toMatch(/import \{ useAuth \} from '@\/business\/auth\/useAuth'/)
    expect(list).toMatch(/canMoveCards = hasPermission\('crm\.directory\.update'\)/)
  })

  it('columns are reorderable (own dataTransfer type) and hideable through persisted prefs', () => {
    const list = kanbanListPage()
    expect(list).toMatch(/useKanbanColumnPrefs\('ss\.kanban\.v1\.TestV2\.crm\.directory\.contact', KANBAN_COLUMNS\)/)
    expect(list).toMatch(/event\.dataTransfer\.setData\('application\/x-ss-column', col\.key\)/)
    expect(list).toMatch(/kanbanPrefs\.moveColumn\(colKey, col\.key\)/)
    expect(list).toMatch(/onToggle=\{kanbanPrefs\.toggleColumn\}/)
    // A header drag can never be mistaken for a card drop.
    expect(list).toMatch(/event\.dataTransfer\.types\.includes\('application\/x-ss-column'\)/)
  })

  it('keeps the unassigned bucket (schema drift stays visible)', () => {
    const list = kanbanListPage()
    expect(list).toMatch(/kanban\.unassigned/)
    expect(list).toMatch(/kanbanBuckets\.unassigned/)
  })

  it('board is READ-ONLY without a move action (transitions authored) — no handler, no useAuth', () => {
    const ps = kanbanPageSpec()
    ps.actions = ps.actions.filter(a => a.code !== 'move')
    const list = kanbanListPage({ pageSpec: ps })
    expect(list).toMatch(/data-testid="list-kanban-board"/)
    expect(list).not.toMatch(/handleCardDrop/)
    expect(list).not.toMatch(/useAuth/)
    expect(list).not.toMatch(/draggable=\{canMoveCards/)
    // Column reorder stays available on a read-only board.
    expect(list).toMatch(/application\/x-ss-column/)
  })

  it('transitions: [] = explicitly read-only, even with a move action declared', () => {
    const ps = kanbanPageSpec()
    ;(ps.kanban as Record<string, unknown>).transitions = []
    const list = kanbanListPage({ pageSpec: ps })
    expect(list).not.toMatch(/handleCardDrop/)
  })

  it('open matrix (no transitions) → any drop allowed, no ALLOWED_TRANSITIONS literal', () => {
    const ps = kanbanPageSpec()
    delete (ps.kanban as Record<string, unknown>).transitions
    const list = kanbanListPage({ pageSpec: ps })
    expect(list).not.toMatch(/ALLOWED_TRANSITIONS/)
    expect(list).toMatch(/handleCardDrop/)
    expect(list).toMatch(/from !== target\n/)
  })

  it('viewModes without kanban → legacy output, board absent even when the block exists', () => {
    const ps = kanbanPageSpec({ viewModes: ['table'] })
    const list = kanbanListPage({ pageSpec: ps })
    expect(list).not.toMatch(/list-kanban-board/)
    expect(list).not.toMatch(/KANBAN_COLUMNS/)
  })

  it('a rejected block (unknown statusField) degrades to the legacy list with a warning', () => {
    const ps = kanbanPageSpec()
    ;(ps.kanban as Record<string, unknown>).statusField = 'phase'
    const warnings: string[] = []
    const files = generate(
      fixture({ fields: KANBAN_FIELDS, views: ['list'], pageSpec: ps }),
      { warnings },
    )
    const list = files.find(f => /ListPage\.tsx$/.test(f.path))!.content
    expect(list).not.toMatch(/list-kanban-board/)
    expect(warnings.join(' ')).toContain("'phase' is not a pagespec field")
  })
})

// ─── Bug 7 — reconduction view first-class ───────────────────────────────

describe('scaffold-component / generate — Bug 7 (reconduction view)', () => {
  it('emits ReconductionPage when views includes "reconduction"', () => {
    const files = generate(fixture({
      entity: 'Demande',
      section: 'demandes',
      fields: [{ name: 'numero', type: 'string', required: true }],
      views: ['reconduction'],
    }))
    const page = files.find(f => /ReconductionPage\.tsx$/.test(f.path))
    expect(page).toBeDefined()
    expect(page!.content).toMatch(/<PageTemplate/)
    expect(page!.content).toMatch(/useReconductDemandes/)
  })

  it('reconduction button is disabled when no rows selected', () => {
    const files = generate(fixture({
      entity: 'Demande',
      section: 'demandes',
      fields: [{ name: 'numero', type: 'string', required: true }],
      views: ['reconduction'],
    }))
    const page = files.find(f => /ReconductionPage\.tsx$/.test(f.path))!
    expect(page.content).toMatch(/selectedIds\.length === 0/)
  })

  it('emits refuse button + useRefuseReconduction hook when withRefuse: true', () => {
    const files = generate(fixture({
      entity: 'Demande',
      section: 'demandes',
      fields: [{ name: 'numero', type: 'string', required: true }],
      views: ['reconduction'],
      reconductionConfig: {
        actionLabelKey: 'reconduction.action.reconduct',
        withRefuse: true,
      },
    }))
    const page = files.find(f => /ReconductionPage\.tsx$/.test(f.path))!
    expect(page.content).toMatch(/useRefuseReconductionDemandes/)
    expect(page.content).toMatch(/handleRefuse/)
  })

  it('does NOT emit refuse hook when withRefuse: false (default)', () => {
    const files = generate(fixture({
      entity: 'Demande',
      section: 'demandes',
      fields: [{ name: 'numero', type: 'string', required: true }],
      views: ['reconduction'],
    }))
    const page = files.find(f => /ReconductionPage\.tsx$/.test(f.path))!
    expect(page.content).not.toMatch(/useRefuseReconduction/)
  })
})

describe('scaffold-component / generate — modern form primitives (date / enum / multiselect)', () => {
  function formPage(fields: ScaffoldComponentInput['fields']) {
    const files = generate(fixture({ fields, views: ['form'] }))
    return files.find((f) => /FormPage\.tsx$/.test(f.path))!
  }

  it('date fields render <DateInput> (never the native <input type="date">) + import it', () => {
    const page = formPage([{ name: 'birthDate', type: 'date', required: true }])
    expect(page.content).toMatch(/import \{ DateInput \} from '@\/components\/ui\/DateInput'/)
    expect(page.content).toMatch(/<DateInput/)
    expect(page.content).not.toMatch(/type="date"/)
    expect(page.content).not.toMatch(/type="datetime-local"/)
  })

  it('a date field carries dateBounds from its spec: past → maxDate="today", future → minDate="today", unset → neither', () => {
    const seg = (content: string) => content.split('<DateInput')[1] ?? ''
    expect(seg(formPage([{ name: 'birthDate', type: 'date', required: true, dateBounds: 'past' }]).content)).toMatch(/maxDate="today"/)
    expect(seg(formPage([{ name: 'dueDate', type: 'date', required: true, dateBounds: 'future' }]).content)).toMatch(/minDate="today"/)
    const plain = seg(formPage([{ name: 'effectiveDate', type: 'date', required: true }]).content)
    expect(plain).not.toMatch(/maxDate="today"/)
    expect(plain).not.toMatch(/minDate="today"/)
  })

  it('enum fields with ≤4 options render <SegmentedControl> with i18n option labels', () => {
    const page = formPage([
      { name: 'status', type: 'enum', required: true, options: [
        { value: 'open', label: 'Open' },
        { value: 'closed', label: 'Closed' },
      ] },
    ])
    expect(page.content).toMatch(/import \{ SegmentedControl \} from '@\/components\/ui\/SegmentedControl'/)
    expect(page.content).toMatch(/<SegmentedControl/)
    // Low cardinality → 1-click segmented, not a dropdown.
    expect(page.content).not.toMatch(/<EnumSelect/)
    // Option labels go through i18n (BA label as the fallback) — never hardcoded.
    // They live in the form.options.<field>.<value> SIBLING branch: nested under
    // the form.fields.<field> label leaf they could never ship (leaf wins).
    expect(page.content).toMatch(/value: 'open', label: t\('contact\.form\.options\.status\.open', \{ defaultValue: 'Open' \}\)/)
    expect(page.content).toMatch(/value: 'closed', label: t\('contact\.form\.options\.status\.closed', \{ defaultValue: 'Closed' \}\)/)
    // Routed away from the plain text input path.
    expect(page.content).not.toMatch(/type="text"/)
  })

  it('enum fields with >4 options render <EnumSelect> (dropdown) with i18n option labels', () => {
    const page = formPage([
      { name: 'priority', type: 'enum', required: true, options: [
        { value: 'p1', label: 'P1' }, { value: 'p2', label: 'P2' }, { value: 'p3', label: 'P3' },
        { value: 'p4', label: 'P4' }, { value: 'p5', label: 'P5' },
      ] },
    ])
    expect(page.content).toMatch(/import \{ EnumSelect \} from '@\/components\/ui\/EnumSelect'/)
    expect(page.content).toMatch(/<EnumSelect/)
    expect(page.content).not.toMatch(/<SegmentedControl/)
    expect(page.content).toMatch(/value: 'p1', label: t\('contact\.form\.options\.priority\.p1', \{ defaultValue: 'P1' \}\)/)
  })

  it('multi-valued enum renders <MultiSelect>, types the field string[] and seeds []', () => {
    const page = formPage([
      { name: 'tags', type: 'enum', required: false, multiple: true, options: [
        { value: 'a', label: 'A' },
        { value: 'b', label: 'B' },
      ] },
    ])
    expect(page.content).toMatch(/import \{ MultiSelect \} from '@\/components\/ui\/MultiSelect'/)
    expect(page.content).toMatch(/<MultiSelect/)
    expect(page.content).toMatch(/tags\?: string\[\]/)   // FormData type
    expect(page.content).toMatch(/tags: \[\]/)            // initial value
  })

  it('escapes single quotes inside option values/labels', () => {
    const page = formPage([
      { name: 'kind', type: 'enum', required: true, options: [
        { value: "o'brien", label: "O'Brien" },
      ] },
    ])
    expect(page.content).toMatch(/value: 'o\\'brien'/)
    expect(page.content).toMatch(/defaultValue: 'O\\'Brien'/)
  })

  it('plain (non-enum / non-date) fields still render a <input>, no primitive imports', () => {
    const page = formPage([{ name: 'firstName', type: 'string', required: true }])
    expect(page.content).toMatch(/<input/)
    expect(page.content).not.toMatch(/<DateInput/)
    expect(page.content).not.toMatch(/<EnumSelect/)
    expect(page.content).not.toMatch(/<MultiSelect/)
  })

  it('detail page resolves enum / multiselect values to their label (not the raw code)', () => {
    const files = generate(fixture({
      views: ['detail'], entityViews: ['list', 'detail'],
      fields: [
        { name: 'status', type: 'enum', required: true, options: [
          { value: 'open', label: 'Open' },
          { value: 'closed', label: 'Closed' },
        ] },
        { name: 'tags', type: 'enum', required: false, multiple: true, options: [
          { value: 'a', label: 'Alpha' },
        ] },
      ],
    }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!
    // single enum → label looked up by value
    expect(detail.content).toMatch(/\{ value: 'open', label: 'Open' \}/)
    expect(detail.content).toMatch(/find\(\(o\) => o\.value === data\.status\)\?\.label/)
    // multiselect → values mapped to labels and joined
    expect(detail.content).toMatch(/\(\(data\.tags as string\[\] \| undefined\) \?\? \[\]\)\.map/)
  })
})

describe('scaffold-component / generate — form field state (readonly / readonlyOn / visibleWhen)', () => {
  function formFor(fields: ScaffoldComponentInput['fields']) {
    const files = generate(fixture({ entity: 'Task', module: 'todo', section: 'tasks', views: ['form'], fields }))
    return files.find((f) => /FormPage\.tsx$/.test(f.path))!
  }

  it('renders a readonly field display-only (no editable input) and drops it from the create payload', () => {
    const form = formFor([
      { name: 'title', type: 'string', required: true },
      { name: 'isOverdue', type: 'bool', required: false, readonly: true },
    ])
    expect(form.content).not.toMatch(/id="isOverdue"/)
    // Readonly boolean → coloured Oui/Non pill (not the old <span class="badge">true</span>).
    expect(form.content).not.toMatch(/<span className="badge">\{String\(formData\.isOverdue\)\}<\/span>/)
    expect(form.content).toMatch(/formData\.isOverdue \? <Badge tone="success">\{t\('task\.common\.yes'\)\}<\/Badge>/)
    expect(form.content).toMatch(/import \{ Badge \} from '@\/components\/ui\/Badge'/)
    // toCreatePayload picks ONLY the editable fields (title), excluding the readonly one.
    expect(form.content).toMatch(/const toCreatePayload = \(d: TaskFormData\) => \(\{/)
    expect(form.content).toMatch(/title: d\.title,/)
    expect(form.content).not.toMatch(/isOverdue: d\.isOverdue/)
    expect(form.content).toMatch(/createMutation\.mutateAsync\(toCreatePayload\(formData\)\)/)
  })

  it('treats isComputed as an alias of readonly (display-only)', () => {
    const form = formFor([
      { name: 'title', type: 'string', required: true },
      { name: 'total', type: 'number', required: false, isComputed: true },
    ])
    expect(form.content).not.toMatch(/id="total"/)
    expect(form.content).toMatch(/\{String\(formData\.total \?\? ''\)\}/)
  })

  it('locks a readonlyOn:"create" select in create mode and seeds its first option', () => {
    const form = formFor([
      { name: 'status', type: 'string', required: true, readonlyOn: 'create',
        options: [{ value: 'Open', label: 'Open' }, { value: 'Done', label: 'Done' }] },
    ])
    expect(form.content).toMatch(/<SegmentedControl[\s\S]*?disabled=\{isPending \|\| !isEdit\}/)
    // Initial form data seeds the first option so the locked control isn't blank.
    expect(form.content).toMatch(/status: 'Open',/)
    // readonlyOn fields stay editable → no exclusion helper, create sends formData.
    expect(form.content).not.toMatch(/toCreatePayload/)
  })

  it('compiles visibleWhen into a guarded render and keeps the field in FormData', () => {
    const form = formFor([
      { name: 'status', type: 'string', required: true,
        options: [{ value: 'Open', label: 'Open' }, { value: 'Done', label: 'Done' }] },
      { name: 'resolution', type: 'string', required: false, visibleWhen: "status === 'Done'" },
    ])
    expect(form.content).toMatch(/\{\(formData\.status === 'Done'\) && \(/)
    // The field stays in the form data type (only its JSX is conditional).
    expect(form.content).toMatch(/resolution\??: string/)
  })

  it('degrades an unsupported visibleWhen to always-visible with a comment (never crashes)', () => {
    const form = formFor([
      { name: 'note', type: 'string', required: false, visibleWhen: 'status && other' },
    ])
    expect(form.content).toMatch(/visibleWhen "status && other" is not a supported predicate/)
    // The field is still rendered (always visible), just not guarded. "note"
    // matches the long-text heuristic, so it's a <Textarea>.
    expect(form.content).toMatch(/onChange\('note',/)
  })

  it('compiles the IN membership grammar into an OR chain (the lifecycle status-gate form)', () => {
    const form = formFor([
      { name: 'status', type: 'string', required: true,
        options: [{ value: 'Open', label: 'Open' }, { value: 'Done', label: 'Done' }] },
      { name: 'resolution', type: 'string', required: false, visibleWhen: "status IN ('Done', 'Archived')" },
    ])
    expect(form.content).toMatch(/\{\(\(formData\.status === 'Done' \|\| formData\.status === 'Archived'\)\) && \(/)
  })

  it('compiles NOT IN into an AND chain of !== and a single-literal IN into one comparison', () => {
    const form = formFor([
      { name: 'reason', type: 'string', required: false, visibleWhen: "status NOT IN ('Open', 'Draft')" },
      { name: 'closedBy', type: 'string', required: false, visibleWhen: "status IN ('Done')" },
    ])
    expect(form.content).toMatch(/\{\(\(formData\.status !== 'Open' && formData\.status !== 'Draft'\)\) && \(/)
    expect(form.content).toMatch(/\{\(formData\.status === 'Done'\) && \(/)
  })

  it('degrades a malformed IN (unquoted literals) to always-visible', () => {
    const form = formFor([
      { name: 'note', type: 'string', required: false, visibleWhen: 'status IN (Done, Open)' },
    ])
    expect(form.content).toMatch(/visibleWhen "status IN \(Done, Open\)" is not a supported predicate/)
  })

  it('renders a readonly FK as a disabled EntityLookup (label, not Guid)', () => {
    const form = formFor([
      { name: 'ownerId', type: 'guid', required: false, readonly: true,
        fkTo: { entity: 'User', module: 'core' } },
    ])
    expect(form.content).toMatch(/<EntityLookup[\s\S]*?apiEndpoint="\/api\/core\/users\/lookup"[\s\S]*?disabled\s*\n\s*\/>/)
    expect(form.content).toMatch(/onChange=\{\(\) => \{\}\}/)
  })

  it('never emits a system "id" field as an editable input', () => {
    const form = formFor([
      { name: 'id', type: 'guid', required: false },
      { name: 'title', type: 'string', required: true },
    ])
    expect(form.content).not.toMatch(/<input[^>]*id="id"/)
  })

  it('legacy form without any field-state flags emits no toCreatePayload (byte-identical path)', () => {
    const form = formFor([
      { name: 'title', type: 'string', required: true },
      { name: 'note', type: 'string', required: false },
    ])
    expect(form.content).not.toMatch(/toCreatePayload/)
    expect(form.content).toMatch(/createMutation\.mutateAsync\(formData\)/)
  })
})

describe('scaffold-component / generate — FK labels in Detail + List (not the Guid)', () => {
  function pages(fields: ScaffoldComponentInput['fields']) {
    // Legacy read fiche (no form sibling) — the unified fiche resolves the
    // same labels through formData (fiche-unified suite).
    const files = generate(fixture({ entity: 'Task', module: 'todo', section: 'tasks', views: ['list', 'detail'], entityViews: ['list', 'detail'], fields }))
    return {
      list: files.find((f) => /ListPage\.tsx$/.test(f.path))!,
      detail: files.find((f) => /DetailPage\.tsx$/.test(f.path))!,
    }
  }
  const fkFields: ScaffoldComponentInput['fields'] = [
    { name: 'title', type: 'string', required: true },
    { name: 'categoryId', type: 'guid', required: true, fkTo: { entity: 'Category', module: 'todo' } },
  ]

  it('Detail resolves a FK field to its label via the target lookup hook', () => {
    const { detail } = pages(fkFields)
    expect(detail.content).toMatch(/import \{ useCategoryLookup \} from '@\/features\/testv2\/todo\/category\/hooks\/useCategory'/)
    expect(detail.content).toMatch(/const \{ data: categoryIdLookupData \} = useCategoryLookup\(\{ search:/)
    // The <dd> shows the resolved displayName, masking with an em dash while
    // unresolved — the raw Guid is NEVER user-facing.
    expect(detail.content).toMatch(/\(categoryIdLookupData\?\.items \?\? \[\]\)\.find\(\(it\) => it\.id === data\.categoryId\)\?\.displayName \?\? \(data\.categoryId \? '—' : ''\)/)
    expect(detail.content).not.toMatch(/\?\? String\(data\.categoryId \?\? ''\)/)
  })

  it('List renders a FK column via a lookup Map (label, not Guid) and marks it non-sortable', () => {
    const { list } = pages(fkFields)
    expect(list.content).toMatch(/import \{ useCategoryLookup \} from '@\/features\/testv2\/todo\/category\/hooks\/useCategory'/)
    expect(list.content).toMatch(/import \{[^}]*\buseMemo\b[^}]*\} from 'react'/)
    expect(list.content).toMatch(/const \{ data: categoryLookupData \} = useCategoryLookup\(\{ pageSize: 100 \}\)/)
    expect(list.content).toMatch(/const categoryLookupMap = useMemo\(\(\) => new Map\(\(categoryLookupData\?\.items \?\? \[\]\)\.map\(\(it\) => \[it\.id, it\.displayName\]\)\)/)
    // The FK column reads the Map in its render and is not server-sortable.
    // Unresolved ids mask with an em dash — the raw Guid is NEVER user-facing.
    expect(list.content).toMatch(/key: 'categoryId'[^}]*sortable: false[^}]*render: \(item\) => categoryLookupMap\.get\(item\.categoryId as string\) \?\? \(item\.categoryId \? '—' : ''\)/)
    expect(list.content).not.toMatch(/\?\? String\(item\.categoryId \?\? ''\)/)
  })

  it('a list with no FK columns imports no lookup hook and no useMemo (byte-identical path)', () => {
    const { list } = pages([
      { name: 'title', type: 'string', required: true },
      { name: 'note', type: 'string', required: false },
    ])
    expect(list.content).not.toMatch(/Lookup/)
    expect(list.content).not.toMatch(/useMemo/)
  })
})

describe('scaffold-component / generate — pageSpec.uiDesign overlay (architecture C)', () => {
  const withOverlay = (uiDesign: Record<string, unknown>, fields: ScaffoldComponentInput['fields']) =>
    generate(fixture({
      entity: 'Contact', module: 'crm', section: 'directory', views: ['form'], fields,
      pageSpec: { ...pageSpecFixture({ view: 'form', filePath: 'src/pages/testv2/crm/directory/ContactFormPage.tsx' }), uiDesign } as unknown as PageSpecMin,
    })).find((f) => /FormPage\.tsx$/.test(f.path))!.content

  it('applies currentUserFk + section + inline date + formLayout from the overlay', () => {
    const c = withOverlay(
      {
        formLayout: 'single-column',
        fields: {
          ownerId: { currentUserFk: true, section: 'identity' },
          birthDate: { control: 'date-inline', section: 'identity' },
          managerId: { section: 'org' },
        },
      },
      [
        { name: 'ownerId', type: 'guid', required: true, fkTo: { entity: 'User', module: 'core' } },
        { name: 'managerId', type: 'guid', required: false, fkTo: { entity: 'Employee', module: 'hr' } },
        { name: 'birthDate', type: 'date', required: false },
      ],
    )
    // currentUserFk from the overlay → "Me" on ownerId, NONE on the self-ref managerId.
    expect(c).toMatch(/onClick=\{\(\) => onChange\('ownerId', \(user\?\.id \?\? ''\)/)
    expect(c).toMatch(/import \{ useAuth \}/)
    expect(c).not.toMatch(/onChange\('managerId', \(user\?\.id/)
    // Section grouping from the overlay.
    expect(c).toMatch(/t\('contact\.form\.section\.identity', \{ defaultValue: 'Identity' \}\)/)
    expect(c).toMatch(/t\('contact\.form\.section\.org', \{ defaultValue: 'Org' \}\)/)
    expect(c.indexOf('section.identity')).toBeLessThan(c.indexOf('section.org'))
    // Inline date from the overlay control.
    expect(c).toMatch(/<DateInput\s+inline\s+value=\{\(formData\.birthDate/)
    // Single-column layout from the overlay.
    expect(c).toMatch(/grid grid-cols-1 gap-x-6 gap-y-4/)
    expect(c).not.toMatch(/md:grid-cols-2/)
  })

  it('reorders fields by the overlay `order`', () => {
    const c = withOverlay(
      { order: ['gamma', 'alpha', 'beta'] },
      [
        { name: 'alpha', type: 'string', required: false },
        { name: 'beta', type: 'string', required: false },
        { name: 'gamma', type: 'string', required: false },
      ],
    )
    expect(c.indexOf('id="gamma"')).toBeLessThan(c.indexOf('id="alpha"'))
    expect(c.indexOf('id="alpha"')).toBeLessThan(c.indexOf('id="beta"'))
  })

  it('applies dateBounds from the overlay (past → maxDate, future → minDate), composing with inline', () => {
    const c = withOverlay(
      {
        fields: {
          birthDate: { dateBounds: 'past' },
          contractEndDate: { control: 'date-inline', dateBounds: 'future' },
          effectiveDate: {},
        },
      },
      [
        { name: 'birthDate', type: 'date', required: false },
        { name: 'contractEndDate', type: 'date', required: false },
        { name: 'effectiveDate', type: 'date', required: false },
      ],
    )
    // One segment per DateInput (text after each `<DateInput` up to the next).
    // slice(1) drops the prefix — the read-first READ grid also references
    // formData.<field> (formatDate) BEFORE the first <DateInput>.
    const seg = (field: string) => c.split('<DateInput').slice(1).find((s) => s.includes('formData.' + field)) ?? ''
    // past → upper-bounded at today (no future birth date).
    expect(seg('birthDate')).toMatch(/maxDate="today"/)
    expect(seg('birthDate')).not.toMatch(/minDate="today"/)
    // future + inline compose: an end date can't be in the past, and it's the primary inline calendar.
    expect(seg('contractEndDate')).toMatch(/minDate="today"/)
    expect(seg('contractEndDate')).toMatch(/^\s*inline/)
    // unset (≡ any) → neither bound.
    expect(seg('effectiveDate')).not.toMatch(/(min|max)Date="today"/)
  })

  it('no uiDesign overlay → safe defaults stand (no Me, popover date, single sober section)', () => {
    const c = generate(fixture({
      entity: 'Contact', module: 'crm', section: 'directory', views: ['form'],
      fields: [
        { name: 'ownerId', type: 'guid', required: true, fkTo: { entity: 'User', module: 'core' } },
        { name: 'birthDate', type: 'date', required: false },
      ],
      pageSpec: pageSpecFixture({ view: 'form', filePath: 'src/pages/testv2/crm/directory/ContactFormPage.tsx' }),
    })).find((f) => /FormPage\.tsx$/.test(f.path))!.content
    expect(c).not.toMatch(/t\('contact\.form\.me'/)
    expect(c).not.toMatch(/<DateInput\s+inline/)
    // Single sober card: no section TITLE is invented (the read grid's <dt>
    // legitimately uses tracking-wider — only the card title prop matters).
    expect(c).not.toMatch(/title=\{t\('contact\.form\.section\./)
  })
})

describe('scaffold-component / generate — modern form layout + controls + interaction', () => {
  const taskFields: ScaffoldComponentInput['fields'] = [
    { name: 'title', type: 'string', required: true },
    { name: 'description', type: 'string', required: false },
    { name: 'categoryId', type: 'guid', required: true, fkTo: { entity: 'Category', module: 'todo' } },
    { name: 'priority', type: 'enum', required: true, options: [
      { value: 'low', label: 'Low' }, { value: 'med', label: 'Medium' }, { value: 'high', label: 'High' } ] },
    { name: 'status', type: 'enum', required: true, readonlyOn: 'create', options: [
      { value: 'todo', label: 'To do' }, { value: 'doing', label: 'Doing' }, { value: 'done', label: 'Done' } ] },
    { name: 'assigneeId', type: 'guid', required: false, fkTo: { entity: 'User', module: 'core' } },
    { name: 'dueDate', type: 'date', required: false },
    { name: 'isUrgent', type: 'bool', required: false },
    { name: 'completedAt', type: 'datetime', required: false, readonly: true },
  ]
  function taskForm() {
    const files = generate(fixture({ entity: 'Task', module: 'todo', section: 'tasks', views: ['form'], fields: taskFields }))
    return files.find((f) => /FormPage\.tsx$/.test(f.path))!
  }

  it('A — uses the full-width standard layout (not the narrow focused column)', () => {
    const c = taskForm().content
    expect(c).toMatch(/width="standard"/)
    expect(c).not.toMatch(/width="focused"/)
  })

  it('A — an un-sectioned form renders ONE sober SectionCard (no redundant Essential/Details header)', () => {
    const c = taskForm().content
    // The directive-less partition guess is gone — no header invented from a title/textarea.
    expect(c).not.toMatch(/t\('task\.form\.section\.essential'/)
    expect(c).not.toMatch(/t\('task\.form\.section\.details'/)
    // The card chrome is the owned SectionCard primitive now — exactly one,
    // without a title prop (sober card, no header).
    const sections = c.match(/<SectionCard/g) ?? []
    expect(sections.length).toBe(1)
    expect(c).toMatch(/import \{ SectionCard \} from '@\/components\/ui\/SectionCard'/)
    expect(c).not.toMatch(/title=\{t\('task\.form\.section\./)
  })

  it('A — groups fields into titled cards from the `section` directive (declaration order)', () => {
    const files = generate(fixture({ entity: 'Profile', module: 'hr', section: 'profiles', views: ['form'], fields: [
      { name: 'firstName', type: 'string', required: true, section: 'identity' },
      { name: 'lastName', type: 'string', required: true, section: 'identity' },
      { name: 'startDate', type: 'date', required: true, section: 'contract' },
    ] }))
    const c = files.find((f) => /FormPage\.tsx$/.test(f.path))!.content
    expect(c).toMatch(/t\('profile\.form\.section\.identity', \{ defaultValue: 'Identity' \}\)/)
    expect(c).toMatch(/t\('profile\.form\.section\.contract', \{ defaultValue: 'Contract' \}\)/)
    expect(c.indexOf('section.identity')).toBeLessThan(c.indexOf('section.contract'))
  })

  it('A — fields flow in a responsive 2-column grid; full-width controls span both columns', () => {
    const c = taskForm().content
    expect(c).toMatch(/grid grid-cols-1 md:grid-cols-2 gap-x-6 gap-y-4/)
    // No old left/right "bulky" split column.
    expect(c).not.toMatch(/lg:grid-cols-2/)
    // The long-text description (Textarea) spans both columns.
    expect(c).toMatch(/md:col-span-2/)
  })

  it('A — a form with no bulky field falls back to a balanced 2-column cell grid', () => {
    const files = generate(fixture({ entity: 'Tag', module: 'todo', section: 'tags', views: ['form'], fields: [
      { name: 'title', type: 'string', required: true },
      { name: 'kind', type: 'enum', required: true, options: [{ value: 'a', label: 'A' }, { value: 'b', label: 'B' }] },
      { name: 'scope', type: 'enum', required: true, options: [{ value: 'x', label: 'X' }, { value: 'y', label: 'Y' }] },
    ] }))
    const c = files.find((f) => /FormPage\.tsx$/.test(f.path))!.content
    expect(c).toMatch(/grid grid-cols-1 md:grid-cols-2 gap-x-6/)
    expect(c).not.toMatch(/lg:grid-cols-2/)
  })

  it('B — long text renders <Textarea> (never a single-line <input>)', () => {
    const c = taskForm().content
    expect(c).toMatch(/import \{ Textarea \} from '@\/components\/ui\/Textarea'/)
    expect(c).toMatch(/<Textarea[\s\S]*?onChange=\{\(v\) => onChange\('description'/)
    expect(c).not.toMatch(/<input[^>]*id="description"/)
  })

  it('B — a low-cardinality enum renders <SegmentedControl>, a bool renders <Switch>', () => {
    const c = taskForm().content
    expect(c).toMatch(/import \{ SegmentedControl \} from '@\/components\/ui\/SegmentedControl'/)
    expect(c).toMatch(/<SegmentedControl[\s\S]*?onChange=\{\(v\) => onChange\('priority'/)
    expect(c).toMatch(/import \{ Switch \} from '@\/components\/ui\/Switch'/)
    expect(c).toMatch(/<Switch[\s\S]*?value=\{!!formData\.isUrgent\}/)
  })

  it('B — a date renders <DateInput> as a popover by default (no always-open inline wall)', () => {
    const c = taskForm().content
    expect(c).toMatch(/import \{ DateInput \} from '@\/components\/ui\/DateInput'/)
    expect(c).toMatch(/<DateInput\s+value=\{\(formData\.dueDate as string \| null\)/)
    // The old wall-of-calendars regression: dueDate must NOT be inline by default.
    expect(c).not.toMatch(/<DateInput\s+inline\s+value=\{\(formData\.dueDate/)
  })

  it('B — a date with control "date-inline" opts into an always-open inline calendar', () => {
    const files = generate(fixture({ entity: 'Event', module: 'cal', section: 'events', views: ['form'], fields: [
      { name: 'eventDate', type: 'date', required: true, control: 'date-inline' },
    ] }))
    const c = files.find((f) => /FormPage\.tsx$/.test(f.path))!.content
    expect(c).toMatch(/<DateInput\s+inline\s+value=\{\(formData\.eventDate as string \| null\)/)
  })

  it('B — a FK gets NO "Me" button by default (no currentUserFk → no wrong self-ref shortcut)', () => {
    const c = taskForm().content
    // assigneeId is a FK→User but carries no currentUserFk directive → plain lookup.
    expect(c).not.toMatch(/t\('task\.form\.me'/)
    expect(c).not.toMatch(/import \{ useAuth \}/)
  })

  it('B — a FK marked currentUserFk gets the "Me" button + useAuth + valueLabel (never the Guid)', () => {
    const files = generate(fixture({ entity: 'Task', module: 'todo', section: 'tasks', views: ['form'], fields: [
      { name: 'assigneeId', type: 'guid', required: false, currentUserFk: true, fkTo: { entity: 'User', module: 'core' } },
    ] }))
    const c = files.find((f) => /FormPage\.tsx$/.test(f.path))!.content
    expect(c).toMatch(/import \{ useAuth \} from '@\/business\/auth\/useAuth'/)
    expect(c).toMatch(/const \{ user \} = useAuth\(\)/)
    expect(c).toMatch(/valueLabel=\{formData\.assigneeId === user\?\.id/)
    expect(c).toMatch(/onClick=\{\(\) => onChange\('assigneeId', \(user\?\.id \?\? ''\)/)
    expect(c).toMatch(/t\('task\.form\.me'/)
  })

  it('C — a readonlyOn:"create" control is locked in create mode and seeded to its default', () => {
    const c = taskForm().content
    expect(c).toMatch(/disabled=\{isPending \|\| !isEdit\}/)
    expect(c).toMatch(/status: 'todo',/)
  })

  it('C — a system/computed read-only field shows only when it has a value (no editable picker)', () => {
    const c = taskForm().content
    expect(c).not.toMatch(/<input[^>]*id="completedAt"/)
    // Value-guarded: an empty completedAt renders nothing.
    expect(c).toMatch(/\{\(formData\.completedAt !== null && formData\.completedAt !== undefined && formData\.completedAt !== ''\) && \(/)
  })

  it('D — autofocuses the first editable control on mount', () => {
    const c = taskForm().content
    expect(c).toMatch(/const formRef = useRef<HTMLFormElement>\(null\)/)
    expect(c).toMatch(/formRef\.current\?\.querySelector<HTMLElement>/)
    expect(c).toMatch(/first\?\.focus\(\)/)
  })

  it('D — Ctrl/Cmd+Enter submits from any field', () => {
    const c = taskForm().content
    expect(c).toMatch(/<form ref=\{formRef\} onSubmit=\{handleSubmit\} onKeyDown=\{onFormKeyDown\}/)
    expect(c).toMatch(/\(event\.metaKey \|\| event\.ctrlKey\) && event\.key === 'Enter'/)
    expect(c).toMatch(/formRef\.current\?\.requestSubmit\(\)/)
  })

  it('D — inline per-field validation: required fields get a message under the field', () => {
    const c = taskForm().content
    expect(c).toMatch(/const \[fieldErrors, setFieldErrors\] = useState<Record<string, string>>\(\{\}\)/)
    expect(c).toMatch(/const validate = \(\): boolean =>/)
    expect(c).toMatch(/if \(!validate\(\)\) return/)
    expect(c).toMatch(/const requiredMsg = t\('task\.form\.required'/)
    expect(c).toMatch(/if \(isBlank\(formData\.title\)\) errs\.title = requiredMsg/)
    // Visible-only validation: a visibleWhen-hidden required field is guarded.
    expect(c).toMatch(/error=\{fieldErrors\.categoryId\}/)
  })

  it('D — the create payload excludes locked/readonly/system fields', () => {
    const c = taskForm().content
    expect(c).toMatch(/const toCreatePayload = \(d: TaskFormData\) => \(\{/)
    expect(c).toMatch(/createMutation\.mutateAsync\(toCreatePayload\(formData\)\)/)
    // completedAt is read-only → never sent.
    expect(c).not.toMatch(/completedAt: d\.completedAt/)
  })

  it('honours an explicit `control` hint over the type-based inference', () => {
    const files = generate(fixture({ entity: 'Note', module: 'todo', section: 'notes', views: ['form'], fields: [
      { name: 'title', type: 'string', required: true },
      // `memo` would default to a plain input, but control forces a Textarea.
      { name: 'memo', type: 'string', required: false, control: 'textarea' },
      // A 6-option enum would default to <EnumSelect>, but control forces segmented.
      { name: 'mood', type: 'enum', required: true, control: 'segmented', options: [
        { value: 'a', label: 'A' }, { value: 'b', label: 'B' }, { value: 'c', label: 'C' },
        { value: 'd', label: 'D' }, { value: 'e', label: 'E' }, { value: 'f', label: 'F' } ] },
    ] }))
    const c = files.find((f) => /FormPage\.tsx$/.test(f.path))!.content
    expect(c).toMatch(/<Textarea[\s\S]*?onChange=\{\(v\) => onChange\('memo'/)
    expect(c).toMatch(/<SegmentedControl[\s\S]*?onChange=\{\(v\) => onChange\('mood'/)
    expect(c).not.toMatch(/<EnumSelect/)
  })
})

describe('scaffold-component / boolean + status pills & row-action dedup', () => {
  function pillFixture(overrides: Partial<ScaffoldComponentInput> = {}): ScaffoldComponentInput {
    return fixture({
      fields: [
        { name: 'libelle', type: 'string', required: true },
        { name: 'dureeDeterminee', type: 'bool', required: true },
        { name: 'archived', type: 'bool', required: false, readonly: true },
        { name: 'priorite', type: 'enum', required: false, options: [
          { value: 'HIGH', label: 'Haute' }, { value: 'LOW', label: 'Basse' } ] },
        { name: 'statut', type: 'string', required: true },
      ],
      ...overrides,
    })
  }

  it('renders a boolean LIST column as a coloured Oui/Non pill, never raw true/false', () => {
    const files = generate(pillFixture())
    const list = files.find((f) => f.path.endsWith('ContactsListPage.tsx'))!.content
    // bool column gets a render → coloured pill keyed on the value
    expect(list).toMatch(/render: \(item\) => \(item\.dureeDeterminee \? <Badge tone="success">/)
    expect(list).toMatch(/import \{ Badge \} from '@\/components\/ui\/Badge'/)
    expect(list).toMatch(/\{t\('contact\.common\.yes'\)\}/)
    expect(list).toMatch(/\{t\('contact\.common\.no'\)\}/)
    // the broken default (raw String of a boolean) must not appear for this column.
    // The sortable: lookahead pins the match on the COLUMN entry — the
    // columnVisibilityDefaults literal shares the key/label shape but is
    // legitimately render-less.
    expect(list).not.toMatch(/key: 'dureeDeterminee',(?=[^}]*sortable:)[^}]*\}\s*,\s*\n\s*\{[^]*?key: 'priorite'/)
    expect(list).not.toMatch(/\{String\(item\.dureeDeterminee\)\}/)
  })

  it('resolves an ENUM list column to its label instead of the raw code', () => {
    const files = generate(pillFixture())
    const list = files.find((f) => f.path.endsWith('ContactsListPage.tsx'))!.content
    expect(list).toMatch(/find\(\(o\) => o\.value === item\.priorite\)\?\.label \?\? String\(item\.priorite \?\? ''\)/)
    expect(list).toMatch(/\{ value: 'HIGH', label: 'Haute' \}/)
  })

  it('renders a "Statut" column as a value-coloured pill', () => {
    const files = generate(pillFixture())
    const list = files.find((f) => f.path.endsWith('ContactsListPage.tsx'))!.content
    expect(list).toMatch(/\/actif\|active\|activ\|enabled/)        // positive regex emitted
    expect(list).toMatch(/\.test\(String\(item\.statut \?\? ''\)\)/) // tested on the value
    expect(list).toMatch(/\{String\(item\.statut \?\? ''\)\}<\/Badge>/) // shows the value
    expect(list).toMatch(/tone=\{[^}]*\? 'success' : 'neutral'\}/)
  })

  it('renders boolean pills on the DETAIL page and the FORM readonly field (no badge true/false)', () => {
    const files = generate(pillFixture())
    const detail = files.find((f) => f.path.endsWith('ContactDetailPage.tsx'))!.content
    // Unified fiche: the read grid renders from formData (server-resynced).
    expect(detail).toMatch(/formData\.dureeDeterminee \? <Badge tone="success">/)
    expect(detail).toMatch(/import \{ Badge \} from '@\/components\/ui\/Badge'/)
    expect(detail).toMatch(/\{t\('contact\.common\.yes'\)\}/)
    expect(detail).not.toMatch(/\{String\(data\.dureeDeterminee \?\? ''\)\}/)

    const form = files.find((f) => f.path.endsWith('ContactFormPage.tsx'))!.content
    // 'archived' is readonly → display-only pill, not the old <span className="badge">true</span>
    expect(form).toMatch(/formData\.archived \? <Badge tone="success">/)
    expect(form).not.toMatch(/<span className="badge">\{String\(formData\.archived\)\}<\/span>/)
    // an EDITABLE boolean still renders a Switch (unchanged behaviour)
    expect(form).toMatch(/<Switch/)
  })

  it('drops a redundant row "open" action (onRowClick already opens detail) but keeps genuine actions', () => {
    const files = generate(pillFixture({
      pageSpec: {
        i18nKeys: {},
        actions: [
          { code: 'open', kind: 'navigate', scope: 'row', permission: 'crm.directory.read', labelKey: 'list.actions.open' },
          { code: 'toggle-actif', kind: 'api', scope: 'row', permission: 'crm.directory.update', labelKey: 'list.actions.toggleActif', endpoint: 'toggle-actif' },
          { code: 'view-invoices', kind: 'navigate', scope: 'row', permission: 'crm.directory.read', labelKey: 'list.actions.viewInvoices', targetRoute: 'routes.invoices.list()' },
        ],
      } as unknown as PageSpecMin,
    }))
    const list = files.find((f) => f.path.endsWith('ContactsListPage.tsx'))!.content
    // redundant open → not emitted at all (no handler, no ExternalLink icon)
    expect(list).not.toMatch(/handleOpen\b/)
    expect(list).not.toMatch(/<ExternalLink\b/)
    // genuine API action (toggle) kept
    expect(list).toMatch(/handleToggleActif/)
    expect(list).toMatch(/<ToggleRight\b/)
    // genuine navigate-elsewhere (not the detail) kept
    expect(list).toMatch(/handleViewInvoices/)
    expect(list).toMatch(/navigate\(routes\.invoices\.list\(\)\)/)
    // the row itself still opens the detail
    expect(list).toMatch(/onRowClick=\{\(item\) => navigate\(routes\.\w+\.detail\(item\.id\)\)\}/)
  })

  it('seeds common.yes / common.no in every locale floor', () => {
    const files = generate(pillFixture())
    const read = (loc: string) =>
      JSON.parse(files.find((f) => new RegExp(`/i18n/locales/${loc}/crm\\.json$`).test(f.path))!.content)
    expect(read('fr').contact.common).toEqual({ yes: 'Oui', no: 'Non' })
    expect(read('en').contact.common).toEqual({ yes: 'Yes', no: 'No' })
    expect(read('it').contact.common).toEqual({ yes: 'Sì', no: 'No' })
    expect(read('de').contact.common).toEqual({ yes: 'Ja', no: 'Nein' })
  })
})

describe('scaffold-component / generate — FK never surfaces as a Guid (labels, filters, cross-app)', () => {
  const fkField: ScaffoldComponentInput['fields'][number] = {
    name: 'categoryId',
    type: 'guid',
    required: true,
    fkTo: { entity: 'Category', module: 'todo', apiEndpoint: '/api/todo/categories/lookup' },
  }

  it('floor label of a FK field drops the Id suffix in every locale (Category, not Category Id)', () => {
    const files = generate(fixture({ entity: 'Task', module: 'todo', section: 'tasks', fields: [
      { name: 'title', type: 'string', required: true },
      fkField,
    ] }))
    for (const loc of ['fr', 'en', 'it', 'de']) {
      const json = JSON.parse(files.find((f) => new RegExp(`/i18n/locales/${loc}/todo\.json$`).test(f.path))!.content)
      expect(json.task.form.fields.categoryId).toBe('Category')
      expect(json.task.detail.fields.categoryId).toBe('Category')
      expect(json.task.list.columns.categoryId).toBe('Category')
    }
  })

  it('a non-FK identifier keeps its full floor label (no fkTo → no stripping)', () => {
    const files = generate(fixture({ entity: 'Task', module: 'todo', section: 'tasks', fields: [
      { name: 'title', type: 'string', required: true },
      { name: 'externalId', type: 'string', required: false },
    ] }))
    const fr = JSON.parse(files.find((f) => /\/i18n\/locales\/fr\/todo\.json$/.test(f.path))!.content)
    expect(fr.task.form.fields.externalId).toBe('External Id')
  })

  it('a filter on a FK field renders a server-searching <EntityLookup>, whatever control the PRD said', () => {
    const ps = pageSpecFixture({
      entity: 'Task',
      columns: [{ key: 'title', labelKey: 'list.columns.title', sortable: true }],
      // The test-RH shipped shape: control "select" without options on a FK →
      // used to degrade to a free-text input matching the raw Guid.
      filters: [
        { field: 'categoryId', labelKey: 'list.filters.category', control: 'select' },
        { field: 'title', labelKey: 'list.filters.title', control: 'text' },
      ],
    } as Parameters<typeof pageSpecFixture>[0])
    const files = generate(fixture({ entity: 'Task', module: 'todo', section: 'tasks', views: ['list'], pageSpec: ps, fields: [
      { name: 'title', type: 'string', required: true },
      fkField,
    ] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!.content
    expect(list).toMatch(/import \{ EntityLookup \} from '@\/components\/ui\/EntityLookup'/)
    expect(list).toMatch(/apiEndpoint="\/api\/todo\/categories\/lookup"/)
    expect(list).toMatch(/value=\{filters\['categoryId'\] \|\| null\}/)
    expect(list).toMatch(/onChange=\{\(id\) => onFilterChange\('categoryId', id \?\? ''\)\}/)
    // The selected Guid rides the SERVER args as an exact id param — never a
    // substring match against the Guid, never an in-memory matcher.
    expect(list).toMatch(/categoryId: debouncedFilters\['categoryId'\] \|\| undefined/)
    expect(list).not.toMatch(/filters\['categoryId'\]\.toLowerCase\(\)/)
    // No EnumSelect import for the promoted filter (it is not a select anymore).
    expect(list).not.toMatch(/import \{ EnumSelect \}/)
    // The plain text filter on a non-FK field rides the server args too.
    expect(list).toMatch(/title: debouncedFilters\['title'\] \|\| undefined/)
  })

  it('a `control: "lookup"` filter renders <EntityLookup> too', () => {
    const ps = pageSpecFixture({
      entity: 'Task',
      columns: [{ key: 'title', labelKey: 'list.columns.title', sortable: true }],
      filters: [{ field: 'categoryId', labelKey: 'list.filters.category', control: 'lookup' }],
    } as Parameters<typeof pageSpecFixture>[0])
    const files = generate(fixture({ entity: 'Task', module: 'todo', section: 'tasks', views: ['list'], pageSpec: ps, fields: [
      { name: 'title', type: 'string', required: true },
      fkField,
    ] }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!.content
    expect(list).toMatch(/<EntityLookup/)
    expect(list).toMatch(/apiEndpoint="\/api\/todo\/categories\/lookup"/)
  })

  it('cross-app FK: the lookup hook imports from the TARGET app segment (fkTo.app)', () => {
    const files = generate(fixture({ entity: 'Projet', module: 'projets', section: 'list', views: ['list', 'detail'], fields: [
      { name: 'label', type: 'string', required: true },
      { name: 'clientId', type: 'guid', required: true, fkTo: { entity: 'Client', app: 'client', module: 'annuaire', apiEndpoint: '/api/annuaire/list/lookup' } },
    ] }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!.content
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!.content
    for (const c of [detail, list]) {
      expect(c).toMatch(/import \{ useClientLookup \} from '@\/features\/client\/annuaire\/client\/hooks\/useClient'/)
      expect(c).not.toMatch(/@\/features\/testv2\/annuaire/)
    }
  })

  it('same-app FK keeps the importing page appCode (fkTo.app absent — legacy specs unchanged)', () => {
    const files = generate(fixture({ entity: 'Task', module: 'todo', section: 'tasks', views: ['detail'], entityViews: ['list', 'detail'], fields: [fkField] }))
    const detail = files.find((f) => /DetailPage\.tsx$/.test(f.path))!.content
    expect(detail).toMatch(/import \{ useCategoryLookup \} from '@\/features\/testv2\/todo\/category\/hooks\/useCategory'/)
  })
})

describe('scaffold-component / field-label floor dictionary + lookup placeholders', () => {
  const orgFk = {
    name: 'OrganisationId',
    type: 'guid',
    required: true,
    fkTo: { entity: 'Organisation', module: 'crm', apiEndpoint: '/api/crm/organisations/lookup' },
  }
  const localeJson = (files: ReturnType<typeof generate>, loc: string) =>
    JSON.parse(files.find((f) => new RegExp(`/i18n/locales/${loc}/crm\\.json$`).test(f.path))!.content)

  it('localises ubiquitous field names PER locale (the AtlasHub "Name on a French form" bug)', () => {
    const files = generate(fixture({ entity: 'Client', module: 'crm', section: 'clients', fields: [
      { name: 'Name', type: 'string', required: true },
      { name: 'Libelle', type: 'string', required: false },
    ] }))
    expect(localeJson(files, 'fr').client.form.fields.name).toBe('Nom')
    expect(localeJson(files, 'en').client.form.fields.name).toBe('Name')
    expect(localeJson(files, 'it').client.form.fields.name).toBe('Nome')
    expect(localeJson(files, 'de').client.form.fields.name).toBe('Name')
    // The same floor feeds list columns and detail fields.
    expect(localeJson(files, 'fr').client.list.columns.name).toBe('Nom')
    expect(localeJson(files, 'fr').client.detail.fields.name).toBe('Nom')
    // A business-specific name stays humanised (the dictionary never guesses).
    expect(localeJson(files, 'fr').client.form.fields.libelle).toBe('Libelle')
  })

  it('a PRD i18nKeys override still wins over the dictionary floor', () => {
    const files = generate(fixture({ entity: 'Client', module: 'crm', section: 'clients',
      pageSpec: { i18nKeys: { fr: { 'form.fields.Name': 'Raison sociale' } } } as unknown as PageSpecMin,
      fields: [{ name: 'Name', type: 'string', required: true }],
    }))
    expect(localeJson(files, 'fr').client.form.fields.name).toBe('Raison sociale')
    expect(localeJson(files, 'en').client.form.fields.name).toBe('Name')
  })

  it('FK lookups get a contextual per-locale search placeholder through the form.placeholders sibling channel', () => {
    const files = generate(fixture({ entity: 'Client', module: 'crm', section: 'clients', fields: [
      { name: 'Name', type: 'string', required: true },
      orgFk,
    ] }))
    const form = files.find((f) => /FormPage\.tsx$/.test(f.path))!.content
    expect(form).toMatch(/placeholder=\{t\('client\.form\.placeholders\.organisationId'\)\}/)
    expect(localeJson(files, 'fr').client.form.placeholders.organisationId).toBe('Rechercher : Organisation…')
    expect(localeJson(files, 'en').client.form.placeholders.organisationId).toBe('Search Organisation…')
    expect(localeJson(files, 'it').client.form.placeholders.organisationId).toBe('Cerca Organizzazione…')
    expect(localeJson(files, 'de').client.form.placeholders.organisationId).toBe('Organisation suchen…')
    // Non-FK fields get no placeholder entry.
    expect(localeJson(files, 'fr').client.form.placeholders.name).toBeUndefined()
  })

  it('a legacy PRD form.fields.<x>.options.<v> key remaps to form.options.<x>.<v> instead of being dropped', () => {
    const files = generate(fixture({ entity: 'Client', module: 'crm', section: 'clients',
      pageSpec: { i18nKeys: { fr: { 'form.fields.name.options.x': 'X' } } } as unknown as PageSpecMin,
      fields: [{ name: 'Name', type: 'string', required: true }],
    }))
    const fr = localeJson(files, 'fr')
    // The label leaf survives AND the authored option label ships in the sibling branch
    // (it used to be silently dropped by the leaf-wins rule — never translatable).
    expect(fr.client.form.fields.name).toBe('Nom')
    expect(fr.client.form.options.name.x).toBe('X')
  })

  it('a stray non-remappable PRD key nested under a label leaf can never destroy the label (leaf wins)', () => {
    const files = generate(fixture({ entity: 'Client', module: 'crm', section: 'clients',
      pageSpec: { i18nKeys: { fr: { 'list.title.extra': 'X' } } } as unknown as PageSpecMin,
      fields: [{ name: 'Name', type: 'string', required: true }],
    }))
    // Before the flatToNested hardening this shipped list.title = { extra: 'X' } → raw key on screen.
    expect(localeJson(files, 'fr').client.list.title).toBe('Clients')
  })

  it('legacy form.fields.<x>.placeholder PRD keys remap to form.placeholders.<x> instead of clobbering the label', () => {
    const files = generate(fixture({ entity: 'Client', module: 'crm', section: 'clients',
      pageSpec: { i18nKeys: { fr: { 'form.fields.OrganisationId.placeholder': 'Choisir une organisation…' } } } as unknown as PageSpecMin,
      fields: [orgFk],
    }))
    const fr = localeJson(files, 'fr')
    expect(fr.client.form.placeholders.organisationId).toBe('Choisir une organisation…')
    expect(fr.client.form.fields.organisationId).toBe('Organisation')
  })
})

describe('scaffold-component / odd-run grid balancing + fullWidth', () => {
  const formOf = (fields: ScaffoldComponentInput['fields'], overrides: Partial<ScaffoldComponentInput> = {}) => {
    const files = generate(fixture({ entity: 'Card', module: 'demo', section: 'cards', views: ['form'], fields, ...overrides }))
    return files.find((f) => /FormPage\.tsx$/.test(f.path))!.content
  }
  const spans = (c: string) => (c.match(/md:col-span-2/g) ?? []).length
  const str = (name: string, extra: Record<string, unknown> = {}) => ({ name, type: 'string', required: false, ...extra })

  it('an odd run of half-width cells promotes its LAST cell to md:col-span-2 (the 3-field orphan)', () => {
    const c = formOf([str('a'), str('b'), str('c')])
    expect(spans(c)).toBe(1)
    // The promoted cell wraps field c — the last of the run — not a or b.
    const afterSpan = c.slice(c.indexOf('md:col-span-2'))
    expect(afterSpan.slice(0, 400)).toMatch(/form\.fields\.c/)
  })

  it('an even run needs no promotion', () => {
    expect(spans(formOf([str('a'), str('b')]))).toBe(0)
  })

  it('full-width cells delimit the runs (half + textarea + half + half → the leading half closes flush)', () => {
    const c = formOf([str('a'), str('desc', { control: 'textarea' }), str('b'), str('c')])
    // a promoted (run of 1) + the textarea itself = 2 spans; the trailing even pair stays half.
    expect(spans(c)).toBe(2)
    const firstSpan = c.slice(c.indexOf('md:col-span-2'))
    expect(firstSpan.slice(0, 400)).toMatch(/form\.fields\.a/)
  })

  it('single-column layout never promotes', () => {
    const c = formOf([str('a'), str('b'), str('c')], { formLayout: 'single-column' })
    expect(spans(c)).toBe(0)
  })

  it('fullWidth: false forbids the balancing promotion', () => {
    expect(spans(formOf([str('a'), str('b'), str('c', { fullWidth: false })]))).toBe(0)
  })

  it('fullWidth: true forces the span and delimits the run like a textarea', () => {
    // a(full) | run [b, c] even → exactly the forced span.
    expect(spans(formOf([str('a', { fullWidth: true }), str('b'), str('c')]))).toBe(1)
  })

  it('self-guarding visibleWhen cells are neither counted nor promoted', () => {
    // c may not render at all → the static run is [a, b], even → no promotion.
    const c = formOf([str('a'), str('b'), str('c', { visibleWhen: "a === 'x'" })])
    expect(spans(c)).toBe(0)
  })

  it('the uiDesign overlay can set fullWidth (judgment replayed on every regen)', () => {
    const c = formOf([str('a'), str('b'), str('c')], {
      pageSpec: { i18nKeys: {}, uiDesign: { fields: { c: { fullWidth: true } } } } as unknown as PageSpecMin,
    })
    // c is forced full-width; the remaining run [a, b] is even → single span, on c.
    expect(spans(c)).toBe(1)
    const afterSpan = c.slice(c.indexOf('md:col-span-2'))
    expect(afterSpan.slice(0, 400)).toMatch(/form\.fields\.c/)
  })
})

describe('scaffold-component / BA tabs[] → form sections seeding', () => {
  const formOf = (overrides: Partial<ScaffoldComponentInput>) => {
    const files = generate(fixture({ entity: 'Employee', module: 'hr', section: 'employees', views: ['form'], ...overrides }))
    return files.find((f) => /FormPage\.tsx$/.test(f.path))!.content
  }
  const fields = [
    { name: 'firstName', type: 'string', required: true },
    { name: 'lastName', type: 'string', required: true },
    { name: 'hireDate', type: 'date', required: false },
  ]
  const tabsSpec = {
    i18nKeys: {},
    tabs: [
      { key: 'identity', labelKey: 'form.section.identity', fields: ['firstName', 'lastName'] },
      { key: 'contract', labelKey: 'form.section.contract', fields: ['hireDate'] },
    ],
  } as unknown as PageSpecMin

  it('a form pagespec carrying BA tabs renders one titled card per tab', () => {
    const c = formOf({ fields, pageSpec: tabsSpec })
    expect(c).toMatch(/t\('employee\.form\.section\.identity', \{ defaultValue: 'Identity' \}\)/)
    expect(c).toMatch(/t\('employee\.form\.section\.contract', \{ defaultValue: 'Contract' \}\)/)
    expect(c.indexOf('section.identity')).toBeLessThan(c.indexOf('section.contract'))
    // The tab keys land in the i18n floor too — no raw form.section.<x> at runtime.
    const files = generate(fixture({ entity: 'Employee', module: 'hr', section: 'employees', views: ['form'], fields, pageSpec: tabsSpec }))
    const fr = JSON.parse(files.find((f) => /\/i18n\/locales\/fr\/hr\.json$/.test(f.path))!.content)
    expect(fr.employee.form.section.identity).toBe('Identity')
  })

  it('the uiDesign overlay wins over the tab seed (explicit judgment beats propagation)', () => {
    const c = formOf({
      fields,
      pageSpec: {
        ...(tabsSpec as unknown as Record<string, unknown>),
        uiDesign: { fields: { hireDate: { section: 'identity' } } },
      } as unknown as PageSpecMin,
    })
    // hireDate is pulled into identity → the contract card has no field left and
    // is never emitted as a separate titled section for hireDate.
    const identityIdx = c.indexOf('section.identity')
    expect(identityIdx).toBeGreaterThan(-1)
    const identityCard = c.slice(identityIdx, c.indexOf('</section>', identityIdx))
    expect(identityCard).toMatch(/form\.fields\.hireDate/)
  })

  it('a form pagespec without tabs is unchanged (single sober card)', () => {
    const c = formOf({ fields, pageSpec: { i18nKeys: {} } as unknown as PageSpecMin })
    expect(c).not.toMatch(/form\.section\./)
  })
})

describe('scaffold-component / generate — cross-view navigation gate (list-only entity)', () => {
  // The client-run TS2339 family: a list-only entity used to get create/edit
  // buttons + onRowClick against routes.{x}.edit/create/detail helpers
  // scaffold-routes never emitted (its family declares only list()).
  const listPage = (files: ReturnType<typeof generate>) =>
    files.find((f) => f.path.endsWith('ListPage.tsx'))!.content

  it('a list-only entity emits NO create/edit buttons and NO row navigation', () => {
    const files = generate(fixture({ views: ['list'], entityViews: ['list'] }))
    const list = listPage(files)
    expect(list).not.toContain('routes.directory.edit(')
    expect(list).not.toContain('routes.directory.create()')
    expect(list).not.toContain('routes.directory.detail(')
    expect(list).not.toContain('onRowClick')
  })

  it('detail without form: rows open the detail but no edit/create affordance', () => {
    const files = generate(fixture({ views: ['list'], entityViews: ['list', 'detail'] }))
    const list = listPage(files)
    expect(list).toContain('routes.directory.detail(')
    expect(list).not.toContain('routes.directory.edit(')
    expect(list).not.toContain('routes.directory.create()')
  })

  it('regen: the emitted Routes.ts family is intersected in — declared form but no edit() helper → suppressed + warning', () => {
    const ctx = { warnings: [] as string[], routesFamilies: { 'testv2-crm': { directory: ['list', 'detail'] } } }
    const files = generate(fixture({ views: ['list'] }), ctx)
    const list = listPage(files)
    expect(list).toContain('routes.directory.detail(')
    expect(list).not.toContain('routes.directory.edit(')
    expect(ctx.warnings.some((w) => w.includes("no 'edit()' helper"))).toBe(true)
  })

  it('detail page without a form sibling omits the Edit button but keeps Delete', () => {
    const files = generate(fixture({ views: ['detail'], entityViews: ['list', 'detail'] }))
    const detail = files.find((f) => f.path.endsWith('DetailPage.tsx'))!.content
    expect(detail).not.toContain('data-testid="detail-action-edit"')
    expect(detail).toContain('data-testid="detail-action-delete"')
  })

  // Client defect 2026-08-25 #6 — the gate above traded TS2339 for TS6133:
  // the affordances were suppressed but their imports stayed. Under strict
  // noUnusedLocals, every list-only page failed the type-check on Plus/Pencil/
  // routes/navigate. Imports now follow the same gates as the rendering.
  it('a list-only entity emits NO unused navigation imports (TS6133 guard)', () => {
    const files = generate(fixture({ views: ['list'], entityViews: ['list'] }))
    const list = listPage(files)
    expect(list).not.toMatch(/\bPlus\b/)
    expect(list).not.toMatch(/\bPencil\b/)
    expect(list).not.toContain("from 'react-router-dom'")
    expect(list).not.toContain('const navigate = useNavigate()')
    expect(list).not.toMatch(/import \{ routes \}/)
    // The unconditional affordances survive.
    expect(list).toMatch(/\bTrash2\b/)
  })

  it('detail-only navigation keeps navigate/routes but not Plus/Pencil', () => {
    const files = generate(fixture({ views: ['list'], entityViews: ['list', 'detail'] }))
    const list = listPage(files)
    expect(list).toContain("import { useNavigate } from 'react-router-dom'")
    expect(list).toContain('const navigate = useNavigate()')
    expect(list).toMatch(/import \{ routes \}/)
    expect(list).not.toMatch(/\bPlus\b/)
    expect(list).not.toMatch(/\bPencil\b/)
  })

  it('full entity (form + detail) keeps Plus, Pencil, routes and navigate', () => {
    const files = generate(fixture({ views: ['list'], entityViews: ['list', 'detail', 'form'] }))
    const list = listPage(files)
    expect(list).toMatch(/\bPlus\b/)
    expect(list).toMatch(/\bPencil\b/)
    expect(list).toContain('const navigate = useNavigate()')
  })

  it('a board on a list-only entity emits no navigate import/binding (cards not clickable)', () => {
    const ps = kanbanPageSpec()
    ps.actions = ps.actions.filter(a => a.code !== 'create')
    const files = generate(fixture({
      fields: KANBAN_FIELDS,
      views: ['list'],
      entityViews: ['list'],
      pageSpec: ps,
    }))
    const list = files.find((f) => /ListPage\.tsx$/.test(f.path))!.content
    expect(list).toMatch(/data-testid="list-kanban-board"/)
    expect(list).not.toContain('const navigate = useNavigate()')
    expect(list).toMatch(/\/\* no detail view for this entity \*\//)
  })
})