@softize/opus 28.0.0 → 30.0.0

package/bin/lib/copy.mjs

@@ -54,6 +54,7 @@ const IGNORED_FILE = /(?:\.d|\.spec|\.test|\.stories)\.[cm]?[jt]sx?$/u
 // inclusive adições futuras, pertence à versão instalada da Base.
 const COPY_RULE_ID = /^COPY\d{3}$/u
 const COPY_DYNAMIC_KINDS = new Set(['message-template', 'runtime-data'])
+const COPY_EXPRESSION_LIMIT = 200
 const COPY_ROLES = new Set([
   'badge',
   'breadcrumb',
@@ -914,7 +915,7 @@ function stableReferences(binding, checker, mode, stack) {
 
 /**
  * Um parâmetro de callback (ou variável de `for…of`) é somente leitura quando cada uso é
- * `elemento.chave` fora de posição de atribuição. Strings são imutáveis, então uma leitura de
+ * `element.key` fora de posição de atribuição. Strings são imutáveis, então uma leitura de
  * propriedade nunca altera o rótulo literal; qualquer outro uso (spread, argumento, retorno,
  * atribuição) poderia mutar ou fazer o objeto escapar e é rejeitado. Destructuring copia os
  * valores de primeiro nível e, por isso, também não alcança o literal.
@@ -1048,7 +1049,7 @@ function elementSource(identifier, checker) {
 }
 
 /**
- * Resolve `elemento.chave` (ou a chave destruturada) para o texto literal de cada elemento
+ * Resolve `element.key` (ou a chave destruturada) para o texto literal de cada elemento
  * do array de origem. Um único elemento opaco ou sem texto estático torna o conjunto todo
  * inextraível: o inventário não pode listar só parte do que a superfície renderiza.
  */
@@ -1387,15 +1388,37 @@ function lineOf(sourceFile, node) {
   return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1
 }
 
+/**
+ * Trecho que identifica o diagnóstico em `copy.dynamic` sem depender da linha. Espaços são
+ * normalizados para a âncora sobreviver a reformatação; trechos longos são cortados de forma
+ * determinística, porque o seletor só precisa distinguir, não reproduzir, o código.
+ */
+function anchorExpression(sourceFile, node) {
+  const text = node
+    .getText(sourceFile)
+    .replace(/\s+/gu, ' ')
+    .replace(/,(\s*)(?=[)\]}])/gu, '$1')
+    .trim()
+  return text.length > COPY_EXPRESSION_LIMIT ? `${text.slice(0, COPY_EXPRESSION_LIMIT)}…` : text
+}
+
 function diagnostic(file, sourceFile, node, field, category = 'content') {
+  const expression = anchorExpression(sourceFile, node)
+  // Só diagnóstico de conteúdo é declarável em copy.dynamic; o trecho é a âncora da declaração.
+  const declarable =
+    category === 'content'
+      ? ` Se o valor vem da aplicação, declare-o em copy.dynamic com field "${field}" e expression ${JSON.stringify(expression)}.`
+      : ''
   return {
     source: file,
     line: lineOf(sourceFile, node),
     field,
+    expression,
     category,
     message:
       `não foi possível extrair \`${field}\` estaticamente; use texto literal, concatenação ` +
-      'de literais, constante local ou I18nRef com `default` literal.',
+      'de literais, constante local ou I18nRef com `default` literal.' +
+      declarable,
   }
 }
 
@@ -2796,8 +2819,8 @@ function copyConfiguration(root) {
   }
 }
 
-function selectorDiagnostic(message) {
-  return { source: 'base.json', line: 1, message }
+function selectorDiagnostic(message, selector) {
+  return selector === undefined ? { source: 'base.json', line: 1, message } : { source: 'base.json', line: 1, message, selector }
 }
 
 function sameProjectFile(left, right) {
@@ -2841,18 +2864,50 @@ function verifyCopyInputs(root, consistency) {
   verifyConfiguration(root, consistency.configFile)
 }
 
+/**
+ * Seletores de `copy.exemptions` e `copy.transforms`. Sem `line`, o seletor é pelo conteúdo
+ * (`source` + `role` + `text`) e vale para toda ocorrência desse texto com esse papel no
+ * arquivo; com `line`, é o formato anterior, que seleciona um único texto naquela linha.
+ */
 function findEntry(entries, selector) {
   return entries
     .map((entry, index) => ({ entry, index }))
     .filter(
       ({ entry }) =>
         entry.source === selector.source &&
-        entry.line === selector.line &&
+        (selector.line === undefined || entry.line === selector.line) &&
         entry.role === selector.role &&
         (selector.text === undefined || entry.text === selector.text),
     )
 }
 
+function validTextSelector(selector) {
+  if (typeof selector.source !== 'string' || typeof selector.role !== 'string') return false
+  if (selector.line === undefined) return typeof selector.text === 'string' && selector.text !== ''
+  return Number.isInteger(selector.line) && (selector.text === undefined || typeof selector.text === 'string')
+}
+
+function describeTextSelector(selector) {
+  const text = selector.text === undefined ? '' : ` "${selector.text}"`
+  return selector.line === undefined
+    ? `o texto${text} (${selector.role}) em ${selector.source}`
+    : `o texto${text} (${selector.role}) na linha ${selector.line} de ${selector.source}`
+}
+
+function missingTextSelector(list, index, selector, matches) {
+  if (selector.line === undefined) {
+    return selectorDiagnostic(
+      `copy.${list}[${index}] não encontra ${describeTextSelector(selector)}; o texto mudou ou saiu do arquivo — atualize ou remova a declaração.`,
+      { list, index },
+    )
+  }
+  return selectorDiagnostic(
+    `copy.${list}[${index}] deve selecionar exatamente um texto; encontrou ${matches.length} para ${describeTextSelector(selector)}. ` +
+      'A âncora por linha quebra a cada edição acima dela: rode `opus copy --reanchor` para ancorar pelo texto.',
+    { list, index },
+  )
+}
+
 function canonicalSource(value) {
   return (
     typeof value === 'string' &&
@@ -2870,18 +2925,54 @@ function canonicalSource(value) {
   )
 }
 
-function applyDynamicMetadata(config, entries, diagnostics) {
+function validExpression(value) {
+  return (
+    typeof value === 'string' &&
+    value !== '' &&
+    value === value.trim() &&
+    !/\s{2,}|[\r\n\t]/u.test(value) &&
+    value.length <= COPY_EXPRESSION_LIMIT + 1
+  )
+}
+
+function describeDynamicSelector(declaration) {
+  return declaration.expression === undefined
+    ? `\`${declaration.field}\` na linha ${declaration.line} de ${declaration.source}`
+    : `\`${declaration.field}\` com o trecho \`${declaration.expression}\` em ${declaration.source}`
+}
+
+function pendingDynamicHint(candidates) {
+  if (candidates.length === 0) {
+    return ' Nenhum diagnóstico desse campo está pendente no arquivo; se o código passou a ser estático, remova a declaração.'
+  }
+  const listed = candidates
+    .slice(0, 5)
+    .map(({ item }) => `\`${item.expression}\` (linha ${item.line})`)
+    .join(', ')
+  const more = candidates.length > 5 ? ` e mais ${candidates.length - 5}` : ''
+  return ` Diagnósticos desse campo ainda sem declaração: ${listed}${more}.`
+}
+
+/**
+ * `copy.dynamic` seleciona diagnósticos de conteúdo. O seletor por `expression` sobrevive a
+ * edições em outras linhas e cobre toda ocorrência do mesmo trecho no mesmo campo do arquivo;
+ * o seletor por `line` (formato anterior) cobre exatamente um diagnóstico. Os seletores por
+ * linha consomem primeiro, para que uma declaração pontual não seja engolida por uma geral.
+ */
+function applyDynamicMetadata(config, entries, diagnostics, analyzed) {
   const surfaces = []
   if (!Array.isArray(config.dynamic)) {
     diagnostics.push(selectorDiagnostic('copy.dynamic deve ser uma lista.'))
     return surfaces
   }
   const consumed = new Set()
+  const valid = []
   for (const [index, declaration] of config.dynamic.entries()) {
     const template = declaration?.kind === 'message-template'
     const allowedFields = new Set([
       'source',
       'line',
+      'expression',
       'field',
       'kind',
       'reason',
@@ -2890,14 +2981,17 @@ function applyDynamicMetadata(config, entries, diagnostics) {
     ])
     const normalizedReason = typeof declaration?.reason === 'string' ? declaration.reason.trim() : ''
     const normalizedReference = typeof declaration?.reference === 'string' ? declaration.reference.trim() : ''
+    const byLine = declaration?.line !== undefined
+    const byExpression = declaration?.expression !== undefined
     if (
       declaration === null ||
       typeof declaration !== 'object' ||
       Array.isArray(declaration) ||
       Object.keys(declaration).some((field) => !allowedFields.has(field)) ||
       !canonicalSource(declaration.source) ||
-      !Number.isInteger(declaration.line) ||
-      declaration.line < 1 ||
+      byLine === byExpression ||
+      (byLine && (!Number.isInteger(declaration.line) || declaration.line < 1)) ||
+      (byExpression && !validExpression(declaration.expression)) ||
       typeof declaration.field !== 'string' ||
       declaration.field.trim() === '' ||
       !COPY_DYNAMIC_KINDS.has(declaration.kind) ||
@@ -2919,34 +3013,58 @@ function applyDynamicMetadata(config, entries, diagnostics) {
     ) {
       diagnostics.push(
         selectorDiagnostic(
-          `copy.dynamic[${index}] exige seletor, kind, reason e reference válidos` +
+          `copy.dynamic[${index}] exige source, expression (ou line, no formato anterior), field, kind, reason e reference válidos` +
             (template ? ', além de text e role para message-template.' : '.'),
+          { list: 'dynamic', index },
         ),
       )
       continue
     }
-    const matches = diagnostics
+    valid.push({ index, declaration, template, normalizedReason, normalizedReference })
+  }
+  const ordered = [
+    ...valid.filter(({ declaration }) => declaration.expression === undefined),
+    ...valid.filter(({ declaration }) => declaration.expression !== undefined),
+  ]
+  const accepted = new Map()
+  for (const { index, declaration, template, normalizedReason, normalizedReference } of ordered) {
+    const candidates = diagnostics
       .map((item, diagnosticIndex) => ({ item, diagnosticIndex }))
       .filter(
         ({ item, diagnosticIndex }) =>
           !consumed.has(diagnosticIndex) &&
           item.category === 'content' &&
           item.source === declaration.source &&
-          item.line === declaration.line &&
           item.field === declaration.field,
       )
-    if (matches.length !== 1) {
+    const matches =
+      declaration.expression === undefined
+        ? candidates.filter(({ item }) => item.line === declaration.line)
+        : candidates.filter(({ item }) => item.expression === declaration.expression)
+    if (matches.length === 0 || (declaration.expression === undefined && matches.length > 1)) {
+      const reanchor =
+        declaration.expression === undefined
+          ? ' A âncora por linha quebra a cada edição acima dela: rode `opus copy --reanchor` para ancorar pelo trecho.'
+          : ''
       diagnostics.push(
         selectorDiagnostic(
-          `copy.dynamic[${index}] deve selecionar exatamente um diagnóstico de extração; encontrou ${matches.length}.`,
+          `copy.dynamic[${index}] deve selecionar ${declaration.expression === undefined ? 'exatamente' : 'ao menos'} um diagnóstico de extração; encontrou ${matches.length} para ${describeDynamicSelector(declaration)}.` +
+            (analyzed !== undefined && !analyzed.has(declaration.source)
+              ? ' O arquivo não existe ou está fora do escopo do inventário; atualize o caminho ou remova a declaração.'
+              : pendingDynamicHint(candidates)) +
+            reanchor,
+          { list: 'dynamic', index },
         ),
       )
       continue
     }
-    consumed.add(matches[0].diagnosticIndex)
+    for (const { diagnosticIndex } of matches) consumed.add(diagnosticIndex)
+    const lines = matches.map(({ item }) => item.line).sort((left, right) => left - right)
     const surface = {
       source: declaration.source,
-      line: declaration.line,
+      ...(declaration.expression === undefined
+        ? { line: declaration.line }
+        : { expression: declaration.expression, lines }),
       field: declaration.field,
       kind: declaration.kind,
       reason: normalizedReason,
@@ -2955,20 +3073,24 @@ function applyDynamicMetadata(config, entries, diagnostics) {
     if (template) {
       surface.role = declaration.role
       surface.text = declaration.text
-      entries.push({
-        source: declaration.source,
-        line: declaration.line,
-        role: declaration.role,
-        text: declaration.text,
-        dynamic: {
-          kind: declaration.kind,
-          field: declaration.field,
-          reference: normalizedReference,
-        },
-      })
+      for (const line of lines) {
+        entries.push({
+          source: declaration.source,
+          line,
+          role: declaration.role,
+          text: declaration.text,
+          dynamic: {
+            kind: declaration.kind,
+            field: declaration.field,
+            reference: normalizedReference,
+          },
+        })
+      }
     }
-    surfaces.push(surface)
+    accepted.set(index, surface)
   }
+  // A ordem do inventário segue a do base.json, não a ordem de consumo.
+  for (const { index } of valid) if (accepted.has(index)) surfaces.push(accepted.get(index))
   if (consumed.size > 0) {
     const remaining = diagnostics.filter((_, index) => !consumed.has(index))
     diagnostics.splice(0, diagnostics.length, ...remaining)
@@ -2976,8 +3098,8 @@ function applyDynamicMetadata(config, entries, diagnostics) {
   return surfaces
 }
 
-function applyProjectMetadata(config, entries, diagnostics) {
-  const dynamicSurfaces = applyDynamicMetadata(config, entries, diagnostics)
+function applyProjectMetadata(config, entries, diagnostics, analyzed) {
+  const dynamicSurfaces = applyDynamicMetadata(config, entries, diagnostics, analyzed)
   if (!Array.isArray(config.exemptions)) {
     diagnostics.push(selectorDiagnostic('copy.exemptions deve ser uma lista.'))
   } else {
@@ -2985,9 +3107,7 @@ function applyProjectMetadata(config, entries, diagnostics) {
       if (
         exemption === null ||
         typeof exemption !== 'object' ||
-        typeof exemption.source !== 'string' ||
-        !Number.isInteger(exemption.line) ||
-        typeof exemption.role !== 'string' ||
+        !validTextSelector(exemption) ||
         typeof exemption.ruleId !== 'string' ||
         !COPY_RULE_ID.test(exemption.ruleId) ||
         typeof exemption.kind !== 'string' ||
@@ -2997,32 +3117,38 @@ function applyProjectMetadata(config, entries, diagnostics) {
         typeof exemption.reference !== 'string' ||
         exemption.reference.trim() === ''
       ) {
-        diagnostics.push(
-          selectorDiagnostic(`copy.exemptions[${index}] exige seletor, ruleId, kind, reason e reference válidos.`),
-        )
-        continue
-      }
-      const matches = findEntry(entries, exemption)
-      if (matches.length !== 1) {
         diagnostics.push(
           selectorDiagnostic(
-            `copy.exemptions[${index}] deve selecionar exatamente um texto; encontrou ${matches.length}.`,
+            `copy.exemptions[${index}] exige source, role, text (ou line, no formato anterior), ruleId, kind, reason e reference válidos.`,
+            { list: 'exemptions', index },
           ),
         )
         continue
       }
-      const target = entries[matches[0].index]
-      target.exemptions ??= []
-      if (target.exemptions.some((item) => item.ruleId === exemption.ruleId)) {
-        diagnostics.push(selectorDiagnostic(`copy.exemptions[${index}] repete ${exemption.ruleId} no mesmo texto.`))
+      const matches = findEntry(entries, exemption)
+      if (matches.length === 0 || (exemption.line !== undefined && matches.length > 1)) {
+        diagnostics.push(missingTextSelector('exemptions', index, exemption, matches))
         continue
       }
-      target.exemptions.push({
-        ruleId: exemption.ruleId,
-        kind: exemption.kind.trim(),
-        reason: exemption.reason.trim(),
-        reference: exemption.reference.trim(),
-      })
+      for (const { index: entryIndex } of matches) {
+        const target = entries[entryIndex]
+        target.exemptions ??= []
+        if (target.exemptions.some((item) => item.ruleId === exemption.ruleId)) {
+          diagnostics.push(
+            selectorDiagnostic(
+              `copy.exemptions[${index}] repete ${exemption.ruleId} no texto "${target.text}" da linha ${target.line} de ${target.source}.`,
+              { list: 'exemptions', index },
+            ),
+          )
+          continue
+        }
+        target.exemptions.push({
+          ruleId: exemption.ruleId,
+          kind: exemption.kind.trim(),
+          reason: exemption.reason.trim(),
+          reference: exemption.reference.trim(),
+        })
+      }
     }
   }
 
@@ -3038,38 +3164,43 @@ function applyProjectMetadata(config, entries, diagnostics) {
       if (
         transform === null ||
         typeof transform !== 'object' ||
-        typeof transform.source !== 'string' ||
-        !Number.isInteger(transform.line) ||
-        typeof transform.role !== 'string' ||
+        !validTextSelector(transform) ||
         !['none', 'lowercase', 'uppercase'].includes(transform.transform)
       ) {
-        diagnostics.push(selectorDiagnostic(`copy.transforms[${index}] tem seletor ou transform inválido.`))
+        diagnostics.push(
+          selectorDiagnostic(`copy.transforms[${index}] tem seletor ou transform inválido.`, {
+            list: 'transforms',
+            index,
+          }),
+        )
         continue
       }
       const matches = findEntry(entries, transform)
-      if (matches.length !== 1) {
+      if (matches.length === 0 || (transform.line !== undefined && matches.length > 1)) {
+        diagnostics.push(missingTextSelector('transforms', index, transform, matches))
+        continue
+      }
+      const overriding = matches.find(({ index: entryIndex }) => transformed.has(entryIndex))
+      if (overriding !== undefined) {
         diagnostics.push(
           selectorDiagnostic(
-            `copy.transforms[${index}] deve selecionar exatamente um texto; encontrou ${matches.length}.`,
+            `copy.transforms[${index}] tenta sobrescrever um texto já transformado (linha ${overriding.entry.line} de ${overriding.entry.source}).`,
+            { list: 'transforms', index },
           ),
         )
         continue
       }
-      const entryIndex = matches[0].index
-      if (transformed.has(entryIndex)) {
-        diagnostics.push(selectorDiagnostic(`copy.transforms[${index}] tenta sobrescrever um texto já transformado.`))
-        continue
+      for (const { index: entryIndex } of matches) {
+        transformed.add(entryIndex)
+        entries[entryIndex].transform = transform.transform
       }
-      transformed.add(entryIndex)
-      entries[entryIndex].transform = transform.transform
     }
   }
   return dynamicSurfaces
 }
 
-export function extractCopyInventory(root) {
-  const target = path.resolve(root)
-  const config = copyConfiguration(target)
+/** Lê e extrai cada source do escopo, sem aplicar as declarações do `base.json`. */
+function collectCopySources(target, config) {
   const sources = []
   const sourceSnapshots = []
   const entries = []
@@ -3123,6 +3254,13 @@ export function extractCopyInventory(root) {
       })
     }
   }
+  return { sources, sourceSnapshots, entries, diagnostics, discovered, excluded }
+}
+
+export function extractCopyInventory(root) {
+  const target = path.resolve(root)
+  const config = copyConfiguration(target)
+  const { sources, sourceSnapshots, entries, diagnostics, discovered, excluded } = collectCopySources(target, config)
   try {
     verifyConfiguration(target, config.configFile)
   } catch (error) {
@@ -3135,7 +3273,12 @@ export function extractCopyInventory(root) {
       ),
     )
   }
-  const dynamicSurfaces = applyProjectMetadata(config, entries, diagnostics)
+  const dynamicSurfaces = applyProjectMetadata(
+    config,
+    entries,
+    diagnostics,
+    new Set(sources.map((source) => source.path)),
+  )
 
   const coveredSources = new Set(entries.map((entry) => entry.source)).size
 
@@ -3165,10 +3308,305 @@ export function extractCopyInventory(root) {
         sourceSnapshots,
       },
     },
+    legacySelectors: { value: legacySelectorCount(config) },
   })
   return result
 }
 
+function legacySelectorCount(config) {
+  return ['dynamic', 'exemptions', 'transforms']
+    .flatMap((list) => (Array.isArray(config[list]) ? config[list] : []))
+    .filter((selector) => selector !== null && typeof selector === 'object' && selector.line !== undefined).length
+}
+
+/** Troca a chave `line` pelas chaves da âncora, preservando a posição dela na declaração. */
+function withAnchor(selector, anchor) {
+  const output = {}
+  for (const [key, value] of Object.entries(selector)) {
+    if (key === 'line') Object.assign(output, anchor)
+    else if (!(key in anchor)) output[key] = value
+  }
+  return output
+}
+
+function sameDeclaration(left, right) {
+  return JSON.stringify(Object.entries(left).sort()) === JSON.stringify(Object.entries(right).sort())
+}
+
+function contentKey(list, selector) {
+  return list === 'dynamic'
+    ? `${selector.source}\u0000${selector.field}\u0000${selector.expression}`
+    : `${selector.source}\u0000${selector.role}\u0000${selector.text}\u0000${list === 'exemptions' ? selector.ruleId : ''}`
+}
+
+/**
+ * Propõe a âncora de conteúdo de cada seletor por linha, por grupo: em `copy.dynamic`, arquivo e
+ * campo; em `copy.exemptions` e `copy.transforms`, arquivo, papel e texto (e a regra, nas
+ * exceções). Uma âncora por conteúdo cobre todos os alvos do grupo, então só é proposta quando o
+ * grupo tem exatamente uma declaração por alvo: com alvo sobrando, a conversão ampliaria a
+ * declaração para um alvo que ninguém classificou. Dentro do grupo, declarações e alvos são
+ * pareados em ordem de linha; `to` é a linha atual do alvo pareado e serve para manter o
+ * seletor por linha, corrigido, quando a conversão não é segura.
+ */
+function reanchorProposals(lists, collected) {
+  const proposals = { dynamic: new Map(), exemptions: new Map(), transforms: new Map() }
+  const unresolved = []
+  const legacy = (selector) => selector !== null && typeof selector === 'object' && Number.isInteger(selector.line)
+  const pair = (list, indexes, targets, line) => {
+    const sorted = [...indexes].sort((left, right) => lists[list][left].line - lists[list][right].line)
+    for (const [position, index] of sorted.entries()) {
+      const target = targets[position]
+      proposals[list].set(index, {
+        anchor: list === 'dynamic' ? { expression: target.expression } : { text: target.text },
+        from: lists[list][index].line,
+        to: line(target),
+        realigned: line(target) !== lists[list][index].line,
+      })
+    }
+  }
+
+  // copy.dynamic. Parear o grupo inteiro, e não só as declarações quebradas, evita trocar motivos
+  // entre vizinhos que por coincidência caíram na linha um do outro.
+  const content = collected.diagnostics.filter((item) => item.category === 'content')
+  const declared = new Set(
+    lists.dynamic
+      .filter((item) => item !== null && typeof item === 'object' && typeof item.expression === 'string')
+      .map((item) => contentKey('dynamic', item)),
+  )
+  const dynamicGroups = new Map()
+  for (const [index, declaration] of lists.dynamic.entries()) {
+    if (!legacy(declaration)) continue
+    const key = `${declaration.source}\u0000${declaration.field}`
+    if (!dynamicGroups.has(key)) dynamicGroups.set(key, [])
+    dynamicGroups.get(key).push(index)
+  }
+  for (const indexes of dynamicGroups.values()) {
+    const first = lists.dynamic[indexes[0]]
+    const free = content
+      .filter(
+        (item) =>
+          item.source === first.source &&
+          item.field === first.field &&
+          !declared.has(contentKey('dynamic', item)),
+      )
+      .sort((left, right) => left.line - right.line)
+    if (free.length !== indexes.length) {
+      for (const index of indexes) {
+        unresolved.push({
+          list: 'dynamic',
+          index,
+          reason: `${indexes.length} declaração(ões) por linha e ${free.length} diagnóstico(s) sem declaração de \`${first.field}\` em ${first.source}`,
+        })
+      }
+      continue
+    }
+    pair('dynamic', indexes, free, (item) => item.line)
+  }
+
+  // copy.exemptions e copy.transforms. O texto pode vir de um `message-template`, que só existe
+  // depois de aplicar copy.dynamic; por isso os textos são lidos com as propostas acima aplicadas.
+  const entries = collected.entries.map((entry) => ({ ...entry }))
+  applyDynamicMetadata(
+    {
+      dynamic: lists.dynamic.map((selector, index) => {
+        const proposal = proposals.dynamic.get(index)
+        return proposal === undefined ? selector : withAnchor(selector, proposal.anchor)
+      }),
+    },
+    entries,
+    collected.diagnostics.map((item) => ({ ...item })),
+  )
+  for (const list of ['exemptions', 'transforms']) {
+    const groups = new Map()
+    for (const [index, selector] of lists[list].entries()) {
+      if (!legacy(selector)) continue
+      let text = selector.text
+      if (typeof text !== 'string' || text === '') {
+        const atLine = findEntry(entries, selector)
+        if (atLine.length !== 1) {
+          unresolved.push({ list, index, reason: `${atLine.length} texto(s) correspondem a ${describeTextSelector(selector)}` })
+          continue
+        }
+        text = atLine[0].entry.text
+      }
+      const key = `${selector.source}\u0000${selector.role}\u0000${text}\u0000${list === 'exemptions' ? selector.ruleId : ''}`
+      if (!groups.has(key)) groups.set(key, { text, indexes: [] })
+      groups.get(key).indexes.push(index)
+    }
+    for (const { text, indexes } of groups.values()) {
+      const first = lists[list][indexes[0]]
+      const matches = findEntry(entries, { source: first.source, role: first.role, text })
+        .map(({ entry }) => entry)
+        .sort((left, right) => left.line - right.line)
+      if (matches.length !== indexes.length) {
+        for (const index of indexes) {
+          unresolved.push({
+            list,
+            index,
+            reason:
+              `o texto "${text}" (${first.role}) aparece ${matches.length} vez(es) em ${first.source} e tem ` +
+              `${indexes.length} declaração(ões) por linha; a âncora por texto mudaria o alcance da declaração`,
+          })
+        }
+        continue
+      }
+      pair(list, indexes, matches, (entry) => entry.line)
+    }
+  }
+  return { proposals, unresolved }
+}
+
+/**
+ * Aplica as propostas às listas. Declarações que viram o mesmo seletor de conteúdo se fundem
+ * quando são idênticas; quando divergem em motivo, tipo ou referência, ficam por linha, já
+ * corrigida, porque um seletor de conteúdo cobriria as duas com um único motivo. Devolve
+ * `null` quando precisou rebaixar alguma proposta, para a chamada recalcular.
+ */
+function buildReanchored(lists, proposals, unresolved) {
+  const next = {}
+  const origin = {}
+  const merged = []
+  for (const list of Object.keys(lists)) {
+    const effective = lists[list].map((selector, index) => {
+      const proposal = proposals[list].get(index)
+      if (proposal === undefined) return selector
+      return withAnchor(selector, proposal.keepLine ? { line: proposal.to } : proposal.anchor)
+    })
+    const seen = new Map()
+    const dropped = new Set()
+    let demoted = false
+    for (const [index, selector] of effective.entries()) {
+      if (selector === null || typeof selector !== 'object' || selector.line !== undefined) continue
+      const key = contentKey(list, selector)
+      if (!seen.has(key)) {
+        seen.set(key, index)
+        continue
+      }
+      const first = seen.get(key)
+      if (sameDeclaration(effective[first], selector)) {
+        // Só uma declaração convertida aqui é descartada; duplicata já escrita assim fica.
+        if (proposals[list].has(index)) dropped.add(index)
+        else if (proposals[list].has(first)) {
+          dropped.add(first)
+          seen.set(key, index)
+        }
+        continue
+      }
+      for (const conflicting of [first, index]) {
+        const proposal = proposals[list].get(conflicting)
+        if (proposal === undefined || proposal.keepLine) continue
+        const reason = 'outra declaração seleciona o mesmo conteúdo com motivo, tipo ou referência diferentes'
+        if (proposal.to === undefined) {
+          proposals[list].delete(conflicting)
+          unresolved.push({ list, index: conflicting, reason })
+        } else proposal.keepLine = reason
+        demoted = true
+      }
+    }
+    if (demoted) return null
+    next[list] = effective.filter((_, index) => !dropped.has(index))
+    origin[list] = effective.map((_, index) => index).filter((index) => !dropped.has(index))
+    for (const index of dropped) merged.push({ list, index })
+  }
+  return { next, origin, merged }
+}
+
+/**
+ * Converte os seletores por linha de `copy.dynamic`, `copy.exemptions` e `copy.transforms`
+ * para seletores por conteúdo e grava o `base.json` atomicamente. Só converte um grupo que tem
+ * uma declaração por alvo (`reanchorProposals`), então a conversão não muda o alcance de
+ * nenhuma declaração; as que mudaram de linha são separadas no relatório para revisão humana.
+ * Os seletores resultantes precisam passar na extração do `opus copy`: uma conversão que
+ * reprovaria fica por linha corrigida ou, sem linha segura, intacta. A política da Base não é
+ * avaliada aqui; `base copy check` continua sendo o gate dela.
+ */
+export function reanchorCopySelectors(root) {
+  const target = path.resolve(root)
+  const config = copyConfiguration(target)
+  const report = { converted: [], realigned: [], relined: [], merged: [], unresolved: [] }
+  if (!config.configFile.exists) return { ok: true, changed: false, report }
+  const collected = collectCopySources(target, config)
+  const blocking = collected.diagnostics.filter((item) => item.category === undefined)
+  if (blocking.length > 0) return { ok: false, changed: false, report, diagnostics: blocking }
+
+  const lists = {
+    dynamic: Array.isArray(config.dynamic) ? config.dynamic : [],
+    exemptions: Array.isArray(config.exemptions) ? config.exemptions : [],
+    transforms: Array.isArray(config.transforms) ? config.transforms : [],
+  }
+  const { proposals, unresolved } = reanchorProposals(lists, collected)
+  report.unresolved.push(...unresolved)
+
+  let built = null
+  for (let attempt = 0; attempt < 20; attempt++) {
+    built = buildReanchored(lists, proposals, report.unresolved)
+    if (built === null) continue
+    const entries = collected.entries.map((entry) => ({ ...entry, exemptions: entry.exemptions?.map((item) => ({ ...item })) }))
+    const diagnostics = collected.diagnostics.map((item) => ({ ...item }))
+    applyProjectMetadata(
+      { ...config, ...built.next },
+      entries,
+      diagnostics,
+      new Set(collected.sources.map((source) => source.path)),
+    )
+    let demoted = false
+    for (const { selector } of diagnostics) {
+      if (selector === undefined) continue
+      const original = built.origin[selector.list]?.[selector.index]
+      const proposal = original === undefined ? undefined : proposals[selector.list].get(original)
+      if (proposal === undefined) continue
+      if (!proposal.keepLine && proposal.to !== undefined) proposal.keepLine = 'a âncora por conteúdo reprovaria no gate'
+      else {
+        proposals[selector.list].delete(original)
+        report.unresolved.push({ list: selector.list, index: original, reason: 'nenhuma âncora segura passa no gate' })
+      }
+      demoted = true
+    }
+    if (!demoted) break
+    built = null
+  }
+  if (built === null) throw new Error('copy --reanchor não convergiu; base.json não foi alterado.')
+
+  report.merged.push(...built.merged)
+  for (const list of Object.keys(lists)) {
+    for (const [index, proposal] of proposals[list]) {
+      if (built.merged.some((item) => item.list === list && item.index === index)) continue
+      const item = { list, index, selector: lists[list][index], anchor: proposal.anchor, from: proposal.from, to: proposal.to }
+      if (proposal.keepLine) {
+        if (proposal.to !== proposal.from) report.relined.push({ ...item, reason: proposal.keepLine })
+        else report.unresolved.push({ list, index, reason: proposal.keepLine })
+      } else if (proposal.realigned) report.realigned.push(item)
+      else report.converted.push(item)
+    }
+  }
+  const changed = Object.keys(lists).some(
+    (list) => JSON.stringify(built.next[list]) !== JSON.stringify(lists[list]),
+  )
+  if (!changed) return { ok: true, changed: false, report }
+
+  const raw = JSON.parse(config.configFile.content)
+  raw.copy = { ...raw.copy }
+  for (const list of Object.keys(lists)) if (Array.isArray(raw.copy[list])) raw.copy[list] = built.next[list]
+  const indent = /^\{\r?\n([ \t]+)/u.exec(config.configFile.content)?.[1] ?? 2
+  const rendered = withLineEndingsOf(
+    config.configFile.content,
+    `${JSON.stringify(raw, null, indent)}${config.configFile.content.endsWith('\n') ? '\n' : ''}`,
+  )
+  verifyConfiguration(target, config.configFile)
+  writeProjectFileAtomically(
+    target,
+    'base.json',
+    rendered,
+    { exists: true, content: config.configFile.content },
+    { mode: config.configFile.mode },
+  )
+  return { ok: true, changed: true, report }
+}
+
+function withLineEndingsOf(original, rendered) {
+  return original.includes('\r\n') ? rendered.replace(/\n/gu, '\r\n') : rendered
+}
+
 export function renderCopyInventory(inventory) {
   return `${JSON.stringify(inventory, null, 2)}\n`
 }