parche-cli 0.0.0-stage → 0.5.1

package/src/codemods/arca-rules.js

@@ -0,0 +1,109 @@
+// Reglas del pack arca.wsfe.condicion-iva-receptor, compartidas por los codemods de JS y de PHP:
+// qué se puede inferir sin datos del negocio y con qué mensajes se reporta.
+
+import { isTestFile } from '../paths.js';
+
+export const PACK = 'arca.wsfe.condicion-iva-receptor';
+
+// Prefiltro de los codemods: sin estas palabras no hay nada de ARCA en el archivo y no se parsea
+// (en repos con bundles grandes, parsear todo tardaba minutos y 1,5 GB de RAM).
+export const ARCA_HINT = /electronicbilling|fecaesolicitar|fecaedetrequest/i;
+
+const CLASS = {
+  A: new Set([1, 2, 3, 201, 202, 203]),
+  B: new Set([6, 7, 8, 206, 207, 208]),
+  C: new Set([11, 12, 13, 211, 212, 213]),
+};
+
+export function classOf(cbteTipo) {
+  for (const [k, set] of Object.entries(CLASS)) if (set.has(cbteTipo)) return k;
+  return null;
+}
+
+// docTipo y cbteTipo: números si el valor es un literal, undefined si no se puede saber.
+export function decideCondition({ docTipo, cbteTipo }, pack) {
+  const clase = typeof cbteTipo === 'number' ? classOf(cbteTipo) : null;
+  if (docTipo === 99) {
+    return { status: 'auto', code: 5, comment: ' parche: 5 = Consumidor Final (DocTipo 99, sin identificar)' };
+  }
+  if (docTipo === 96 && (clase === 'B' || clase === 'C')) {
+    return { status: 'needs-review', code: 5, comment: ' parche: inferido Consumidor Final (DNI + comprobante ' + clase + ') — REVISAR' };
+  }
+  const valid = clase ? pack.codes_by_class[clase] : null;
+  return { status: 'needs-input', clase, valid };
+}
+
+export function validCodesText(decision, pack) {
+  return (decision.valid || Object.keys(pack.codes).map(Number))
+    .map((c) => `${c} (${pack.codes[String(c)]})`).join(', ');
+}
+
+export function missingMessage(decision) {
+  return `Falta CondicionIVAReceptorId y no se puede inferir sin saber la condición frente al IVA del cliente${decision.clase ? ` (comprobante clase ${decision.clase})` : ''}.`;
+}
+
+export function appliedMessage(status) {
+  return status === 'auto'
+    ? 'Agregado CondicionIVAReceptorId: 5 (Consumidor Final): el comprobante va a un consumidor sin identificar.'
+    : 'Agregado CondicionIVAReceptorId: 5 por inferencia (DNI + comprobante B/C). Confirmá que el cliente no sea exento ni no alcanzado.';
+}
+
+// "El repo ya usa CondicionIVAReceptorId en otro lado": prefijo para bajar a "revisar" lo que no se pudo leer
+// (en repos ya migrados, el objeto suele salir de un builder que sí pone el campo).
+export function alreadyMigratedPrefix(context) {
+  const f = context?.fieldFiles?.[0];
+  return f ? `El repo ya usa CondicionIVAReceptorId (en \`${f}\`): verificá que este comprobante también lo lleve. ` : null;
+}
+
+// Si el campo puede no llegar a ARCA aunque esté en el código: librería 0.x (WSDL de 2021) o un WSDL viejo
+// en el repo. Verificado en el código de afip.js/afip.php el 16/10/2026 (ver src/context.js).
+export function libraryCaveat(context, ecosystem) {
+  const lib = (context?.arcaLibs || []).find((l) => l.ecosystem === ecosystem && l.travels !== 'si');
+  if (lib) {
+    return `Ojo: con ${lib.name} ${lib.version} el pedido se arma con un WSDL de 2021 que no tiene este campo`
+      + `${lib.travels === 'no' ? '' : ' (en JS falta confirmarlo)'}: para que llegue a ARCA hay que actualizar la librería a 1.x.`;
+  }
+  const wsdl = context?.staleWsdl?.[0];
+  if (wsdl) return `Ojo: el repo tiene un WSDL de WSFEv1 sin este campo (\`${wsdl}\`): si el cliente SOAP lo usa, el campo no viaja hasta actualizarlo.`;
+  return null;
+}
+
+// Integraciones SOAP propias (cualquier lenguaje): solo detección.
+// Con menos ruido que la primera versión (frente B, 16/10): no marca tests, mocks, tipos, copias de la librería
+// ni archivos que solo nombran el método (constantes, reexports); solo los que arman el detalle del comprobante.
+export function soapDetection(source, file, context) {
+  if (!/FECAESolicitar|FECAEDetRequest/.test(source) || /CondicionIVAReceptorId/.test(source)) return null;
+  if (isTestFile(file) || /\.d\.[cm]?ts$/.test(file)) return null;
+  if (/class\s+ElectronicBilling\b/.test(source)) return null; // copia de afip.php/afip.js: la cubren la versión y el WSDL
+  const generated = /(^|\/)Reference\.cs$|Stub\.java$/i.test(file) || /class\s+FECAEDetRequest\b/.test(source);
+  if (!generated && !/\b(DocTipo|CbteDesde|ImpTotal)\b/.test(source)) return null;
+  const line = source.split('\n').findIndex((l) => /FECAESolicitar|FECAEDetRequest/.test(l)) + 1;
+  const base = generated
+    ? 'Cliente SOAP de WSFEv1 generado sin CondicionIVAReceptorId: hay que regenerarlo con el WSDL vigente (y después completar el campo).'
+    : 'Integración SOAP propia con WSFEv1 sin CondicionIVAReceptorId en el FECAEDetRequest. Hay que agregarlo al XML, con la condición frente al IVA del cliente.';
+  const prefix = alreadyMigratedPrefix(context);
+  return {
+    finding: { pack: PACK, file, line, status: prefix ? 'needs-review' : 'needs-input', message: (prefix || '') + base },
+    usage: { provider: 'arca', op: generated ? 'WSFEv1 SOAP (cliente generado)' : 'WSFEv1 SOAP', line },
+  };
+}
+
+// Archivos .wsdl de WSFEv1 sin el campo: si el cliente SOAP arma el pedido con ese esquema
+// (SoapClient en modo WSDL, la librería soap de Node), el campo no viaja aunque esté en el código.
+export function wsdlDetection({ source, file }) {
+  const findings = [];
+  const usages = [];
+  if (/FECAESolicitar|FECAEDetRequest/.test(source) && !source.includes('CondicionIVAReceptorId')) {
+    const line = source.split('\n').findIndex((l) => /FECAEDetRequest/.test(l)) + 1 || 1;
+    findings.push({ pack: PACK, file, line, status: 'needs-input',
+      message: 'WSDL de WSFEv1 sin CondicionIVAReceptorId: si tu cliente SOAP arma el pedido con este archivo, el campo no viaja aunque lo agregues al código. Reemplazalo por el WSDL vigente de WSFEv1.' });
+    usages.push({ provider: 'arca', op: 'WSFEv1 WSDL', line });
+  }
+  return { output: null, findings, usages };
+}
+
+// Lenguajes sin codemod (Python, C#, Java, Go, VB.NET): solo la detección de SOAP propio o cliente generado.
+export function soapOnly({ source, file, context }) {
+  const soap = soapDetection(source, file, context);
+  return { output: null, findings: soap ? [soap.finding] : [], usages: soap ? [soap.usage] : [] };
+}

package/src/codemods/arca-wsfe-condicion-iva-php.js

@@ -0,0 +1,195 @@
+// Pack arca.wsfe.condicion-iva-receptor (PHP: afipsdk/afip.php y sus forks)
+// Mismas reglas que el codemod de JS: agrega CondicionIVAReceptorId a cada
+// $afip->ElectronicBilling->CreateVoucher($data) / CreateNextVoucher($data) cuando se puede inferir
+// sin datos del negocio, y marca el resto para que una persona complete el dato.
+// Edita con inserciones de texto mínimas sobre los offsets exactos de php-parser (ver src/php.js).
+import { eolOf, applyEdits, finding } from '../ast.js';
+import { parsePhp, walkPhp, phpLiteral, phpKey } from '../php.js';
+import {
+  PACK, decideCondition, validCodesText, missingMessage, appliedMessage, soapDetection, ARCA_HINT, libraryCaveat, alreadyMigratedPrefix,
+} from './arca-rules.js';
+import { emptyContext } from '../context.js';
+
+// En PHP los nombres de método no distinguen mayúsculas: createVoucher también es válido.
+// El inventario usa el nombre oficial, así un mismo método no aparece dos veces.
+const VOUCHER_METHODS = new Map([['createvoucher', 'CreateVoucher'], ['createnextvoucher', 'CreateNextVoucher']]);
+// Claves que cambian la decisión: si se tocan fuera del array literal, no se puede inferir.
+const DECISION_KEYS = new Set(['DocTipo', 'CbteTipo', 'DocNro']);
+const FIELD = 'CondicionIVAReceptorId';
+const HINT_TAIL = 'con la condición frente al IVA del cliente.';
+
+const isLookup = (n) => n && (n.kind === 'propertylookup' || n.kind === 'nullsafepropertylookup');
+const identName = (n) => (n && n.kind === 'identifier' ? n.name : null);
+
+// '...->ElectronicBilling->CreateVoucher(...)' → nombre oficial del método; null si no es.
+function voucherMethod(call) {
+  const what = call.what;
+  if (!isLookup(what)) return null;
+  const method = identName(what.offset);
+  if (!method || !VOUCHER_METHODS.has(method.toLowerCase())) return null;
+  if (!isLookup(what.what) || identName(what.what.offset) !== 'ElectronicBilling') return null;
+  return VOUCHER_METHODS.get(method.toLowerCase());
+}
+
+// Asignaciones por scope: $var = ... y $var['Clave'] = ...
+function collect(ast) {
+  const scopes = new Map();
+  const calls = [];
+  const info = (scope) => {
+    if (!scopes.has(scope)) scopes.set(scope, { assigns: new Map(), offsets: new Map() });
+    return scopes.get(scope);
+  };
+  const push = (map, name, value) => map.set(name, [...(map.get(name) || []), value]);
+  walkPhp(ast, (node, scope) => {
+    if (node.kind === 'assign') {
+      const left = node.left;
+      if (left.kind === 'variable' && typeof left.name === 'string') push(info(scope).assigns, left.name, node);
+      else if (left.kind === 'offsetlookup' && left.what && left.what.kind === 'variable' && typeof left.what.name === 'string' && left.offset) {
+        push(info(scope).offsets, left.what.name, { key: phpLiteral(left.offset), node });
+      }
+    }
+    if (node.kind === 'call') {
+      const method = voucherMethod(node);
+      if (method) calls.push({ node, scope, method });
+    }
+  });
+  return { scopes, calls };
+}
+
+// El array con los datos del comprobante: literal en la llamada o $var definida una sola vez,
+// antes de la llamada y en el mismo scope.
+function resolveData(arg, scope, call, scopes) {
+  if (!arg) return { reason: 'la llamada no tiene argumentos' };
+  if (arg.kind === 'array') return { arr: arg };
+  if (arg.kind !== 'variable' || typeof arg.name !== 'string') return { reason: 'no es un array literal ni una variable' };
+  const s = scopes.get(scope) || { assigns: new Map(), offsets: new Map() };
+  const defs = s.assigns.get(arg.name) || [];
+  const v = `$${arg.name}`;
+  if (defs.length === 0) {
+    const isParam = (scope.arguments || []).some((a) => a.kind === 'parameter' && (a.name?.name ?? a.name) === arg.name);
+    if (isParam) return { hint: `Los datos del comprobante llegan en \`${v}\` como parámetro: agregá ${FIELD} donde se arma ese array, ${HINT_TAIL}` };
+    return { reason: `${v} no se define en esta función` };
+  }
+  if (defs.length > 1) return { reason: `${v} se asigna más de una vez` };
+  const def = defs[0];
+  // $data = armarComprobante(...) / $this->builder->armar(...) / Builder::armar(...): decir qué función lo arma.
+  if (def.right.kind === 'call') {
+    const what = def.right.what;
+    const fn = what && (what.kind === 'name' ? what.name : identName(what.offset));
+    if (typeof fn === 'string') return { hint: `Los datos del comprobante los arma \`${fn}()\`: agregá ${FIELD} ahí, ${HINT_TAIL}` };
+  }
+  if (def.operator !== '=' || def.right.kind !== 'array') return { reason: `${v} no es un array literal` };
+  if (def.loc.start.offset > call.loc.start.offset) return { reason: `${v} se define después de la llamada` };
+  const offsets = s.offsets.get(arg.name) || [];
+  if (offsets.some((o) => o.key === FIELD)) return { migrated: true };
+  if (offsets.some((o) => o.key === undefined || DECISION_KEYS.has(o.key))) return { reason: `${v} se completa en varios pasos` };
+  return { arr: def.right };
+}
+
+export default function transform({ source, file, pack, context = emptyContext() }) {
+  const findings = [];
+  const usages = [];
+  if (!ARCA_HINT.test(source)) return { output: null, findings, usages }; // prefiltro (ver el codemod de JS)
+  const caveat = libraryCaveat(context, 'composer');
+  const migrated = alreadyMigratedPrefix(context);
+  let ast;
+  try {
+    ast = parsePhp(source, file);
+  } catch (err) {
+    if (/ElectronicBilling|FECAESolicitar|FECAEDetRequest/.test(source)) {
+      findings.push({ pack: PACK, file, line: err.lineNumber || null, status: 'needs-input',
+        message: `No pude analizar este archivo PHP (${err.message}). Revisá a mano las llamadas a ElectronicBilling.` });
+    }
+    return { output: null, findings, usages };
+  }
+
+  const { scopes, calls } = collect(ast);
+  const edits = [];
+  const edited = new Set(); // el mismo $data en dos llamadas: se inserta una sola vez (ver el codemod de JS)
+  for (const { node: call, scope, method } of calls) {
+    usages.push({ provider: 'arca', op: `ElectronicBilling->${method}`, line: call.loc.start.line });
+    const data = resolveData(call.arguments[0], scope, call, scopes);
+    if (data.migrated) continue;
+    const entries = data.arr ? data.arr.items.filter((it) => it && it.kind === 'entry') : null;
+    if (!entries || entries.some((e) => e.unpack || e.byRef)) {
+      const msg = data.hint || `No pude leer los datos del comprobante (${data.reason || 'el array usa ...$otro o referencias'}). Agregá ${FIELD} a mano, ${HINT_TAIL}`;
+      findings.push(finding(PACK, file, call, migrated ? 'needs-review' : 'needs-input', (migrated || '') + msg));
+      continue;
+    }
+    const byKey = (k) => entries.find((e) => phpKey(e) === k);
+    if (byKey(FIELD) || edited.has(data.arr)) continue; // ya está migrado (o ya lo editamos)
+
+    const d = decideCondition({ docTipo: phpLiteral(byKey('DocTipo')?.value), cbteTipo: phpLiteral(byKey('CbteTipo')?.value) }, pack);
+    if (d.status === 'needs-input') {
+      findings.push(finding(PACK, file, call, 'needs-input', missingMessage(d) + (caveat ? ` ${caveat}` : ''),
+        { suggestion: `'${FIELD}' => <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}` }));
+      continue;
+    }
+    const anchor = byKey('DocNro') || entries[entries.length - 1];
+    edits.push(...insertAfterEntry(source, entries, anchor, { value: d.code, comment: d.comment }));
+    edited.add(data.arr);
+    // Con afip.php 0.x (WSDL de 2021 sin el campo) el arreglo no alcanza solo: deja de ser "automático".
+    const status = caveat && d.status === 'auto' ? 'needs-review' : d.status;
+    findings.push(finding(PACK, file, call, status, appliedMessage(d.status) + (caveat ? ` ${caveat}` : '')));
+  }
+
+  const soap = soapDetection(source, file, context);
+  if (soap) { findings.push(soap.finding); usages.push(soap.usage); }
+
+  return { output: edits.length ? applyEdits(source, edits) : null, findings, usages };
+}
+
+// Inserta 'CondicionIVAReceptorId' => N después de `anchor`, copiando el estilo del array:
+// comillas de las claves, indentación, alineación de los =>, coma final y fin de línea.
+export function insertAfterEntry(source, entries, anchor, { value, comment }) {
+  const eol = eolOf(source);
+  const keyed = entries.filter((e) => e.key && e.key.kind === 'string');
+  const doubles = keyed.filter((e) => source[e.key.loc.start.offset] === '"').length;
+  const q = doubles > keyed.length / 2 ? '"' : "'";
+  const key = `${q}${FIELD}${q}`;
+
+  const end = anchor.loc.end.offset;
+  let k = end;
+  while (k < source.length && /[ \t]/.test(source[k])) k++;
+  const hasComma = source[k] === ',';
+  const nl = source.indexOf('\n', end);
+  const rest = source.slice(hasComma ? k + 1 : end, nl === -1 ? source.length : nl);
+  const endsLine = nl !== -1 && (rest.trim() === '' || /^\s*(\/\/|#)/.test(rest));
+
+  if (!endsLine) {
+    // Array en una sola línea.
+    return [{ offset: hasComma ? k + 1 : end, text: `${hasComma ? '' : ','} ${key} => ${value} /*${comment} */${hasComma ? ',' : ''}` }];
+  }
+
+  const lineStart = source.lastIndexOf('\n', anchor.loc.start.offset - 1) + 1;
+  const indent = source.slice(lineStart).match(/^[ \t]*/)[0];
+  const { before, after } = arrowSpacing(source, keyed, anchor, key.length);
+  const isLast = anchor === entries[entries.length - 1];
+  const trailing = hasComma || !isLast ? ',' : '';
+  const out = [{ offset: nl + 1, text: `${indent}//${comment}${eol}${indent}${key}${before}=>${after}${value}${trailing}${eol}` }];
+  if (!hasComma) out.push({ offset: end, text: ',' });
+  return out;
+}
+
+// Espacios antes y después del => para la línea nueva. Si las claves del array están alineadas
+// con espacios ('DocTipo'    => 99), se alinea igual; si no, se copia el espaciado del ancla.
+function arrowSpacing(source, keyed, anchor, newKeyLength) {
+  const parts = (e) => {
+    const keyEnd = e.key.loc.end.offset;
+    const arrow = source.indexOf('=>', keyEnd);
+    return {
+      width: arrow - e.key.loc.start.offset,
+      before: source.slice(keyEnd, arrow),
+      after: source.slice(arrow + 2, e.value.loc.start.offset),
+      line: e.loc.start.line,
+    };
+  };
+  const all = keyed.map(parts);
+  const own = anchor.key && anchor.key.kind === 'string' ? parts(anchor) : { before: ' ', after: ' ' };
+  const after = /^[ \t]*$/.test(own.after) && own.after ? own.after : ' ';
+  const multiline = new Set(all.map((p) => p.line)).size === all.length;
+  const aligned = multiline && all.length > 1 && all.every((p) => p.width === all[0].width && /^ +$/.test(p.before))
+    && all.some((p) => p.before.length > 1);
+  if (aligned) return { before: ' '.repeat(Math.max(1, all[0].width - newKeyLength)), after };
+  return { before: /^[ \t]+$/.test(own.before) ? own.before : ' ', after };
+}

package/src/codemods/arca-wsfe-condicion-iva.js

@@ -0,0 +1,177 @@
+// Pack arca.wsfe.condicion-iva-receptor (JavaScript/TypeScript, afip.js)
+// Agrega CondicionIVAReceptorId a cada pedido de CAE hecho con afip.js cuando se puede inferir
+// sin datos del negocio, y marca el resto para que una persona complete el dato.
+import {
+  jFor, detectQuote, eolOf, offsetAt, applyEdits, getProp, hasSpread, isQuotedKey, isPlainProp, literalValue, resolveBinding, finding,
+} from '../ast.js';
+import {
+  PACK, decideCondition, validCodesText, missingMessage, appliedMessage, soapDetection, ARCA_HINT, libraryCaveat, alreadyMigratedPrefix,
+} from './arca-rules.js';
+import { emptyContext } from '../context.js';
+
+const VOUCHER_METHODS = new Set(['createVoucher', 'createNextVoucher']);
+const WRAPPERS = new Set(['TSAsExpression', 'TSNonNullExpression', 'TSTypeAssertion', 'TSSatisfiesExpression', 'ParenthesizedExpression']);
+
+// (afip.ElectronicBilling as any) → afip.ElectronicBilling
+const unwrap = (n) => {
+  while (n && WRAPPERS.has(n.type)) n = n.expression;
+  return n;
+};
+const isEBMember = (n) => !!(n && n.type === 'MemberExpression' && !n.computed && n.property.type === 'Identifier' && n.property.name === 'ElectronicBilling');
+
+// ¿`node` es `<algo>.ElectronicBilling`? También con casts de TS y con un alias en el mismo scope
+// (`const eb = afip.ElectronicBilling; eb.createVoucher(...)`): los dos aparecieron en repos reales.
+function isElectronicBilling(node, p) {
+  const n = unwrap(node);
+  if (isEBMember(n)) return true;
+  if (n && n.type === 'Identifier') {
+    const decl = resolveBinding(p, n.name);
+    return isEBMember(unwrap(decl && decl.node.init));
+  }
+  return false;
+}
+
+function voucherCallee(p) {
+  const callee = unwrap(p.node.callee);
+  if (!callee || callee.type !== 'MemberExpression' || callee.computed || callee.property.type !== 'Identifier') return null;
+  if (!VOUCHER_METHODS.has(callee.property.name) || !isElectronicBilling(callee.object, p)) return null;
+  return callee;
+}
+
+export function decide(obj, pack) {
+  return decideCondition({
+    docTipo: literalValue(getProp(obj, 'DocTipo')?.value),
+    cbteTipo: literalValue(getProp(obj, 'CbteTipo')?.value),
+  }, pack);
+}
+
+export default function transform({ source, file, pack, context = emptyContext() }) {
+  const findings = [];
+  const usages = [];
+  if (!ARCA_HINT.test(source)) return { output: null, findings, usages };
+  const caveat = libraryCaveat(context, 'npm');
+  const migrated = alreadyMigratedPrefix(context);
+  const j = jFor(file);
+  let root;
+  try {
+    root = j(source);
+  } catch (err) {
+    // Antes se descartaba en silencio: un archivo de ARCA que no parsea es justo el que hay que mirar.
+    findings.push({ pack: PACK, file, line: err.loc?.line || null, status: 'needs-input',
+      message: `No pude analizar este archivo (${err.message.split('\n')[0]}). Revisá a mano las llamadas a ElectronicBilling.` });
+    return { output: null, findings, usages };
+  }
+  let changed = false;
+  const edits = [];
+  // Objetos ya editados: el mismo `payload` puede ir a dos llamadas (lo vimos en un repo real). Como se edita
+  // texto y el árbol no se entera, sin esto se insertaba dos veces → clave duplicada y TypeScript no compila.
+  const edited = new Set();
+
+  root.find(j.CallExpression).filter((p) => voucherCallee(p) !== null).forEach((p) => {
+    const call = p.node;
+    usages.push({ provider: 'arca', op: `ElectronicBilling.${voucherCallee(p).property.name}`, line: call.loc?.start.line });
+    const arg = call.arguments[0];
+    let obj = null;
+    if (arg && arg.type === 'ObjectExpression') obj = arg;
+    else if (arg && arg.type === 'Identifier') {
+      const decl = resolveBinding(p, arg.name);
+      if (decl && decl.node.init && decl.node.init.type === 'ObjectExpression') obj = decl.node.init;
+    }
+    if (!obj || hasSpread(obj)) {
+      // Si el repo ya usa el campo en otro lado, lo más probable es que el builder ya lo ponga: "revisar".
+      findings.push(finding(PACK, file, call, migrated ? 'needs-review' : 'needs-input', (migrated || '') + unreadableMessage(j, root, p, arg, obj)));
+      return;
+    }
+    if (getProp(obj, 'CondicionIVAReceptorId') || edited.has(obj)) return; // ya está migrado (o ya lo editamos)
+
+    const d = decide(obj, pack);
+    if (d.status === 'needs-input') {
+      findings.push(finding(PACK, file, call, 'needs-input', missingMessage(d) + (caveat ? ` ${caveat}` : ''),
+        { suggestion: `'CondicionIVAReceptorId': <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}` }));
+      return;
+    }
+
+    const props = obj.properties.filter(isPlainProp);
+    const quoted = props.length > 0 && props.filter(isQuotedKey).length >= props.length / 2;
+    const q = detectQuote(source) === 'double' ? '"' : "'";
+    const keyText = quoted ? `${q}CondicionIVAReceptorId${q}` : 'CondicionIVAReceptorId';
+    const anchor = getProp(obj, 'DocNro') || props[props.length - 1];
+    const isLast = anchor === obj.properties[obj.properties.length - 1];
+    edits.push(...insertAfterProp(source, anchor, `${keyText}: ${d.code}`, d.comment, { isLast }));
+    edited.add(obj);
+    changed = true;
+    // Con librería vieja o WSDL viejo el arreglo no alcanza solo: deja de ser "automático".
+    const status = caveat && d.status === 'auto' ? 'needs-review' : d.status;
+    findings.push(finding(PACK, file, call, status, appliedMessage(d.status) + (caveat ? ` ${caveat}` : '')));
+  });
+
+  const soap = soapDetection(source, file, context);
+  if (soap) { findings.push(soap.finding); usages.push(soap.usage); }
+
+  return { output: changed ? applyEdits(source, edits) : null, findings, usages };
+}
+
+// Cuando no se puede leer el comprobante, decir DÓNDE hay que agregar el dato: la función que lo arma
+// (y de qué módulo viene) o que llega como parámetro. Lo encontrado en repos reales: payload = buildVoucherPayload(...).
+function unreadableMessage(j, root, p, arg, obj) {
+  const tail = 'con la condición frente al IVA del cliente.';
+  if (obj) return `No pude leer los datos del comprobante (el objeto usa ...spread). Agregá CondicionIVAReceptorId a mano, ${tail}`;
+  if (arg && arg.type === 'Identifier') {
+    const decl = resolveBinding(p, arg.name);
+    let init = decl && decl.node.init;
+    if (init && init.type === 'AwaitExpression') init = init.argument;
+    if (init && init.type === 'CallExpression') {
+      const fn = init.callee.type === 'Identifier' ? init.callee.name
+        : init.callee.type === 'MemberExpression' && !init.callee.computed && init.callee.property.type === 'Identifier' ? init.callee.property.name : null;
+      if (fn) {
+        const from = importSourceOf(j, root, fn);
+        return `Los datos del comprobante los arma \`${fn}()\`${from ? ` (de \`${from}\`)` : ''}: agregá CondicionIVAReceptorId ahí, ${tail}`;
+      }
+    }
+    if (!decl) return `Los datos del comprobante llegan en \`${arg.name}\` desde afuera de esta función: agregá CondicionIVAReceptorId donde se arma ese objeto, ${tail}`;
+  }
+  return `No pude leer los datos del comprobante (no es un objeto literal). Agregá CondicionIVAReceptorId a mano, ${tail}`;
+}
+
+// De qué módulo viene `name`: import estático, require o import() dinámico con desestructuración.
+function importSourceOf(j, root, name) {
+  let src = null;
+  root.find(j.ImportDeclaration).forEach((ip) => {
+    if (ip.node.specifiers.some((s) => s.local && s.local.name === name)) src = ip.node.source.value;
+  });
+  if (src) return src;
+  root.find(j.VariableDeclarator).forEach((vp) => {
+    const { id } = vp.node;
+    let init = vp.node.init;
+    if (!init || id.type !== 'ObjectPattern') return;
+    if (init.type === 'AwaitExpression') init = init.argument;
+    const isImportCall = init.type === 'CallExpression' && (init.callee.type === 'Import' || (init.callee.type === 'Identifier' && init.callee.name === 'require'));
+    const source = init.type === 'ImportExpression' ? init.source : isImportCall ? init.arguments[0] : null;
+    if (!source || typeof source.value !== 'string') return;
+    if (id.properties.some((pr) => pr.value && pr.value.type === 'Identifier' && pr.value.name === name)) src = source.value;
+  });
+  return src;
+}
+
+// Inserta una propiedad nueva después de `prop` tocando solo el texto necesario,
+// para que el diff del PR sea de una línea y respete el formato del cliente.
+// Si `prop` es la última y no tenía coma final, la nueva tampoco la lleva.
+export function insertAfterProp(source, prop, text, comment, { isLast = false } = {}) {
+  const eol = eolOf(source);
+  const end = offsetAt(source, prop.loc.end);
+  let k = end;
+  while (k < source.length && /[ \t]/.test(source[k])) k++;
+  const hasComma = source[k] === ',';
+  const nl = source.indexOf('\n', end);
+  const rest = source.slice(hasComma ? k + 1 : end, nl === -1 ? source.length : nl);
+  if (nl !== -1 && rest.trim() === '') {
+    const lineStart = offsetAt(source, { line: prop.loc.start.line, column: 0 });
+    const indent = source.slice(lineStart).match(/^[ \t]*/)[0];
+    const trailing = hasComma || !isLast ? ',' : '';
+    const out = [{ offset: nl + 1, text: `${indent}//${comment}${eol}${indent}${text}${trailing}${eol}` }];
+    if (!hasComma) out.push({ offset: end, text: ',' });
+    return out;
+  }
+  // Objeto en una sola línea.
+  return [{ offset: hasComma ? k + 1 : end, text: `${hasComma ? '' : ','} ${text} /*${comment} */${hasComma ? ',' : ''}` }];
+}