facturas 0.5.2 → 0.6.1

package/dist/index.mjs

@@ -68,10 +68,24 @@ var ArcaInvalidSoapResponseError = class extends ArcaError {
 var ArcaServiceError = class extends ArcaError {
   name = "ArcaServiceError";
   serviceCode;
+  service;
+  operation;
+  result;
+  resultLevel;
+  results;
+  cae;
+  issues;
   detail;
   constructor(message, options) {
     super(message, "ARCA_SERVICE_ERROR", options);
     this.serviceCode = options?.serviceCode;
+    this.service = options?.service;
+    this.operation = options?.operation;
+    this.result = options?.result;
+    this.resultLevel = options?.resultLevel;
+    this.results = options?.results;
+    this.cae = options?.cae;
+    this.issues = options?.issues;
     this.detail = options?.detail;
   }
 };
@@ -86,9 +100,10 @@ var ARCA_ENV_VARIABLES = {
 };
 var PRIVATE_KEY_PEM_PREFIXES = [
   "-----BEGIN PRIVATE KEY-----",
-  "-----BEGIN RSA PRIVATE KEY-----",
-  "-----BEGIN ENCRYPTED PRIVATE KEY-----"
+  "-----BEGIN RSA PRIVATE KEY-----"
 ];
+var ENCRYPTED_PRIVATE_KEY_PEM_PREFIX = "-----BEGIN ENCRYPTED PRIVATE KEY-----";
+var LEGACY_ENCRYPTED_RSA_PRIVATE_KEY_PATTERN = /^-----BEGIN RSA PRIVATE KEY-----[\s\S]*^Proc-Type:\s*4,\s*ENCRYPTED\s*$/m;
 var VALID_ARCA_LOG_LEVELS = ["debug", "info", "warn", "error"];
 var DEFAULT_ARCA_TIMEOUT_MS = 3e4;
 var DEFAULT_ARCA_RETRIES = 0;
@@ -119,6 +134,11 @@ function assertArcaClientConfig(config) {
   const timeout = normalized.timeout ?? DEFAULT_ARCA_TIMEOUT_MS;
   const retries = normalized.retries ?? DEFAULT_ARCA_RETRIES;
   const retryDelay = normalized.retryDelay ?? DEFAULT_ARCA_RETRY_DELAY_MS;
+  if (normalized.privateKeyPem.startsWith(ENCRYPTED_PRIVATE_KEY_PEM_PREFIX) || LEGACY_ENCRYPTED_RSA_PRIVATE_KEY_PATTERN.test(normalized.privateKeyPem)) {
+    throw new ArcaConfigurationError(
+      "Encrypted private keys are not supported. Provide an unencrypted PKCS#8 or RSA private key PEM."
+    );
+  }
   if (!/^\d{11}$/.test(normalized.taxId)) {
     invalidFields.push("taxId");
   }
@@ -432,7 +452,7 @@ async function executePadronOperation(options, service, operation, body) {
 
 // src/services/wsfe.ts
 function createWsfeService(options) {
-  async function executeWsfeAuthenticatedOperation(operation, input, body = {}) {
+  async function executeWsfeAuthenticatedRawOperation(operation, input, body = {}, retries) {
     const auth = await options.auth.login("wsfe", {
       representedTaxId: input.representedTaxId,
       forceRefresh: input.forceRefresh
@@ -440,6 +460,7 @@ function createWsfeService(options) {
     const response = await options.soap.execute({
       service: "wsfe",
       operation,
+      ...retries === void 0 ? {} : { retries },
       body: {
         Auth: createWsfeAuth(
           input.representedTaxId ?? options.config.taxId,
@@ -449,7 +470,16 @@ function createWsfeService(options) {
         ...body
       }
     });
-    return unwrapWsfeOperationResult(operation, response.result);
+    return unwrapWsfeOperationEnvelope(operation, response.result);
+  }
+  async function executeWsfeAuthenticatedOperation(operation, input, body = {}) {
+    const result = await executeWsfeAuthenticatedRawOperation(
+      operation,
+      input,
+      body
+    );
+    throwForWsfeOperationErrors(operation, result);
+    return result;
   }
   async function executeWsfeOperation(operation, body = {}) {
     const response = await options.soap.execute({
@@ -457,7 +487,9 @@ function createWsfeService(options) {
       operation,
       body
     });
-    return unwrapWsfeOperationResult(operation, response.result);
+    const result = unwrapWsfeOperationEnvelope(operation, response.result);
+    throwForWsfeOperationErrors(operation, result);
+    return result;
   }
   async function getNextVoucherNumber({
     representedTaxId,
@@ -499,55 +531,148 @@ function createWsfeService(options) {
       forceRefresh
     });
   }
+  function authorizeVoucherOutcome({
+    representedTaxId,
+    data,
+    voucherNumber,
+    forceRefresh
+  }) {
+    const normalizedInput = normalizeWsfeVoucherInput(data);
+    return executeWsfeAuthorization({
+      representedTaxId,
+      data: normalizedInput,
+      voucherNumber,
+      forceRefresh
+    }).then(({ outcome }) => outcome);
+  }
   async function authorizeNormalizedVoucher({
     representedTaxId,
     data: normalizedInput,
     voucherNumber,
     forceRefresh
   }) {
-    const requestData = mapWsfeVoucherInput(normalizedInput, voucherNumber);
-    const auth = await options.auth.login("wsfe", {
+    const execution = await executeWsfeAuthorization({
       representedTaxId,
+      data: normalizedInput,
+      voucherNumber,
       forceRefresh
     });
-    const response = await options.soap.execute({
-      service: "wsfe",
-      operation: "FECAESolicitar",
-      body: {
-        Auth: createWsfeAuth(
-          representedTaxId ?? options.config.taxId,
-          auth.token,
-          auth.sign
-        ),
-        FeCAEReq: {
-          FeCabReq: {
-            CantReg: 1,
-            PtoVta: normalizedInput.salesPoint,
-            CbteTipo: normalizedInput.voucherType
-          },
-          FeDetReq: {
-            FECAEDetRequest: requestData
+    if (execution.error) {
+      throw execution.error;
+    }
+    if (execution.outcome.kind !== "authorized") {
+      throw createWsfeOutcomeError(execution.outcome);
+    }
+    const { cae, caeExpiry, raw } = execution.outcome;
+    if (!(caeExpiry && raw)) {
+      throw new ArcaServiceError("WSFE did not return CAE authorization data", {
+        service: "wsfe",
+        operation: "FECAESolicitar",
+        result: execution.outcome.result,
+        resultLevel: execution.outcome.resultLevel,
+        results: execution.outcome.results,
+        cae,
+        issues: [
+          ...execution.outcome.errors,
+          ...execution.outcome.observations
+        ],
+        detail: raw
+      });
+    }
+    return {
+      cae,
+      caeExpiry,
+      voucherNumber,
+      raw
+    };
+  }
+  async function executeWsfeAuthorization({
+    representedTaxId,
+    data: normalizedInput,
+    voucherNumber,
+    forceRefresh
+  }) {
+    const requestData = mapWsfeVoucherInput(normalizedInput, voucherNumber);
+    try {
+      const result = await executeWsfeAuthenticatedRawOperation(
+        "FECAESolicitar",
+        { representedTaxId, forceRefresh },
+        {
+          FeCAEReq: {
+            FeCabReq: {
+              CantReg: 1,
+              PtoVta: normalizedInput.salesPoint,
+              CbteTipo: normalizedInput.voucherType
+            },
+            FeDetReq: {
+              FECAEDetRequest: requestData
+            }
           }
+        },
+        0
+      );
+      return {
+        outcome: classifyWsfeAuthorization(result, voucherNumber)
+      };
+    } catch (error) {
+      return {
+        outcome: createWsfeIndeterminateOutcome(error),
+        error
+      };
+    }
+  }
+  async function lookupVoucher({
+    representedTaxId,
+    number,
+    salesPoint,
+    voucherType,
+    forceRefresh
+  }) {
+    const operation = "FECompConsultar";
+    const result = await executeWsfeAuthenticatedRawOperation(
+      operation,
+      { representedTaxId, forceRefresh },
+      {
+        FeCompConsReq: {
+          CbteNro: number,
+          PtoVta: salesPoint,
+          CbteTipo: voucherType
         }
       }
-    });
-    const result = unwrapWsfeOperationResult("FECAESolicitar", response.result);
-    const detailResponse = normalizeWsfeDetailResponse(result);
-    const cae = detailResponse.CAE;
-    const caeExpiry = detailResponse.CAEFchVto;
-    if (typeof cae !== "string" || typeof caeExpiry !== "string") {
-      throw new ArcaServiceError("WSFE did not return CAE authorization data", {
+    );
+    const errors = extractWsfeGlobalIssues(result, operation);
+    if (errors.length > 0 && errors.every((issue) => issue.code === "602")) {
+      return {
+        kind: "not_found",
+        service: "wsfe",
+        operation,
+        errors,
+        observations: [],
+        raw: result
+      };
+    }
+    if (errors.length > 0) {
+      throw createWsfeServiceError(operation, result, errors);
+    }
+    const raw = toWsfeRecord(result.ResultGet);
+    if (!raw) {
+      throw new ArcaServiceError("WSFE did not return the consulted voucher", {
+        service: "wsfe",
+        operation,
         detail: result
       });
     }
     return {
-      cae,
-      caeExpiry: String(caeExpiry),
-      voucherNumber,
+      kind: "found",
+      service: "wsfe",
+      operation,
+      voucher: mapWsfeVoucherInfo(raw),
+      observations: [],
       raw: result
     };
   }
   return {
+    authorizeVoucherOutcome,
     authorizeVoucher,
     async createNextVoucher({ representedTaxId, data, forceRefresh }) {
       const normalizedInput = normalizeWsfeVoucherInput(data);
@@ -659,42 +784,14 @@ function createWsfeService(options) {
       const raw = result.ResultGet ?? {};
       return mapWsfeQuotation(raw);
     },
-    async getVoucherInfo({
-      representedTaxId,
-      number,
-      salesPoint,
-      voucherType,
-      forceRefresh
-    }) {
-      const result = await executeWsfeAuthenticatedOperation(
-        "FECompConsultar",
-        {
-          representedTaxId,
-          forceRefresh
-        },
-        {
-          FeCompConsReq: {
-            CbteNro: number,
-            PtoVta: salesPoint,
-            CbteTipo: voucherType
-          }
-        }
-      );
-      const raw = result.ResultGet ?? null;
-      if (!raw) {
-        return null;
-      }
-      return mapWsfeVoucherInfo(raw);
-    }
+    async getVoucherInfo(input) {
+      const lookup = await lookupVoucher(input);
+      return lookup.kind === "found" ? lookup.voucher : null;
+    },
+    lookupVoucher
   };
 }
 function mapWsfeVoucherInput(input, voucherNumber) {
-  const sendsSameForeignCurrencyCancellation = input.currencyId !== "PES" && input.sameCurrencyForeignCancellation === "S";
-  if (input.exchangeRate === void 0 && !sendsSameForeignCurrencyCancellation) {
-    throw new ArcaInputError(
-      "exchangeRate is required unless sameCurrencyForeignCancellation is S for a foreign-currency voucher."
-    );
-  }
   const data = {
     Concepto: input.concept,
     DocTipo: input.documentType,
@@ -712,7 +809,7 @@ function mapWsfeVoucherInput(input, voucherNumber) {
     PtoVta: input.salesPoint,
     CbteTipo: input.voucherType
   };
-  if (!sendsSameForeignCurrencyCancellation) {
+  if (input.exchangeRate !== void 0) {
     data.MonCotiz = input.exchangeRate;
   }
   if (input.receiverVatConditionId !== void 0) {
@@ -796,6 +893,7 @@ function mapWsfeVoucherInput(input, voucherNumber) {
 function normalizeWsfeVoucherInput(input) {
   const {
     voucherDate,
+    exchangeRate,
     serviceStartDate,
     serviceEndDate,
     paymentDueDate,
@@ -803,9 +901,11 @@ function normalizeWsfeVoucherInput(input) {
     associatedPeriod,
     ...rest
   } = input;
+  const normalizedExchangeRate = normalizeWsfeExchangeRate(input, exchangeRate);
   return {
     ...rest,
     voucherDate: normalizeWsfeDateInput(voucherDate, "voucherDate"),
+    ...normalizedExchangeRate === void 0 ? {} : { exchangeRate: normalizedExchangeRate },
     ...serviceStartDate === void 0 ? {} : {
       serviceStartDate: normalizeWsfeDateInput(
         serviceStartDate,
@@ -852,6 +952,30 @@ function normalizeWsfeVoucherInput(input) {
     }
   };
 }
+function normalizeWsfeExchangeRate(input, exchangeRate) {
+  if (input.currencyId === "PES") {
+    if (exchangeRate !== void 0 && exchangeRate !== 1) {
+      throw new ArcaInputError(
+        "exchangeRate must be 1 when currencyId is PES."
+      );
+    }
+    return 1;
+  }
+  if (exchangeRate === void 0) {
+    if (input.sameCurrencyForeignCancellation === "S") {
+      return void 0;
+    }
+    throw new ArcaInputError(
+      "exchangeRate is required unless sameCurrencyForeignCancellation is S for a foreign-currency voucher."
+    );
+  }
+  if (!(Number.isFinite(exchangeRate) && exchangeRate > 0)) {
+    throw new ArcaInputError(
+      "exchangeRate must be a positive finite number for a foreign-currency voucher."
+    );
+  }
+  return exchangeRate;
+}
 function normalizeWsfeDateInput(value, fieldName) {
   if (typeof value !== "string") {
     throw new ArcaInputError(
@@ -951,17 +1075,45 @@ function mapWsfeQuotation(raw) {
   };
 }
 function mapWsfeVoucherInfo(raw) {
-  return {
+  const voucher = {
     voucherNumber: Number(raw.CbteDesde ?? raw.CbteHasta ?? 0),
-    ...raw.CbteFch === void 0 ? {} : { voucherDate: String(raw.CbteFch) },
-    ...raw.PtoVta === void 0 ? {} : { salesPoint: Number(raw.PtoVta) },
-    ...raw.CbteTipo === void 0 ? {} : { voucherType: Number(raw.CbteTipo) },
-    ...raw.ImpTotal === void 0 ? {} : { totalAmount: Number(raw.ImpTotal) },
-    ...raw.Resultado === void 0 ? {} : { result: String(raw.Resultado) },
-    ...raw.CAE === void 0 ? {} : { cae: String(raw.CAE) },
-    ...raw.CAEFchVto === void 0 ? {} : { caeExpiry: String(raw.CAEFchVto) },
     raw
   };
+  assignWsfeValue(voucher, "voucherDate", normalizeWsfeString(raw.CbteFch));
+  assignWsfeValue(voucher, "salesPoint", normalizeWsfeNumber(raw.PtoVta));
+  assignWsfeValue(voucher, "voucherType", normalizeWsfeNumber(raw.CbteTipo));
+  assignWsfeValue(voucher, "concept", normalizeWsfeNumber(raw.Concepto));
+  assignWsfeValue(voucher, "documentType", normalizeWsfeNumber(raw.DocTipo));
+  assignWsfeValue(voucher, "documentNumber", normalizeWsfeString(raw.DocNro));
+  assignWsfeValue(
+    voucher,
+    "receiverVatConditionId",
+    normalizeWsfeNumber(raw.CondicionIVAReceptorId)
+  );
+  assignWsfeValue(voucher, "totalAmount", normalizeWsfeNumber(raw.ImpTotal));
+  assignWsfeValue(
+    voucher,
+    "nonTaxableAmount",
+    normalizeWsfeNumber(raw.ImpTotConc)
+  );
+  assignWsfeValue(voucher, "netAmount", normalizeWsfeNumber(raw.ImpNeto));
+  assignWsfeValue(voucher, "exemptAmount", normalizeWsfeNumber(raw.ImpOpEx));
+  assignWsfeValue(voucher, "taxAmount", normalizeWsfeNumber(raw.ImpTrib));
+  assignWsfeValue(voucher, "vatAmount", normalizeWsfeNumber(raw.ImpIVA));
+  assignWsfeValue(voucher, "currencyId", normalizeWsfeString(raw.MonId));
+  assignWsfeValue(voucher, "exchangeRate", normalizeWsfeNumber(raw.MonCotiz));
+  assignWsfeValue(voucher, "result", normalizeWsfeString(raw.Resultado));
+  assignWsfeValue(
+    voucher,
+    "cae",
+    normalizeWsfeString(raw.CodAutorizacion ?? raw.CAE)
+  );
+  assignWsfeValue(
+    voucher,
+    "caeExpiry",
+    normalizeWsfeString(raw.FchVto ?? raw.CAEFchVto)
+  );
+  return voucher;
 }
 function createWsfeAuth(representedTaxId, token, sign) {
   return {
@@ -970,47 +1122,16 @@ function createWsfeAuth(representedTaxId, token, sign) {
     Cuit: Number.parseInt(String(representedTaxId), 10)
   };
 }
-function unwrapWsfeOperationResult(operation, response) {
+function unwrapWsfeOperationEnvelope(operation, response) {
   const operationResponse = response[`${operation}Response`];
   const result = operationResponse?.[`${operation}Result`] ?? response[`${operation}Result`] ?? response;
-  if (operation === "FECAESolicitar") {
-    const detailResponse = normalizeWsfeDetailResponse(result);
-    const resultCode = detailResponse.Resultado;
-    if (resultCode && resultCode !== "A") {
-      const observationsContainer = detailResponse.Observaciones;
-      const observations = normalizeWsfeErrors(observationsContainer?.Obs);
-      if (observations.length > 0) {
-        const firstObservation = observations[0];
-        if (!firstObservation) {
-          throw new ArcaServiceError(
-            "WSFE returned an empty observation list",
-            {
-              detail: result
-            }
-          );
-        }
-        throw new ArcaServiceError(firstObservation.message, {
-          serviceCode: firstObservation.code,
-          detail: result
-        });
-      }
-    }
-  }
-  const errorsContainer = result.Errors;
-  const errors = normalizeWsfeErrors(errorsContainer?.Err);
+  return result;
+}
+function throwForWsfeOperationErrors(operation, result) {
+  const errors = extractWsfeGlobalIssues(result, operation);
   if (errors.length > 0) {
-    const firstError = errors[0];
-    if (!firstError) {
-      throw new ArcaServiceError("WSFE returned an empty error list", {
-        detail: result
-      });
-    }
-    throw new ArcaServiceError(firstError.message, {
-      serviceCode: firstError.code,
-      detail: result
-    });
+    throw createWsfeServiceError(operation, result, errors);
   }
-  return result;
 }
 function normalizeWsfeDetailResponse(result) {
   const detailResponse = result.FeDetResp;
@@ -1020,17 +1141,248 @@ function normalizeWsfeDetailResponse(result) {
   }
   return rawDetail ?? {};
 }
-function normalizeWsfeErrors(rawErrors) {
+function classifyWsfeAuthorization(result, voucherNumber) {
+  const operation = "FECAESolicitar";
+  const header = toWsfeRecord(result.FeCabResp) ?? {};
+  const detail = normalizeWsfeDetailResponse(result);
+  const headerResult = normalizeWsfeResult(header.Resultado);
+  const detailResult = normalizeWsfeResult(detail.Resultado);
+  const resultCode = detailResult ?? headerResult;
+  const resultLevel = getWsfeResultLevel(headerResult, detailResult);
+  const cae = normalizeWsfeString(detail.CAE);
+  const caeExpiry = normalizeWsfeString(detail.CAEFchVto);
+  const errors = extractWsfeGlobalIssues(result, operation, "header");
+  const observations = extractWsfeObservations(
+    detail,
+    detailResult === "R" ? "business" : "observation"
+  );
+  const hasInfrastructureError = errors.some(
+    (issue) => issue.category === "infrastructure"
+  );
+  const base = {
+    service: "wsfe",
+    operation,
+    results: createWsfeResults(headerResult, detailResult),
+    errors,
+    observations,
+    raw: result
+  };
+  const context = {
+    base,
+    headerResult,
+    detailResult,
+    resultCode,
+    resultLevel,
+    cae,
+    caeExpiry
+  };
+  if (hasContradictoryWsfeResults(context)) {
+    return createWsfeStructuredIndeterminate(context, "contradictory_response");
+  }
+  if (hasInfrastructureError) {
+    return createWsfeStructuredIndeterminate(context, "incomplete_response");
+  }
+  if (isAuthorizedWsfeContext(context)) {
+    return {
+      ...base,
+      kind: "authorized",
+      result: "A",
+      resultLevel: "detail",
+      cae: context.cae,
+      caeExpiry: context.caeExpiry,
+      voucherNumber
+    };
+  }
+  if (isRejectedWsfeDetailContext(context)) {
+    return {
+      ...base,
+      kind: "rejected",
+      result: "R",
+      resultLevel: "detail"
+    };
+  }
+  if (isRejectedWsfeHeaderContext(context)) {
+    return {
+      ...base,
+      kind: "rejected",
+      result: "R",
+      resultLevel: "header"
+    };
+  }
+  return createWsfeStructuredIndeterminate(
+    context,
+    hasWsfeCaeContradiction(context) ? "contradictory_response" : "incomplete_response"
+  );
+}
+function getWsfeResultLevel(headerResult, detailResult) {
+  if (detailResult) {
+    return "detail";
+  }
+  return headerResult ? "header" : void 0;
+}
+function hasContradictoryWsfeResults(context) {
+  return Boolean(
+    context.headerResult && context.detailResult && context.headerResult !== context.detailResult
+  );
+}
+function isAuthorizedWsfeContext(context) {
+  return Boolean(
+    context.detailResult === "A" && context.headerResult !== "R" && context.base.errors.length === 0 && context.cae && context.caeExpiry
+  );
+}
+function isRejectedWsfeDetailContext(context) {
+  return context.detailResult === "R" && context.headerResult !== "A" && !context.cae;
+}
+function isRejectedWsfeHeaderContext(context) {
+  return context.headerResult === "R" && context.detailResult === void 0 && !context.cae && context.base.errors.length > 0 && context.base.errors.every((issue) => issue.category === "business");
+}
+function hasWsfeCaeContradiction(context) {
+  return (context.resultCode === "A" || context.resultCode === "R") && Boolean(context.cae);
+}
+function createWsfeStructuredIndeterminate(context, reason) {
+  const outcome = {
+    ...context.base,
+    kind: "indeterminate",
+    reason
+  };
+  assignWsfeValue(outcome, "result", context.resultCode);
+  assignWsfeValue(outcome, "resultLevel", context.resultLevel);
+  assignWsfeValue(outcome, "cae", context.cae);
+  assignWsfeValue(outcome, "caeExpiry", context.caeExpiry);
+  return outcome;
+}
+function createWsfeResults(headerResult, detailResult) {
+  const results = {};
+  assignWsfeValue(results, "header", headerResult);
+  assignWsfeValue(results, "detail", detailResult);
+  return results;
+}
+function createWsfeIndeterminateOutcome(error) {
+  return {
+    kind: "indeterminate",
+    service: "wsfe",
+    operation: "FECAESolicitar",
+    results: {},
+    reason: getArcaIndeterminateReason(error),
+    errors: [],
+    observations: []
+  };
+}
+function getArcaIndeterminateReason(error) {
+  if (error instanceof ArcaTransportError) {
+    return "transport_error";
+  }
+  if (error instanceof ArcaSoapFaultError) {
+    return "soap_fault";
+  }
+  if (error instanceof ArcaInvalidSoapResponseError) {
+    return "invalid_response";
+  }
+  return "unexpected_error";
+}
+function createWsfeOutcomeError(outcome) {
+  const issues = [...outcome.errors, ...outcome.observations];
+  const firstIssue = issues[0];
+  const message = firstIssue ? formatWsfeIssue(firstIssue) : outcome.kind === "rejected" ? "WSFE rejected the voucher authorization" : outcome.result === "A" ? "WSFE did not return CAE authorization data" : "WSFE did not return conclusive voucher authorization data";
+  return new ArcaServiceError(message, {
+    service: "wsfe",
+    operation: outcome.operation,
+    ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
+    ...outcome.result === void 0 ? {} : { result: outcome.result },
+    ...outcome.resultLevel === void 0 ? {} : { resultLevel: outcome.resultLevel },
+    results: outcome.results,
+    ...outcome.kind === "indeterminate" && outcome.cae ? { cae: outcome.cae } : {},
+    issues,
+    detail: outcome.raw
+  });
+}
+function createWsfeServiceError(operation, result, issues) {
+  const firstIssue = issues[0];
+  return new ArcaServiceError(
+    firstIssue ? formatWsfeIssue(firstIssue) : "WSFE returned a service error",
+    {
+      service: "wsfe",
+      operation,
+      ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
+      issues,
+      detail: result
+    }
+  );
+}
+function extractWsfeGlobalIssues(result, operation, resultLevel) {
+  const errorsContainer = toWsfeRecord(result.Errors);
+  return normalizeWsfeIssueEntries(errorsContainer?.Err).map((entry) => ({
+    service: "wsfe",
+    operation,
+    source: "error",
+    category: operation === "FECAESolicitar" && WSFE_AUTHORIZATION_INFRASTRUCTURE_CODES.has(entry.code ?? "") ? "infrastructure" : operation === "FECAESolicitar" ? "business" : "unknown",
+    ...entry.code === void 0 ? {} : { code: entry.code },
+    message: entry.message,
+    ...resultLevel === void 0 ? {} : { resultLevel }
+  }));
+}
+function extractWsfeObservations(detail, category) {
+  const observationsContainer = toWsfeRecord(detail.Observaciones);
+  return normalizeWsfeIssueEntries(observationsContainer?.Obs).map((entry) => ({
+    service: "wsfe",
+    operation: "FECAESolicitar",
+    source: "observation",
+    category,
+    ...entry.code === void 0 ? {} : { code: entry.code },
+    message: entry.message,
+    resultLevel: "detail"
+  }));
+}
+function normalizeWsfeIssueEntries(rawErrors) {
   const entries = Array.isArray(rawErrors) ? rawErrors : rawErrors ? [rawErrors] : [];
   return entries.map((entry) => entry).map((entry) => {
-    const code = entry.Code ?? entry.code ?? "N/A";
+    const code = entry.Code ?? entry.code;
     const message = entry.Msg ?? entry.msg ?? "Unknown WSFE error";
     return {
-      code: String(code),
-      message: `(${String(code)}) ${String(message)}`
+      ...code === void 0 ? {} : { code: String(code) },
+      message: String(message)
     };
   });
 }
+function formatWsfeIssue(issue) {
+  return issue.code ? `(${issue.code}) ${issue.message}` : issue.message;
+}
+function normalizeWsfeResult(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toUpperCase();
+  return normalized || void 0;
+}
+function normalizeWsfeString(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const normalized = String(value).trim();
+  return normalized || void 0;
+}
+function normalizeWsfeNumber(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const normalized = Number(value);
+  return Number.isFinite(normalized) ? normalized : void 0;
+}
+function assignWsfeValue(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function toWsfeRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+var WSFE_AUTHORIZATION_INFRASTRUCTURE_CODES = /* @__PURE__ */ new Set([
+  "500",
+  "501",
+  "502",
+  "600",
+  "601"
+]);
 function getWsfeResultEntries(result, key) {
   const rawEntries = result.ResultGet?.[key];
   if (!rawEntries) {
@@ -1043,145 +1395,227 @@ function getWsfeResultEntries(result, key) {
 
 // src/services/wsmtxca.ts
 function createWsmtxcaService(options) {
-  return {
-    async authorizeVoucher({ representedTaxId, data, forceRefresh }) {
-      const auth = await options.auth.login("wsmtxca", {
-        representedTaxId,
-        forceRefresh
-      });
-      const response = await options.soap.execute({
-        service: "wsmtxca",
-        operation: "autorizarComprobante",
-        bodyElementName: "autorizarComprobanteRequest",
-        bodyElementNamespaceMode: "prefix",
-        body: {
-          authRequest: createWsmtxcaAuth(
-            representedTaxId ?? options.config.taxId,
-            auth.token,
-            auth.sign
-          ),
-          ...data
-        }
-      });
-      const raw = unwrapWsmtxcaOperationResponse(
-        response.result,
-        "autorizarComprobante"
-      );
-      const authorizationPayload = extractWsmtxcaAuthorizationPayload(raw);
-      const messages = extractWsmtxcaMessages(raw);
-      const resultado = raw.resultado ?? authorizationPayload.resultado;
-      const caeValue = authorizationPayload.CAE ?? authorizationPayload.codigoAutorizacion ?? raw.codigoAutorizacion;
-      if (resultado === "R" || caeValue == null) {
-        throw new ArcaServiceError(
-          messages.join(" | ") || "WSMTXCA rejected the voucher authorization",
-          { detail: raw }
-        );
+  async function executeWsmtxcaAuthenticatedOperation(operation, input, body = {}, retries) {
+    const auth = await options.auth.login("wsmtxca", {
+      representedTaxId: input.representedTaxId,
+      forceRefresh: input.forceRefresh
+    });
+    const response = await options.soap.execute({
+      service: "wsmtxca",
+      operation,
+      ...retries === void 0 ? {} : { retries },
+      bodyElementName: `${operation}Request`,
+      bodyElementNamespaceMode: "prefix",
+      body: {
+        ...body,
+        authRequest: createWsmtxcaAuth(
+          input.representedTaxId ?? options.config.taxId,
+          auth.token,
+          auth.sign
+        )
       }
+    });
+    return unwrapWsmtxcaOperationResponse(response.result, operation);
+  }
+  async function executeWsmtxcaAuthorization({
+    representedTaxId,
+    data,
+    forceRefresh
+  }) {
+    if (Object.hasOwn(data, "authRequest")) {
+      throw new ArcaInputError(
+        'WSMTXCA authorization data cannot include the reserved top-level field "authRequest".'
+      );
+    }
+    try {
+      const raw = await executeWsmtxcaAuthenticatedOperation(
+        "autorizarComprobante",
+        { representedTaxId, forceRefresh },
+        data,
+        0
+      );
+      return { outcome: classifyWsmtxcaAuthorization(raw) };
+    } catch (error) {
       return {
-        cae: String(caeValue),
-        caeExpiry: normalizeWsmtxcaResponseDate(
-          authorizationPayload.fechaVencimientoCAE ?? authorizationPayload.fechaVencimiento ?? raw.fechaVencimiento
-        ),
-        voucherNumber: parseWsmtxcaVoucherNumber(
-          authorizationPayload.numeroComprobante ?? raw.numeroComprobante,
-          "WSMTXCA did not return the authorized voucher number",
-          raw
-        ),
-        messages,
-        raw
+        outcome: createWsmtxcaIndeterminateOutcome(error),
+        error
       };
-    },
-    async getLastAuthorizedVoucher({
-      representedTaxId,
-      voucherType,
-      salesPoint,
-      forceRefresh
-    }) {
-      const auth = await options.auth.login("wsmtxca", {
-        representedTaxId,
-        forceRefresh
-      });
-      const response = await options.soap.execute({
-        service: "wsmtxca",
-        operation: "consultarUltimoComprobanteAutorizado",
-        bodyElementName: "consultarUltimoComprobanteAutorizadoRequest",
-        bodyElementNamespaceMode: "prefix",
-        body: {
-          authRequest: createWsmtxcaAuth(
-            representedTaxId ?? options.config.taxId,
-            auth.token,
-            auth.sign
-          ),
-          consultaUltimoComprobanteAutorizadoRequest: {
-            codigoTipoComprobante: voucherType,
-            numeroPuntoVenta: salesPoint
-          }
+    }
+  }
+  async function authorizeVoucherOutcome(input) {
+    return (await executeWsmtxcaAuthorization(input)).outcome;
+  }
+  async function authorizeVoucher(input) {
+    const execution = await executeWsmtxcaAuthorization(input);
+    if (execution.error) {
+      throw execution.error;
+    }
+    if (execution.outcome.kind !== "authorized") {
+      throw createWsmtxcaOutcomeError(execution.outcome);
+    }
+    const { outcome } = execution;
+    return {
+      cae: outcome.cae,
+      ...outcome.caeExpiry === void 0 ? {} : { caeExpiry: outcome.caeExpiry },
+      voucherNumber: outcome.voucherNumber,
+      messages: formatWsmtxcaIssues([
+        ...outcome.errors,
+        ...outcome.observations
+      ]),
+      raw: outcome.raw ?? {}
+    };
+  }
+  async function getLastAuthorizedVoucher({
+    representedTaxId,
+    voucherType,
+    salesPoint,
+    forceRefresh
+  }) {
+    const operation = "consultarUltimoComprobanteAutorizado";
+    const raw = await executeWsmtxcaAuthenticatedOperation(
+      operation,
+      { representedTaxId, forceRefresh },
+      {
+        consultaUltimoComprobanteAutorizadoRequest: {
+          codigoTipoComprobante: voucherType,
+          numeroPuntoVenta: salesPoint
         }
-      });
-      const raw = unwrapWsmtxcaOperationResponse(
-        response.result,
-        "consultarUltimoComprobanteAutorizado"
-      );
+      }
+    );
+    const errors = extractWsmtxcaIssues(raw, operation, "error");
+    if (errors.length > 0 && errors.every((issue) => issue.code === "1502")) {
+      return { voucherNumber: 0, raw };
+    }
+    if (errors.length > 0) {
+      throw createWsmtxcaServiceError(operation, raw, errors);
+    }
+    return {
+      voucherNumber: parseWsmtxcaVoucherNumber(
+        raw.numeroComprobante ?? raw.cbteNro ?? raw.nroComprobante,
+        "WSMTXCA did not return the last authorized voucher number",
+        raw,
+        true
+      ),
+      raw
+    };
+  }
+  async function getSalesPoints({
+    representedTaxId,
+    forceRefresh
+  }) {
+    const raw = await executeWsmtxcaAuthenticatedOperation(
+      "consultarPuntosVenta",
+      { representedTaxId, forceRefresh }
+    );
+    const rawSalesPoints = toRecord(raw.arrayPuntosVenta)?.puntoVenta;
+    const entries = Array.isArray(rawSalesPoints) ? rawSalesPoints : rawSalesPoints ? [rawSalesPoints] : [];
+    const salesPoints = entries.flatMap((entry) => {
+      const record = toRecord(entry);
+      const number = parseOptionalPositiveInteger(record?.numeroPuntoVenta);
+      if (number === void 0) {
+        return [];
+      }
+      const deletedAt = normalizeWsmtxcaResponseDate(record?.fechaBaja);
+      return [
+        {
+          number,
+          blocked: String(record?.bloqueado ?? "N").toUpperCase() === "S",
+          ...deletedAt === void 0 ? {} : { deletedAt }
+        }
+      ];
+    });
+    return { salesPoints, raw };
+  }
+  async function lookupVoucher({
+    representedTaxId,
+    voucherType,
+    salesPoint,
+    voucherNumber,
+    forceRefresh
+  }) {
+    const operation = "consultarComprobante";
+    const raw = await executeWsmtxcaAuthenticatedOperation(
+      operation,
+      { representedTaxId, forceRefresh },
+      {
+        consultaComprobanteRequest: {
+          codigoTipoComprobante: voucherType,
+          numeroPuntoVenta: salesPoint,
+          numeroComprobante: voucherNumber
+        }
+      }
+    );
+    const errors = extractWsmtxcaIssues(raw, operation, "error");
+    const observations = extractWsmtxcaIssues(raw, operation, "observation");
+    if (errors.length > 0 && errors.every((issue) => issue.code === "1503")) {
       return {
-        voucherNumber: parseWsmtxcaVoucherNumber(
-          raw.numeroComprobante ?? raw.cbteNro ?? raw.nroComprobante,
-          extractWsmtxcaMessages(raw).join(" | ") || "WSMTXCA did not return the last authorized voucher number",
-          raw
-        ),
+        kind: "not_found",
+        service: "wsmtxca",
+        operation,
+        errors,
+        observations,
         raw
       };
-    },
-    async getVoucher({
-      representedTaxId,
-      voucherType,
-      salesPoint,
-      voucherNumber,
-      forceRefresh
-    }) {
-      const auth = await options.auth.login("wsmtxca", {
-        representedTaxId,
-        forceRefresh
-      });
-      const response = await options.soap.execute({
-        service: "wsmtxca",
-        operation: "consultarComprobante",
-        bodyElementName: "consultarComprobanteRequest",
-        bodyElementNamespaceMode: "prefix",
-        body: {
-          authRequest: createWsmtxcaAuth(
-            representedTaxId ?? options.config.taxId,
-            auth.token,
-            auth.sign
-          ),
-          consultaComprobanteRequest: {
-            codigoTipoComprobante: voucherType,
-            numeroPuntoVenta: salesPoint,
-            numeroComprobante: voucherNumber
-          }
+    }
+    if (errors.length > 0) {
+      throw createWsmtxcaServiceError(operation, raw, errors);
+    }
+    const voucher = extractWsmtxcaVoucherPayload(raw);
+    if (voucher === raw && !toRecord(raw.comprobante)) {
+      throw new ArcaServiceError(
+        "WSMTXCA did not return the voucher issue date",
+        {
+          service: "wsmtxca",
+          operation,
+          issues: observations,
+          detail: raw
         }
-      });
-      const raw = unwrapWsmtxcaOperationResponse(
-        response.result,
-        "consultarComprobante"
       );
-      const voucher = extractWsmtxcaVoucherPayload(raw);
-      const messages = extractWsmtxcaMessages(raw);
-      const invoiceDate = normalizeWsmtxcaResponseDate(
-        voucher.fechaEmision ?? voucher.fecha ?? voucher.CbteFch
+    }
+    return {
+      kind: "found",
+      service: "wsmtxca",
+      operation,
+      voucher: mapWsmtxcaVoucherInfo(voucher),
+      observations,
+      raw
+    };
+  }
+  async function getVoucher(input) {
+    const lookup = await lookupVoucher(input);
+    if (lookup.kind === "not_found") {
+      throw createWsmtxcaServiceError(
+        lookup.operation,
+        lookup.raw,
+        lookup.errors
+      );
+    }
+    const invoiceDate = lookup.voucher.invoiceDate;
+    if (!invoiceDate) {
+      throw new ArcaServiceError(
+        formatWsmtxcaIssues(lookup.observations)[0] ?? "WSMTXCA did not return the voucher issue date",
+        {
+          service: "wsmtxca",
+          operation: lookup.operation,
+          issues: lookup.observations,
+          detail: lookup.raw
+        }
       );
-      if (!invoiceDate) {
-        throw new ArcaServiceError(
-          messages[0] ?? "WSMTXCA did not return the voucher issue date",
-          { detail: raw }
-        );
-      }
-      return {
-        invoiceDate,
-        voucher,
-        messages,
-        raw
-      };
     }
+    return {
+      invoiceDate,
+      voucher: lookup.voucher.raw,
+      messages: formatWsmtxcaIssues(lookup.observations),
+      raw: lookup.raw
+    };
+  }
+  return {
+    authorizeVoucherOutcome,
+    authorizeVoucher,
+    getLastAuthorizedVoucher,
+    getSalesPoints,
+    lookupVoucher,
+    getVoucher
   };
 }
 function createWsmtxcaAuth(representedTaxId, token, sign) {
@@ -1192,7 +1626,7 @@ function createWsmtxcaAuth(representedTaxId, token, sign) {
   };
 }
 function toRecord(value) {
-  return value && typeof value === "object" ? value : void 0;
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function unwrapWsmtxcaOperationResponse(response, operation) {
   const responseRecord = toRecord(response) ?? {};
@@ -1202,6 +1636,9 @@ function unwrapWsmtxcaOperationResponse(response, operation) {
   if (operation === "consultarComprobante") {
     return toRecord(responseRecord.consultarComprobanteResponse) ?? toRecord(responseRecord.consultaComprobanteResponse) ?? toRecord(responseRecord.consultarComprobanteResult) ?? responseRecord;
   }
+  if (operation === "consultarPuntosVenta") {
+    return toRecord(responseRecord.consultarPuntosVentaResponse) ?? toRecord(responseRecord.consultarPuntosVentaResult) ?? responseRecord;
+  }
   return toRecord(responseRecord.consultarUltimoComprobanteAutorizadoResponse) ?? toRecord(responseRecord.consultaUltimoComprobanteAutorizadoResponse) ?? toRecord(responseRecord.consultarUltimoComprobanteAutorizadoResult) ?? responseRecord;
 }
 function extractWsmtxcaAuthorizationPayload(raw) {
@@ -1210,42 +1647,291 @@ function extractWsmtxcaAuthorizationPayload(raw) {
 function extractWsmtxcaVoucherPayload(raw) {
   return toRecord(raw.comprobanteResponse) ?? toRecord(raw.comprobante) ?? toRecord(raw.cmp) ?? raw;
 }
-function extractWsmtxcaMessages(raw) {
-  const rawErrors = raw.arrayErrores;
-  const rawObservations = raw.arrayObservaciones;
-  const toEntries = (value) => {
-    if (!value) {
-      return [];
-    }
-    if (Array.isArray(value)) {
-      return value;
+function classifyWsmtxcaAuthorization(raw) {
+  const operation = "autorizarComprobante";
+  const payload = extractWsmtxcaAuthorizationPayload(raw);
+  const result = normalizeWsmtxcaResult(raw.resultado ?? payload.resultado);
+  const cae = normalizeWsmtxcaString(
+    payload.CAE ?? payload.codigoAutorizacion ?? raw.codigoAutorizacion
+  );
+  const caeExpiry = normalizeWsmtxcaResponseDate(
+    payload.fechaVencimientoCAE ?? payload.fechaVencimiento ?? raw.fechaVencimiento
+  );
+  const voucherNumber = parseOptionalPositiveInteger(
+    payload.numeroComprobante ?? raw.numeroComprobante
+  );
+  const errors = extractWsmtxcaIssues(raw, operation, "error");
+  const observations = extractWsmtxcaIssues(raw, operation, "observation");
+  const base = {
+    service: "wsmtxca",
+    operation,
+    results: createWsmtxcaResults(result),
+    errors,
+    observations,
+    raw
+  };
+  if ((result === "A" || result === "O") && cae && voucherNumber !== void 0 && errors.length === 0) {
+    return {
+      ...base,
+      kind: "authorized",
+      result,
+      resultLevel: "operation",
+      cae,
+      ...caeExpiry === void 0 ? {} : { caeExpiry },
+      voucherNumber
+    };
+  }
+  if (result === "R" && !cae && errors.length > 0) {
+    return {
+      ...base,
+      kind: "rejected",
+      result: "R",
+      resultLevel: "operation"
+    };
+  }
+  const outcome = {
+    ...base,
+    kind: "indeterminate",
+    reason: result === "R" && Boolean(cae) || (result === "A" || result === "O") && Boolean(errors.length) ? "contradictory_response" : "incomplete_response",
+    ...result === void 0 ? {} : { result },
+    ...result === void 0 ? {} : { resultLevel: "operation" }
+  };
+  assignWsmtxcaValue(outcome, "cae", cae);
+  assignWsmtxcaValue(outcome, "caeExpiry", caeExpiry);
+  assignWsmtxcaValue(outcome, "voucherNumber", voucherNumber);
+  return outcome;
+}
+function createWsmtxcaIndeterminateOutcome(error) {
+  return {
+    kind: "indeterminate",
+    service: "wsmtxca",
+    operation: "autorizarComprobante",
+    results: {},
+    reason: getWsmtxcaIndeterminateReason(error),
+    errors: [],
+    observations: []
+  };
+}
+function getWsmtxcaIndeterminateReason(error) {
+  if (error instanceof ArcaTransportError) {
+    return "transport_error";
+  }
+  if (error instanceof ArcaSoapFaultError) {
+    return "soap_fault";
+  }
+  if (error instanceof ArcaInvalidSoapResponseError) {
+    return "invalid_response";
+  }
+  return "unexpected_error";
+}
+function createWsmtxcaOutcomeError(outcome) {
+  const issues = [...outcome.errors, ...outcome.observations];
+  const messages = formatWsmtxcaIssues(issues);
+  const firstIssue = issues[0];
+  return new ArcaServiceError(
+    messages.join(" | ") || (outcome.kind === "rejected" ? "WSMTXCA rejected the voucher authorization" : "WSMTXCA did not return conclusive voucher authorization data"),
+    {
+      service: "wsmtxca",
+      operation: outcome.operation,
+      ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
+      ...outcome.result === void 0 ? {} : { result: outcome.result },
+      ...outcome.resultLevel === void 0 ? {} : { resultLevel: outcome.resultLevel },
+      results: outcome.results,
+      ...outcome.kind === "indeterminate" && outcome.cae ? { cae: outcome.cae } : {},
+      issues,
+      detail: outcome.raw
     }
-    if (typeof value === "object") {
-      return [value];
+  );
+}
+function createWsmtxcaResults(operationResult) {
+  const results = {};
+  assignWsmtxcaValue(results, "operation", operationResult);
+  return results;
+}
+function createWsmtxcaServiceError(operation, raw, issues) {
+  const firstIssue = issues[0];
+  return new ArcaServiceError(
+    formatWsmtxcaIssues(issues).join(" | ") || "WSMTXCA returned a service error",
+    {
+      service: "wsmtxca",
+      operation,
+      ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
+      issues,
+      detail: raw
     }
-    return [];
-  };
-  const errors = toEntries(rawErrors?.codigoDescripcion).map((entry) => {
-    const code = entry.codigo == null ? "N/A" : String(entry.codigo);
-    const description = entry.descripcion == null ? "Unknown WSMTXCA error" : String(entry.descripcion);
-    return `Error ${code}: ${description}`;
+  );
+}
+function extractWsmtxcaIssues(raw, operation, source) {
+  const container = toRecord(
+    source === "error" ? raw.arrayErrores : raw.arrayObservaciones
+  );
+  return normalizeWsmtxcaIssueEntries(container?.codigoDescripcion).map(
+    (entry) => ({
+      service: "wsmtxca",
+      operation,
+      source,
+      category: source === "observation" ? "observation" : operation === "autorizarComprobante" ? "business" : "unknown",
+      ...entry.code === void 0 ? {} : { code: entry.code },
+      message: entry.message,
+      ...operation === "autorizarComprobante" ? { resultLevel: "operation" } : {}
+    })
+  );
+}
+function normalizeWsmtxcaIssueEntries(value) {
+  const entries = Array.isArray(value) ? value : value ? [value] : [];
+  return entries.map((entry) => {
+    const record = toRecord(entry) ?? {};
+    const code = record.codigo;
+    const description = record.descripcion;
+    return {
+      ...code === void 0 || code === null ? {} : { code: String(code) },
+      message: description === void 0 || description === null ? "Unknown WSMTXCA issue" : String(description)
+    };
   });
-  const observations = toEntries(rawObservations?.codigoDescripcion).map(
-    (entry) => {
-      const code = entry.codigo == null ? "N/A" : String(entry.codigo);
-      const description = entry.descripcion == null ? "" : String(entry.descripcion);
-      return `Obs ${code}: ${description}`.trim();
-    }
+}
+function formatWsmtxcaIssues(issues) {
+  return issues.map((issue) => {
+    const prefix = issue.source === "error" ? "Error" : "Obs";
+    return `${prefix}${issue.code ? ` ${issue.code}` : ""}: ${issue.message}`;
+  });
+}
+function mapWsmtxcaVoucherInfo(raw) {
+  const voucher = { raw };
+  const invoiceDate = normalizeWsmtxcaResponseDate(
+    raw.fechaEmision ?? raw.fecha ?? raw.CbteFch
+  );
+  const cae = normalizeWsmtxcaString(raw.codigoAutorizacion ?? raw.CAE);
+  const caeExpiry = normalizeWsmtxcaResponseDate(
+    raw.fechaVencimiento ?? raw.fechaVencimientoCAE
+  );
+  const vatAmount = sumWsmtxcaVatAmounts(raw.arraySubtotalesIVA);
+  assignWsmtxcaValue(
+    voucher,
+    "voucherNumber",
+    parseOptionalPositiveInteger(raw.numeroComprobante)
+  );
+  assignWsmtxcaValue(voucher, "invoiceDate", invoiceDate);
+  assignWsmtxcaValue(
+    voucher,
+    "salesPoint",
+    parseOptionalPositiveInteger(raw.numeroPuntoVenta)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "voucherType",
+    parseOptionalPositiveInteger(raw.codigoTipoComprobante)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "concept",
+    parseOptionalNumber(raw.codigoConcepto)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "documentType",
+    parseOptionalNumber(raw.codigoTipoDocumento)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "documentNumber",
+    normalizeWsmtxcaString(raw.numeroDocumento)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "receiverVatConditionId",
+    parseOptionalNumber(raw.condicionIVAReceptor)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "totalAmount",
+    parseOptionalNumber(raw.importeTotal)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "subtotalAmount",
+    parseOptionalNumber(raw.importeSubtotal)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "taxableAmount",
+    parseOptionalNumber(raw.importeGravado)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "nonTaxableAmount",
+    parseOptionalNumber(raw.importeNoGravado)
   );
-  return [...errors, ...observations];
+  assignWsmtxcaValue(
+    voucher,
+    "exemptAmount",
+    parseOptionalNumber(raw.importeExento)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "taxAmount",
+    parseOptionalNumber(raw.importeOtrosTributos)
+  );
+  assignWsmtxcaValue(voucher, "vatAmount", vatAmount);
+  assignWsmtxcaValue(
+    voucher,
+    "currencyId",
+    normalizeWsmtxcaString(raw.codigoMoneda)
+  );
+  assignWsmtxcaValue(
+    voucher,
+    "exchangeRate",
+    parseOptionalNumber(raw.cotizacionMoneda)
+  );
+  assignWsmtxcaValue(voucher, "cae", cae);
+  assignWsmtxcaValue(voucher, "caeExpiry", caeExpiry);
+  return voucher;
 }
-function parseWsmtxcaVoucherNumber(value, message, detail) {
+function sumWsmtxcaVatAmounts(value) {
+  const subtotals = toRecord(value)?.subtotalIVA;
+  const entries = Array.isArray(subtotals) ? subtotals : subtotals ? [subtotals] : [];
+  const amounts = entries.map((entry) => parseOptionalNumber(toRecord(entry)?.importe)).filter((amount) => amount !== void 0);
+  return amounts.length > 0 ? amounts.reduce((total, amount) => total + amount, 0) : void 0;
+}
+function parseWsmtxcaVoucherNumber(value, message, detail, allowZero = false) {
   const parsed = Number.parseInt(String(value ?? ""), 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new ArcaServiceError(message, { detail });
+  if (!Number.isFinite(parsed) || (allowZero ? parsed < 0 : parsed <= 0)) {
+    throw new ArcaServiceError(message, {
+      service: "wsmtxca",
+      detail
+    });
   }
   return parsed;
 }
+function parseOptionalPositiveInteger(value) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function parseOptionalNumber(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeWsmtxcaResult(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toUpperCase();
+  return normalized || void 0;
+}
+function normalizeWsmtxcaString(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const normalized = String(value).trim();
+  return normalized || void 0;
+}
+function assignWsmtxcaValue(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
 function normalizeWsmtxcaResponseDate(value) {
   if (typeof value === "number" && Number.isInteger(value)) {
     return formatCompactDateToIso(value);
@@ -1638,7 +2324,7 @@ function createSoapTransport(options) {
           soapAction: serviceConfig.soapVersion === "1.1" ? soapAction : void 0,
           useLegacyTlsSecurityLevel0: options.config.environment === "production" && serviceConfig.useLegacyTlsSecurityLevel0 === true,
           timeout: options.config.timeout,
-          retries: options.config.retries,
+          retries: request.retries ?? options.config.retries,
           retryDelay: options.config.retryDelay,
           logger: options.logger,
           service: request.service,
@@ -1751,93 +2437,129 @@ function isWsaaCredentialValid(credentials) {
 // src/wsaa/index.ts
 function createWsaaAuthModule(options) {
   const cache = /* @__PURE__ */ new Map();
-  const inFlight = /* @__PURE__ */ new Map();
-  return {
-    async login(service, authOptions = {}) {
-      const sessionKey = buildWsaaSessionKey(options.config, service);
-      const cacheKey = serializeWsaaSessionKey(sessionKey);
-      const running = inFlight.get(cacheKey);
-      if (running) {
-        return running;
+  const ordinaryInFlight = /* @__PURE__ */ new Map();
+  const forcedInFlight = /* @__PURE__ */ new Map();
+  function trackLogin(target, cacheKey, login) {
+    const promise = login();
+    target.set(cacheKey, promise);
+    const cleanup = () => {
+      if (target.get(cacheKey) === promise) {
+        target.delete(cacheKey);
       }
-      const loginPromise = (async () => {
-        const reuse = await getReusableCredentials({
-          config: options.config,
-          cache,
-          cacheKey,
-          sessionKey,
-          logger: options.logger,
-          service,
-          allowStore: !authOptions.forceRefresh,
-          allowCache: !authOptions.forceRefresh
-        });
-        if (reuse) {
-          return reuse;
-        }
-        const refresh = () => refreshWsaaCredentials({
+    };
+    promise.then(cleanup, cleanup);
+    return promise;
+  }
+  async function requestOrReuseWsaaCredentials(service, sessionKey, cacheKey, forceRefresh) {
+    const reuse = await getReusableCredentials({
+      config: options.config,
+      cache,
+      cacheKey,
+      sessionKey,
+      logger: options.logger,
+      service,
+      allowStore: !forceRefresh,
+      allowCache: !forceRefresh
+    });
+    if (reuse) {
+      return reuse;
+    }
+    const refresh = () => refreshWsaaCredentials({
+      config: options.config,
+      cache,
+      cacheKey,
+      sessionKey,
+      logger: options.logger,
+      service,
+      forceRefresh
+    });
+    if (options.config.wsaaSessionStore?.withLock) {
+      return await withWsaaSessionStoreLock(
+        options.config,
+        sessionKey,
+        service,
+        refresh
+      );
+    }
+    return await refresh();
+  }
+  async function performLogin(service, sessionKey, cacheKey, forceRefresh) {
+    try {
+      return await requestOrReuseWsaaCredentials(
+        service,
+        sessionKey,
+        cacheKey,
+        forceRefresh
+      );
+    } catch (error) {
+      if (error instanceof ArcaSoapFaultError && error.faultCode === "ns1:coe.alreadyAuthenticated") {
+        const recovered = await getReusableCredentials({
           config: options.config,
           cache,
           cacheKey,
           sessionKey,
           logger: options.logger,
           service,
-          forceRefresh: authOptions.forceRefresh === true
+          allowStore: true,
+          allowCache: true
         });
-        if (options.config.wsaaSessionStore?.withLock) {
-          return await withWsaaSessionStoreLock(
-            options.config,
-            sessionKey,
-            service,
-            refresh
+        if (recovered) {
+          options.logger?.warn(
+            "Recovered WSAA coe.alreadyAuthenticated fault",
+            {
+              service,
+              faultCode: error.faultCode
+            }
           );
+          return recovered;
         }
-        return await refresh();
-      })();
-      inFlight.set(cacheKey, loginPromise);
-      try {
-        return await loginPromise;
-      } catch (error) {
-        if (error instanceof ArcaSoapFaultError && error.faultCode === "ns1:coe.alreadyAuthenticated") {
-          const recovered = await getReusableCredentials({
-            config: options.config,
-            cache,
-            cacheKey,
-            sessionKey,
-            logger: options.logger,
-            service,
-            allowStore: true,
-            allowCache: true
-          });
-          if (recovered) {
-            options.logger?.warn(
-              "Recovered WSAA coe.alreadyAuthenticated fault",
-              {
-                service,
-                faultCode: error.faultCode
-              }
-            );
-            return recovered;
-          }
-          if (!options.config.wsaaSessionStore) {
-            throw new ArcaConfigurationError(
-              "WSAA login failed because another process likely owns a valid TA. Configure a durable wsaaSessionStore for multi-process or serverless deployments.",
-              { cause: error }
-            );
-          }
+        if (!options.config.wsaaSessionStore) {
+          throw new ArcaConfigurationError(
+            "WSAA login failed because another process likely owns a valid TA. Configure a durable wsaaSessionStore for multi-process or serverless deployments.",
+            { cause: error }
+          );
         }
-        if (error instanceof ArcaSoapFaultError) {
-          options.logger?.error("WSAA SOAP fault response", {
-            service,
-            operation: "loginCms",
-            url: ARCA_WSAA_CONFIG.endpoint[options.config.environment],
-            faultCode: error.faultCode,
-            error
-          });
+      }
+      if (error instanceof ArcaSoapFaultError) {
+        options.logger?.error("WSAA SOAP fault response", {
+          service,
+          operation: "loginCms",
+          url: ARCA_WSAA_CONFIG.endpoint[options.config.environment],
+          faultCode: error.faultCode,
+          error
+        });
+      }
+      throw error;
+    }
+  }
+  return {
+    login(service, authOptions = {}) {
+      const sessionKey = buildWsaaSessionKey(options.config, service);
+      const cacheKey = serializeWsaaSessionKey(sessionKey);
+      if (authOptions.forceRefresh) {
+        const runningForced2 = forcedInFlight.get(cacheKey);
+        if (runningForced2) {
+          return runningForced2;
         }
-        throw error;
-      } finally {
-        inFlight.delete(cacheKey);
+        const runningOrdinary2 = ordinaryInFlight.get(cacheKey);
+        return trackLogin(forcedInFlight, cacheKey, async () => {
+          await runningOrdinary2?.catch(() => void 0);
+          return await performLogin(service, sessionKey, cacheKey, true);
+        });
       }
+      const runningOrdinary = ordinaryInFlight.get(cacheKey);
+      if (runningOrdinary) {
+        return runningOrdinary;
+      }
+      const runningForced = forcedInFlight.get(cacheKey);
+      if (runningForced) {
+        return runningForced;
+      }
+      return trackLogin(
+        ordinaryInFlight,
+        cacheKey,
+        () => performLogin(service, sessionKey, cacheKey, false)
+      );
     }
   };
 }