@arela/uploader 1.1.4 → 1.2.0

package/.claude/worktrees/agent-multi-profile/src/document-type-shared.js

@@ -0,0 +1,131 @@
+// Import all document type definitions
+import { dodaPdfDefinition } from './document-types/doda-pdf.js';
+import { dodaXmlDefinition } from './document-types/doda-xml.js';
+import { facturaInterAgenciaDefinition } from './document-types/factura-inter-agencia.js';
+import { facturasComerciales } from './document-types/facturas-comerciales.js';
+import { pedimentoCompletoXmlDefinition } from './document-types/pedimento-completo-xml.js';
+import { pedimentoCompletoDefinition } from './document-types/pedimento-completo.js';
+import { pedimentoSimplificadoDefinition } from './document-types/pedimento-simplificado.js';
+import { proformaDefinition } from './document-types/proforma.js';
+import { supportDocumentDefinition } from './document-types/support-document.js';
+
+// Document type definitions and extraction utilities
+// Ported from TypeScript to JavaScript for Node.js
+
+export class FieldResult {
+  constructor(name, found, value) {
+    this.name = name;
+    this.found = found;
+    this.value = value;
+  }
+}
+
+export class DocumentTypeDefinition {
+  constructor(
+    type,
+    extensions,
+    match,
+    extractors,
+    extractNumPedimento,
+    extractPedimentoYear,
+  ) {
+    this.type = type;
+    this.extensions = extensions;
+    this.match = match;
+    this.extractors = extractors;
+    this.extractNumPedimento = extractNumPedimento;
+    this.extractPedimentoYear = extractPedimentoYear;
+  }
+}
+
+// Registry of all document types
+// pedimentoSimplificadoDefinition is the primary matcher for "FORMA SIMPLIFICADA" documents.
+// After field extraction, resolveType() differentiates between pedimento_simplificado (paid) and proforma (unpaid).
+// proformaDefinition is kept as reference but not used directly in the registry since resolution is handled post-extraction.
+const documentTypes = [
+  pedimentoSimplificadoDefinition,
+  pedimentoCompletoDefinition,
+  pedimentoCompletoXmlDefinition,
+  supportDocumentDefinition,
+  dodaPdfDefinition,
+  dodaXmlDefinition,
+  // factura_inter_agencia MUST be evaluated BEFORE facturasComerciales
+  // because a NORCOM↔PALCO CFDI would also match the generic commercial
+  // invoice matcher. First match wins (see extractDocumentFields).
+  facturaInterAgenciaDefinition,
+  facturasComerciales,
+  // Add more document types here as needed
+];
+
+/**
+ * Extract document fields from text content
+ * @param {string} source - The text content to analyze
+ * @param {string} fileExtension - File extension for context
+ * @param {string} filePath - File path for context
+ * @returns {[string|null, FieldResult[], string|null, number|null]} - [detectedType, fields, pedimento, year]
+ */
+export function extractDocumentFields(source, fileExtension, filePath) {
+  if (!source || typeof source !== 'string') {
+    return [null, [], null, null];
+  }
+
+  // Try to match against each document type
+  for (const docType of documentTypes) {
+    // Check if file extension matches
+    if (
+      fileExtension &&
+      !docType.extensions.includes(fileExtension.toLowerCase())
+    ) {
+      continue;
+    }
+
+    // Test if content matches this document type
+    if (docType.match(source)) {
+      console.log(`✅ Matched document type: ${docType.type}`);
+
+      // Extract all fields
+      const fields = [];
+      for (const extractor of docType.extractors) {
+        try {
+          const result = extractor.extract(source);
+          fields.push(result);
+          if (result.found) {
+            console.log(`  - ${result.name}: ${result.value}`);
+          }
+        } catch (error) {
+          console.error(`Error extracting field ${extractor.field}:`, error);
+          fields.push(new FieldResult(extractor.field, false, null));
+        }
+      }
+
+      // Resolve final type if the definition supports it (e.g., pedimento_simplificado vs proforma)
+      const resolvedType = docType.resolveType
+        ? docType.resolveType(fields, filePath)
+        : docType.type;
+
+      console.log(`   → Resolved type: ${resolvedType}`);
+
+      // Extract pedimento number and year. `filePath` is forwarded so XML
+      // matchers (which compose numPedimento from the filename) can use it.
+      const pedimento = docType.extractNumPedimento
+        ? docType.extractNumPedimento(source, fields, filePath)
+        : null;
+      const year = docType.extractPedimentoYear
+        ? docType.extractPedimentoYear(source, fields, filePath)
+        : null;
+
+      // Ensure downstream code (composeArelaPath) sees `numPedimento` as a
+      // field. PDF matchers add it via an explicit extractor; XML matchers
+      // compose it externally via extractNumPedimento. Backfill so both paths
+      // expose the same shape.
+      if (pedimento && !fields.some((f) => f.name === 'numPedimento')) {
+        fields.push(new FieldResult('numPedimento', true, pedimento));
+      }
+
+      return [resolvedType, fields, pedimento, year];
+    }
+  }
+
+  console.log('❓ No document type matched');
+  return [null, [], null, null];
+}

package/.claude/worktrees/agent-multi-profile/src/document-types/_pedimento-shared-extractors.js

@@ -0,0 +1,348 @@
+// Shared PDF extractors used by both `pedimento_simplificado` and
+// `pedimento_completo` matchers. Keeping the regexes in a single module
+// prevents drift between the two pedimento variants.
+import { FieldResult } from '../document-type-shared.js';
+
+// 1) Número de Pedimento (15 digits, possibly separated by spaces)
+export const numPedimentoExtractor = {
+  field: 'numPedimento',
+  extract: (source) => {
+    const match = source.match(/\d{2}\s?\d{2}\s?\d{4}\s?\d{7}/);
+    return new FieldResult(
+      'numPedimento',
+      !!match,
+      match ? match[0].replace(/\s/g, '') : null,
+    );
+  },
+};
+
+// 2) Tipo de Operación: 3 chars after the pedimento number
+export const tipoOperacionExtractor = {
+  field: 'tipoOperacion',
+  extract: (source) => {
+    const match = source.match(/\d{2}\s+\d{2}\s+\d{4}\s+\d{7}\s+([A-Z]{3})/);
+    return new FieldResult('tipoOperacion', !!match, match ? match[1] : null);
+  },
+};
+
+// 3) Clave de Pedimento: 2 chars after tipoOperacion (multiple layout patterns)
+export const clavePedimentoExtractor = {
+  field: 'clavePedimento',
+  extract: (source) => {
+    const patterns = [
+      // Standard spaced layout: "22 07 3429 2002089 EXP RT"
+      /\d{2}\s+\d{2}\s+\d{4}\s+\d{7}\s+[A-Z]{3}\s+([A-Z0-9]{2})\b/,
+      // Concatenated 15-digit layout: "260734296013645 EXP RT"
+      /\d{15}\s+[A-Z]{3}\s+([A-Z0-9]{2})\b/,
+      // Fallback: T.OPER keyword followed by 2-char clave
+      /\b(?:EXP|IMP|TRA|TRN)\s+([A-Z][A-Z0-9])\b/,
+      // Explicit label
+      /CVE\.?\s*PED(?:IMENTO)?[^A-Z0-9]{0,60}?\b([A-Z][A-Z0-9])\b/i,
+    ];
+    for (const re of patterns) {
+      const m = source.match(re);
+      if (m) return new FieldResult('clavePedimento', true, m[1]);
+    }
+    return new FieldResult('clavePedimento', false, null);
+  },
+};
+
+// 4) Aduana E/S: 3-digit code on the peso-bruto line
+//    Fallback A: allow 2-digit code (some SIMP layouts omit the leading zero).
+//    Fallback B: derive the 2-digit customs-office code from positions 2-3 of
+//    numPedimento (e.g. "260734296013645" → "07"), which is what the
+//    arela_path formula uses after padStart(2,'0').
+export const aduanaEntradaSalidaExtractor = {
+  field: 'aduanaEntradaSalida',
+  extract: (source) => {
+    // Primary: 3-digit aduana code at end of peso-bruto line
+    const m3 = source.match(/^\s*\d+\s+[\d,.]+\s+(\d{3})\s*$/m);
+    if (m3) return new FieldResult('aduanaEntradaSalida', true, m3[1]);
+
+    // Fallback A: 2-digit aduana code at end of peso-bruto line
+    const m2 = source.match(/^\s*\d+\s+[\d,.]+\s+(\d{2})\s*$/m);
+    if (m2) return new FieldResult('aduanaEntradaSalida', true, m2[1]);
+
+    // Fallback B: derive 2-digit customs-office code from numPedimento
+    //   Format: AA BB CCCC DDDDDDD  →  BB (positions 2-3) = aduana
+    const pedMatch = source.match(/\d{2}\s?\d{2}\s?\d{4}\s?\d{7}/);
+    if (pedMatch) {
+      const num = pedMatch[0].replace(/\s/g, '');
+      if (num.length === 15) {
+        return new FieldResult(
+          'aduanaEntradaSalida',
+          true,
+          num.substring(2, 4),
+        );
+      }
+    }
+
+    return new FieldResult('aduanaEntradaSalida', false, null);
+  },
+};
+
+// 5) RFC: importer/exporter RFC on its own line.
+//    Strategy A: strict whole-line pattern (3-4 letters + 6 consecutive digits +
+//    3 alphanum). COVE codes like COVE2681B1RX8 naturally fail this because
+//    their digit section is non-consecutive (2681B1 has a letter at pos 5).
+//    Strategy B: RFC as a word within a longer line (handles "RFC: IMS030409FZ0").
+//    Strategy C: loose 12-13 alphanum isolated on its own line — iterate ALL
+//    matches via matchAll() so that a leading COVE code is skipped and the
+//    actual RFC (which appears later in the document) is still found.
+export const rfcExtractor = {
+  field: 'rfc',
+  extract: (source) => {
+    const RFC_STRICT = /^[A-Z]{3,4}\d{6}[A-Z0-9]{3}$/i;
+    const lines = source
+      .split(/\r?\n/)
+      .map((l) => l.trim())
+      .filter((l) => l);
+
+    // Primary: RFC occupies an entire trimmed line
+    const strictLine = lines.find((line) => RFC_STRICT.test(line));
+    if (strictLine) return new FieldResult('rfc', true, strictLine);
+
+    // Fallback A: RFC embedded in a longer line (word-boundary search)
+    for (const line of lines) {
+      const m = line.match(/\b([A-Z]{3,4}\d{6}[A-Z0-9]{3})\b/i);
+      if (m) return new FieldResult('rfc', true, m[1]);
+    }
+
+    // Fallback B: loose 12-13 alphanum isolated on its own line.
+    // Use matchAll() to iterate ALL occurrences — a leading COVE code must not
+    // short-circuit the search; the RFC typically follows it in the document.
+    for (const m of source.matchAll(/\n\s*([A-Z0-9]{12,13})\s*\n/g)) {
+      if (!/^COVE/i.test(m[1])) return new FieldResult('rfc', true, m[1]);
+    }
+
+    return new FieldResult('rfc', false, null);
+  },
+};
+
+// 6) Código de Aceptación: 8 alphanumeric chars on the line right after the RFC.
+//    Uses the same RFC-line detection logic as rfcExtractor.
+export const codigoAceptacionExtractor = {
+  field: 'codigoAceptacion',
+  extract: (source) => {
+    const RFC_STRICT = /^[A-Z]{3,4}\d{6}[A-Z0-9]{3}$/i;
+    const RFC_LOOSE = /^[A-Z0-9]{12,13}$/;
+    const lines = source
+      .split(/\r?\n/)
+      .map((l) => l.trim())
+      .filter((l) => l.length > 0);
+
+    // Find RFC line using strict pattern first, then loose (excluding COVE)
+    let rfcIndex = lines.findIndex((l) => RFC_STRICT.test(l));
+    if (rfcIndex < 0) {
+      rfcIndex = lines.findIndex((l) => RFC_LOOSE.test(l) && !/^COVE/i.test(l));
+    }
+
+    let code = null;
+    if (rfcIndex >= 0 && /^[A-Z0-9]{8}$/.test(lines[rfcIndex + 1] || '')) {
+      code = lines[rfcIndex + 1];
+    }
+    return new FieldResult('codigoAceptacion', code !== null, code);
+  },
+};
+
+// 7) Num. E-Document: collects all 13-char codes following
+//    `NUM. E-DOCUMENT` / `NUMERO DE E-DOCUMENT` labels. Real eDocument
+//    numbers START WITH A DIGIT (e.g. "0438261FSSN86"); MVE acuse folios
+//    ("MNVA26002Q3V5") are also listed under the same label and kept —
+//    downstream consumers filter them. The old bare [A-Z0-9]{13} also
+//    captured 13-letter words (TRANSPORTISTA), truncated tokens
+//    (IDENTIFICACIO[N], CURP prefixes) and RFCs.
+const EDOC_RE = /(?<![A-Z0-9])(?:\d[A-Z0-9]{12}|MNVA[A-Z0-9]{9})(?![A-Z0-9])/g;
+
+export const numEDocumentoExtractor = {
+  field: 'numEDocumento',
+  extract: (source) => {
+    const lines = source.split(/\r?\n/);
+    const extractedCodes = [];
+    const titlePatterns = [/NUMERO\s+DE\s+E-DOCUMENT/i, /NUM\.?\s*E-DOCUMENT/i];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const hasTitle = titlePatterns.some((p) => p.test(line));
+      if (!hasTitle) continue;
+
+      // Codes on the title line itself
+      const codesInLine = line.match(EDOC_RE) || [];
+      extractedCodes.push(...codesInLine);
+
+      // Codes on the next few lines (e.g. CLAVE/COMPL. table rows)
+      for (let j = 1; j <= 10 && i + j < lines.length; j++) {
+        const nextLine = lines[i + j];
+        if (/NUMERO|OBSERVACIONES/i.test(nextLine)) break;
+        const codesInNextLine = nextLine.match(EDOC_RE) || [];
+        extractedCodes.push(...codesInNextLine);
+      }
+    }
+
+    if (extractedCodes.length === 0) {
+      return new FieldResult('numEDocumento', false, null);
+    }
+
+    const uniqueCodes = [...new Set(extractedCodes)];
+    return new FieldResult('numEDocumento', true, `[${uniqueCodes.join(',')}]`);
+  },
+};
+
+// 8) Payment date — multiple known label variants
+export const paymentDateExtractor = {
+  field: 'paymentDate',
+  extract: (source) => {
+    const patterns = [
+      /FECHA\s+DE\s+PAGO:?\s*(\d{2}\/\d{2}\/\d{4})/i, // 0: explicit label DD/MM/YYYY
+      /FECHA\s+DE\s+PAGO:?\s*(\d{4}\/\d{2}\/\d{2})/i, // 1: explicit label YYYY/MM/DD
+      /2\s+PAGO:\s*(\d{2}\/\d{2}\/\d{4})/, // 2: forma simplificada scheduled date ⚠️
+      /(?:^|\n)\s*PAGO\s+(\d{2}\/\d{2}\/\d{4})/i, // 3: PAGO at line start (original)
+      /(?<=\d)PAGO\s+(\d{2}\/\d{2}\/\d{4})/i, // 4: PAGO after digit (pdf-parse artifact)
+      /(\d{2}\/\d{2}\/\d{4})[ \t]+PAGO[ \t]*$/im, // 5: reversed layout — date before PAGO (FECHAS column)
+      // 6: forma simplificada — pdf-parse extracts table cells out of order, so the
+      // label "FECHA DE PAGO:" can appear on its own line and the value (along with
+      // other cells like línea de captura, pedimento, importe) follows several lines
+      // later. Take the FIRST dd/mm/yyyy after the label within a 400-char window.
+      // Safe because `isNoPagado` short-circuits documents without a real payment,
+      // so we won't grab the unrelated ENTRADA date from the "FECHAS:" block above.
+      /FECHA\s+DE\s+PAGO:[\s\S]{1,400}?(\d{2}\/\d{2}\/\d{4})/i,
+      /PRESENTACION:\s*(\d{2}\/\d{2}\/\d{4})/i, // 7: fallback
+    ];
+    // "*** NO PAGADO" is the explicit SAT marker that no payment has been
+    // certified. When present, the bank-certification block is physically
+    // absent, so any date matched by the fallback patterns (e.g.
+    // "2 PAGO:" with a scheduled date, or "PRESENTACION:") would be a false
+    // positive. Return null outright — the document is classified as proforma.
+    const isNoPagado = /\*{3}\s*NO\s+PAGADO/i.test(source);
+    if (isNoPagado) {
+      return new FieldResult('paymentDate', false, null);
+    }
+    for (const pattern of patterns) {
+      const m = source.match(pattern);
+      if (!m) continue;
+      return new FieldResult('paymentDate', true, m[1]);
+    }
+    return new FieldResult('paymentDate', false, null);
+  },
+};
+
+// 9) COVE — collect all `COVE<alphanum>` tokens from lines containing
+//    `COVE` or `NUMERO DE ACUSE DE VALOR`. CoveFact variant emits
+//    `COVE257W76NF2 / ID250230` → only the leading COVE token is kept
+//    because the COVE regex stops at the space before `/`.
+export const coveExtractor = {
+  field: 'cove',
+  extract: (source) => {
+    const lines = source.split(/\r?\n/);
+    const coveLines = lines.filter(
+      (line) => /COVE/i.test(line) || /NUMERO DE ACUSE DE VALOR/i.test(line),
+    );
+
+    if (coveLines.length === 0) {
+      return new FieldResult('cove', false, null);
+    }
+
+    const coveValues = [];
+    coveLines.forEach((line) => {
+      const coveMatches = line.match(/COVE[A-Z0-9]+/gi) || [];
+      coveValues.push(...coveMatches.map((m) => m.toUpperCase()));
+    });
+
+    if (coveValues.length === 0) {
+      return new FieldResult('cove', false, null);
+    }
+
+    const unique = [...new Set(coveValues)];
+    return new FieldResult('cove', true, `[${unique.join(',')}]`);
+  },
+};
+
+// 10) Patente: from the PATENTE/PEDIMENTO/ADUANA header table
+//    Fallback A: pago electrónico line "3429 4024126 07" (pedimento_completo).
+//    Fallback B: positions 4-7 of numPedimento (always available when found).
+export const patenteExtractor = {
+  field: 'patente',
+  extract: (source) => {
+    // Primary: PATENTE:/PEDIMENTO:/ADUANA: header followed by data line
+    const lines = source.split(/\r?\n/);
+    const patenteHeaderIndex = lines.findIndex((line) =>
+      /PATENTE:.*PEDIMENTO:.*ADUANA:/i.test(line),
+    );
+    if (patenteHeaderIndex >= 0) {
+      for (let i = patenteHeaderIndex + 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (/^\d+\s+\d+\s+\d+$/.test(line)) {
+          const parts = line.split(/\s+/);
+          return new FieldResult('patente', true, parts[0]);
+        }
+      }
+    }
+
+    // Fallback A: pago electrónico line "3429 4024126 07"
+    const pagoMatch = source.match(/(\d{4})\s+\d{7}\s+\d{2}/);
+    if (pagoMatch) return new FieldResult('patente', true, pagoMatch[1]);
+
+    // Fallback B: positions 4-7 of numPedimento
+    const pedMatch = source.match(/\d{2}\s?\d{2}\s?\d{4}\s?\d{7}/);
+    if (pedMatch) {
+      const num = pedMatch[0].replace(/\s/g, '');
+      if (num.length === 15) {
+        return new FieldResult('patente', true, num.substring(4, 8));
+      }
+    }
+
+    return new FieldResult('patente', false, null);
+  },
+};
+
+// 11) Fecha de Pago Rectificación — used when clavePedimento is a rectification
+export const fechaPagoRectificacionExtractor = {
+  field: 'fechaPagoRectificacion',
+  extract: (source) => {
+    const rectSectionMatch = source.match(
+      /RECTIFICACION[\s\S]{0,500}?(\d{2}\/\d{2}\/\d{4})/i,
+    );
+    if (rectSectionMatch) {
+      return new FieldResult(
+        'fechaPagoRectificacion',
+        true,
+        rectSectionMatch[1],
+      );
+    }
+    const fechaMatch = source.match(
+      /FECHA PAGO RECT[\s\S]{0,500}?(\d{2}\/\d{2}\/\d{4})/i,
+    );
+    if (fechaMatch) {
+      return new FieldResult('fechaPagoRectificacion', true, fechaMatch[1]);
+    }
+    return new FieldResult('fechaPagoRectificacion', false, null);
+  },
+};
+
+/**
+ * Canonical extractor list for both pedimento_simplificado and pedimento_completo PDFs.
+ * Order matters only for downstream tooling that inspects the result array.
+ */
+export const sharedPedimentoExtractors = [
+  numPedimentoExtractor,
+  tipoOperacionExtractor,
+  clavePedimentoExtractor,
+  aduanaEntradaSalidaExtractor,
+  rfcExtractor,
+  codigoAceptacionExtractor,
+  numEDocumentoExtractor,
+  paymentDateExtractor,
+  coveExtractor,
+  patenteExtractor,
+  fechaPagoRectificacionExtractor,
+];
+
+/**
+ * Shared helper used by both PDF matchers' `extractPedimentoYear`.
+ */
+export function pedimentoYearFromFields(fields) {
+  const numPedimento = fields?.find((f) => f.name === 'numPedimento')?.value;
+  if (!numPedimento) return null;
+  const year = parseInt(numPedimento.substring(0, 2), 10);
+  return year < 50 ? year + 2000 : year + 1900;
+}

package/.claude/worktrees/agent-multi-profile/src/document-types/doda-pdf.js

@@ -0,0 +1,121 @@
+import { FieldResult } from '../document-type-shared.js';
+
+/**
+ * DODA PDF Document Type Definition
+ * Detects DODA (Documento de Operación para Despacho Aduanero) in PDF format.
+ * DODAs are validation documents generated by VUCEM for customs clearance.
+ * They reside in the SAME directory as the pedimento_simplificado,
+ * so within-table propagation handles arela_path assignment.
+ */
+export const dodaPdfDefinition = {
+  type: 'doda_pdf',
+  extensions: ['pdf'],
+  match: (source) => {
+    // DODA PDFs contain specific markers from VUCEM/customs systems
+    const markers = [
+      /DOCUMENTO DE OPERACI[OÓ]N PARA DESPACHO ADUANERO/i,
+      /DODA/i,
+      /VUCEM/i,
+    ];
+
+    // Require the primary DODA marker, or at least 2 of the secondary markers
+    const primaryMatch = markers[0].test(source);
+    if (primaryMatch) return true;
+
+    const secondaryMatches = markers
+      .slice(1)
+      .filter((m) => m.test(source)).length;
+
+    // Also check for pedimento number + DODA-specific context
+    const hasPedimentoNumber = /\d{2}\s?\d{2}\s?\d{4}\s?\d{7}/.test(source);
+    const hasDodaContext =
+      /despacho aduanero|operaci[oó]n aduanera|validaci[oó]n/i.test(source);
+
+    return (
+      (secondaryMatches >= 2 && hasPedimentoNumber) ||
+      (hasDodaContext && hasPedimentoNumber && secondaryMatches >= 1)
+    );
+  },
+
+  extractNumPedimento: (source, fields) => {
+    return fields?.find((f) => f.name === 'numPedimento')?.value ?? null;
+  },
+
+  extractPedimentoYear: (source, fields) => {
+    const numPedimento = fields?.find((f) => f.name === 'numPedimento')?.value;
+    if (!numPedimento) return null;
+    const year = parseInt(numPedimento.substring(0, 2), 10);
+    return year < 50 ? year + 2000 : year + 1900;
+  },
+
+  extractors: [
+    {
+      field: 'numPedimento',
+      extract: (source) => {
+        // Try cadena original format: ||aduana|patente|...|pedimentos|integracion|...
+        // e.g. ||070|3429|2|4009029,4008062|109335668|A231|
+        const cadenaMatch = source.match(
+          /\|\|(\d{2,3})\|(\d{4})\|\d\|([\d,]+)\|(\d+)\|/,
+        );
+        if (cadenaMatch) {
+          const rawAduana = cadenaMatch[1];
+          // 3-digit code = aduana(2) + section(1), e.g. 070 → aduana 07
+          const aduana =
+            rawAduana.length === 3
+              ? rawAduana.slice(0, 2)
+              : rawAduana.padStart(2, '0');
+          const patente = cadenaMatch[2];
+          const pedNums = cadenaMatch[3].split(',');
+          // Use first pedimento number, pad to 7 digits
+          const pedNum = pedNums[0].padStart(7, '0');
+          // Extract year from date in cadena
+          const yearMatch = source.match(/(\d{4})-\d{2}-\d{2}/);
+          const year = yearMatch
+            ? yearMatch[1].slice(-2)
+            : new Date().getFullYear().toString().slice(-2);
+          const full = `${year}${aduana}${patente}${pedNum}`;
+          if (full.length === 15) {
+            return new FieldResult('numPedimento', true, full);
+          }
+        }
+
+        // Try dash-separated format: YY-AA-PPPP-NNNNNNN
+        const dashMatch = source.match(/(\d{2})-(\d{2})-(\d{4})-(\d{7})/);
+        if (dashMatch) {
+          const full =
+            dashMatch[1] + dashMatch[2] + dashMatch[3] + dashMatch[4];
+          return new FieldResult('numPedimento', true, full);
+        }
+
+        // Try 15-digit near pedimento keyword (avoid matching sello digital)
+        const contextMatch = source.match(
+          /pedimento[^\d]{0,30}(\d{2}\s?\d{2}\s?\d{4}\s?\d{7})/i,
+        );
+        if (contextMatch) {
+          return new FieldResult(
+            'numPedimento',
+            true,
+            contextMatch[1].replace(/\s/g, ''),
+          );
+        }
+
+        return new FieldResult('numPedimento', false, null);
+      },
+    },
+    {
+      field: 'rfc',
+      extract: (source) => {
+        // Mexican RFC: 3-4 letters + 6 digits + 3 alphanumeric
+        const match = source.match(/\b([A-ZÑ&]{3,4}\d{6}[A-Z0-9]{3})\b/);
+        return new FieldResult('rfc', !!match, match ? match[1] : null);
+      },
+    },
+    {
+      field: 'aduana',
+      extract: (source) => {
+        const match = source.match(/aduana[:\s]*(\d{2,4})/i);
+        return new FieldResult('aduana', !!match, match ? match[1] : null);
+      },
+    },
+  ],
+};