@lapyme/arca 0.1.0 → 0.2.0

package/dist/index.js

@@ -13,6 +13,14 @@ var ArcaConfigurationError = class extends ArcaError {
     super(message, "ARCA_CONFIGURATION_ERROR", options);
   }
 };
+var ArcaInputError = class extends ArcaError {
+  name = "ArcaInputError";
+  detail;
+  constructor(message, options) {
+    super(message, "ARCA_INPUT_ERROR", options);
+    this.detail = options?.detail;
+  }
+};
 var ArcaTransportError = class extends ArcaError {
   name = "ArcaTransportError";
   statusCode;
@@ -50,15 +58,17 @@ var ARCA_ENV_VARIABLES = {
   taxId: "ARCA_TAX_ID",
   certificatePem: "ARCA_CERTIFICATE_PEM",
   privateKeyPem: "ARCA_PRIVATE_KEY_PEM",
-  environment: "ARCA_ENVIRONMENT",
-  wsaaCacheMode: "ARCA_WSAA_CACHE_MODE",
-  wsaaCacheDirectory: "ARCA_WSAA_CACHE_DIRECTORY"
+  environment: "ARCA_ENVIRONMENT"
 };
 var PRIVATE_KEY_PEM_PREFIXES = [
   "-----BEGIN PRIVATE KEY-----",
   "-----BEGIN RSA PRIVATE KEY-----",
   "-----BEGIN ENCRYPTED PRIVATE KEY-----"
 ];
+var VALID_ARCA_LOG_LEVELS = ["debug", "info", "warn", "error"];
+var DEFAULT_ARCA_TIMEOUT_MS = 3e4;
+var DEFAULT_ARCA_RETRIES = 0;
+var DEFAULT_ARCA_RETRY_DELAY_MS = 500;
 function resolveArcaEnvironment(production) {
   return production ? "production" : "test";
 }
@@ -70,34 +80,21 @@ function createArcaClientConfigFromEnv(options = {}) {
   };
   const environmentInput = readEnv(env, variableNames.environment);
   const environmentValue = normalizeEnvironmentValue(environmentInput);
-  const cacheModeInput = readEnv(env, variableNames.wsaaCacheMode);
-  const cacheModeValue = normalizeCacheMode(cacheModeInput);
   const config = {
     taxId: readEnv(env, variableNames.taxId) ?? "",
     certificatePem: readEnv(env, variableNames.certificatePem) ?? "",
     privateKeyPem: readEnv(env, variableNames.privateKeyPem) ?? "",
     environment: environmentValue ?? environmentInput ?? options.defaultEnvironment ?? "test"
   };
-  if (cacheModeValue === "disk" || cacheModeInput === "disk") {
-    config.wsaa = {
-      cache: {
-        mode: cacheModeValue ?? cacheModeInput,
-        directory: readEnv(env, variableNames.wsaaCacheDirectory) ?? ""
-      }
-    };
-  } else if (cacheModeValue === "memory" || cacheModeInput !== void 0) {
-    config.wsaa = {
-      cache: {
-        mode: cacheModeValue ?? cacheModeInput
-      }
-    };
-  }
   assertArcaClientConfig(config);
   return normalizeArcaClientConfig(config);
 }
 function assertArcaClientConfig(config) {
   const invalidFields = [];
   const normalized = normalizeArcaClientConfig(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 (!/^\d{11}$/.test(normalized.taxId)) {
     invalidFields.push("taxId");
   }
@@ -112,15 +109,21 @@ function assertArcaClientConfig(config) {
   if (!ARCA_ENVIRONMENTS.includes(normalized.environment)) {
     invalidFields.push("environment");
   }
-  const cacheConfig = config.wsaa?.cache;
-  if (cacheConfig) {
-    const cacheMode = cacheConfig.mode?.trim().toLowerCase() ?? "memory";
-    if (cacheMode !== "memory" && cacheMode !== "disk") {
-      invalidFields.push("wsaa.cache.mode");
-    }
-    if (cacheMode === "disk" && (!("directory" in cacheConfig) || cacheConfig.directory.trim().length < 1)) {
-      invalidFields.push("wsaa.cache.directory");
-    }
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    invalidFields.push("timeout");
+  }
+  if (!Number.isInteger(retries) || retries < 0) {
+    invalidFields.push("retries");
+  }
+  if (!Number.isFinite(retryDelay) || retryDelay < 0) {
+    invalidFields.push("retryDelay");
+  }
+  const loggerLevel = normalized.logger?.level;
+  if (loggerLevel !== void 0 && !VALID_ARCA_LOG_LEVELS.includes(loggerLevel)) {
+    invalidFields.push("logger.level");
+  }
+  if (normalized.logger?.log !== void 0 && typeof normalized.logger.log !== "function") {
+    invalidFields.push("logger.log");
   }
   if (invalidFields.length > 0) {
     throw new ArcaConfigurationError(
@@ -191,32 +194,21 @@ function getArcaServiceConfig(service) {
 }
 function normalizeArcaClientConfig(config) {
   const normalizedEnvironment = normalizeEnvironmentValue(String(config.environment)) ?? config.environment;
-  const normalizedCache = normalizeWsaaCacheConfig(config.wsaa?.cache);
+  const normalizedLoggerLevel = normalizeLogLevelValue(config.logger?.level);
   return {
     taxId: config.taxId.trim(),
     certificatePem: config.certificatePem.trim(),
     privateKeyPem: config.privateKeyPem.trim(),
     environment: normalizedEnvironment,
-    ...normalizedCache ? {
-      wsaa: {
-        cache: normalizedCache
+    timeout: config.timeout ?? DEFAULT_ARCA_TIMEOUT_MS,
+    retries: config.retries ?? DEFAULT_ARCA_RETRIES,
+    retryDelay: config.retryDelay ?? DEFAULT_ARCA_RETRY_DELAY_MS,
+    ...config.logger === void 0 ? {} : {
+      logger: {
+        ...config.logger,
+        ...normalizedLoggerLevel === void 0 ? {} : { level: normalizedLoggerLevel }
       }
-    } : {}
-  };
-}
-function normalizeWsaaCacheConfig(cache) {
-  if (!cache) {
-    return void 0;
-  }
-  const mode = normalizeCacheMode(cache.mode) ?? "memory";
-  if (mode !== "disk") {
-    return {
-      mode: "memory"
-    };
-  }
-  return {
-    mode,
-    directory: ("directory" in cache ? cache.directory : "").trim()
+    }
   };
 }
 function normalizeEnvironmentValue(value) {
@@ -229,18 +221,69 @@ function normalizeEnvironmentValue(value) {
   }
   return void 0;
 }
-function normalizeCacheMode(value) {
+function readEnv(env, variableName) {
+  return env[variableName]?.trim() || void 0;
+}
+function normalizeLogLevelValue(value) {
   if (!value) {
     return void 0;
   }
   const normalized = value.trim().toLowerCase();
-  if (normalized === "memory" || normalized === "disk") {
+  if (VALID_ARCA_LOG_LEVELS.includes(normalized)) {
     return normalized;
   }
-  return void 0;
+  return value;
 }
-function readEnv(env, variableName) {
-  return env[variableName]?.trim() || void 0;
+
+// src/internal/logger.ts
+var ARCA_LOG_LEVELS = ["debug", "info", "warn", "error"];
+function createArcaLogger(config) {
+  const disabled = config?.disabled ?? false;
+  const level = resolveArcaLogLevel(config?.level);
+  const sink = config?.log ?? defaultArcaLog;
+  const log = (messageLevel, message, ...args) => {
+    if (disabled || !shouldLog(level, messageLevel)) {
+      return;
+    }
+    sink(messageLevel, message, ...args);
+  };
+  return {
+    disabled,
+    level,
+    log,
+    debug(message, ...args) {
+      log("debug", message, ...args);
+    },
+    info(message, ...args) {
+      log("info", message, ...args);
+    },
+    warn(message, ...args) {
+      log("warn", message, ...args);
+    },
+    error(message, ...args) {
+      log("error", message, ...args);
+    }
+  };
+}
+function resolveArcaLogLevel(level) {
+  if (isArcaLogLevel(level)) {
+    return level;
+  }
+  const envLevel = process.env.ARCA_LOG_LEVEL?.trim().toLowerCase();
+  if (isArcaLogLevel(envLevel)) {
+    return envLevel;
+  }
+  return "warn";
+}
+function shouldLog(threshold, messageLevel) {
+  return ARCA_LOG_LEVELS.indexOf(messageLevel) >= ARCA_LOG_LEVELS.indexOf(threshold);
+}
+function isArcaLogLevel(value) {
+  return ARCA_LOG_LEVELS.includes(value);
+}
+function defaultArcaLog(level, message, ...args) {
+  const method = level === "debug" ? console.debug : level === "info" ? console.info : level === "warn" ? console.warn : console.error;
+  method(message, ...args);
 }
 
 // src/services/padron.ts
@@ -262,7 +305,7 @@ function createPadronService(options) {
       const datosGenerales = record.datosGenerales;
       return {
         taxId: String(record.idPersona ?? ""),
-        ...record.tipoPersona !== void 0 ? { personType: String(record.tipoPersona) } : {},
+        ...record.tipoPersona === void 0 ? {} : { personType: String(record.tipoPersona) },
         ...datosGenerales ? { name: extractPadronName(datosGenerales) } : {},
         raw: record
       };
@@ -281,7 +324,7 @@ function createPadronService(options) {
       }
       const record = raw;
       const idPersona = record.idPersona;
-      const taxIds = Array.isArray(idPersona) ? idPersona.map(String) : idPersona !== void 0 ? [String(idPersona)] : [];
+      const taxIds = Array.isArray(idPersona) ? idPersona.map(String) : idPersona === void 0 ? [] : [String(idPersona)];
       return {
         taxIds,
         raw: record
@@ -331,7 +374,10 @@ async function executePadronOperation(options, service, operation, body) {
     }
     return operationResponse.return ?? null;
   } catch (error) {
-    if (error instanceof ArcaSoapFaultError && error.message.toLowerCase().includes("no existe")) {
+    if (error instanceof ArcaSoapFaultError && // Public Padron A5/A13 WSDLs expose only a generic validation fault, so
+    // there is no documented not-found-specific fault code to match here.
+    // Keep the current message fallback, but treat it as fragile.
+    error.message.toLowerCase().includes("no existe")) {
       return null;
     }
     throw error;
@@ -340,43 +386,68 @@ async function executePadronOperation(options, service, operation, body) {
 
 // src/services/wsfe.ts
 function createWsfeService(options) {
-  async function getLastVoucher({
-    representedTaxId,
-    salesPoint,
-    voucherType,
-    forceAuthRefresh
-  }) {
+  async function executeWsfeAuthenticatedOperation(operation, input, body = {}) {
     const auth = await options.auth.login("wsfe", {
-      representedTaxId,
-      forceRefresh: forceAuthRefresh
+      representedTaxId: input.representedTaxId,
+      forceRefresh: input.forceAuthRefresh
     });
     const response = await options.soap.execute({
       service: "wsfe",
-      operation: "FECompUltimoAutorizado",
+      operation,
       body: {
         Auth: createWsfeAuth(
-          representedTaxId ?? options.config.taxId,
+          input.representedTaxId ?? options.config.taxId,
           auth.token,
           auth.sign
         ),
-        PtoVta: salesPoint,
-        CbteTipo: voucherType
+        ...body
       }
     });
-    const result = unwrapWsfeOperationResult(
+    return unwrapWsfeOperationResult(operation, response.result);
+  }
+  async function executeWsfeOperation(operation, body = {}) {
+    const response = await options.soap.execute({
+      service: "wsfe",
+      operation,
+      body
+    });
+    return unwrapWsfeOperationResult(operation, response.result);
+  }
+  async function getNextVoucherNumber({
+    representedTaxId,
+    salesPoint,
+    voucherType,
+    forceAuthRefresh
+  }) {
+    const result = await executeWsfeAuthenticatedOperation(
       "FECompUltimoAutorizado",
-      response.result
+      {
+        representedTaxId,
+        forceAuthRefresh
+      },
+      {
+        PtoVta: salesPoint,
+        CbteTipo: voucherType
+      }
     );
     return Number(result.CbteNro ?? 0) + 1;
   }
+  async function getWsfeCatalog(operation, resultKey, input) {
+    const result = await executeWsfeAuthenticatedOperation(operation, {
+      representedTaxId: input.representedTaxId,
+      forceAuthRefresh: input.forceAuthRefresh
+    });
+    return getWsfeResultEntries(result, resultKey).map(mapWsfeCatalogEntry);
+  }
   return {
     async createNextVoucher({ representedTaxId, data }) {
-      const voucherNumber = await getLastVoucher({
+      const normalizedInput = normalizeWsfeVoucherInput(data);
+      const voucherNumber = await getNextVoucherNumber({
         representedTaxId,
-        salesPoint: data.salesPoint,
-        voucherType: data.voucherType
+        salesPoint: normalizedInput.salesPoint,
+        voucherType: normalizedInput.voucherType
       });
-      const requestData = mapWsfeVoucherInput(data, voucherNumber);
+      const requestData = mapWsfeVoucherInput(normalizedInput, voucherNumber);
       const auth = await options.auth.login("wsfe", { representedTaxId });
       const response = await options.soap.execute({
         service: "wsfe",
@@ -390,8 +461,8 @@ function createWsfeService(options) {
           FeCAEReq: {
             FeCabReq: {
               CantReg: 1,
-              PtoVta: data.salesPoint,
-              CbteTipo: data.voucherType
+              PtoVta: normalizedInput.salesPoint,
+              CbteTipo: normalizedInput.voucherType
             },
             FeDetReq: {
               FECAEDetRequest: requestData
@@ -419,61 +490,89 @@ function createWsfeService(options) {
         raw: result
       };
     },
-    getLastVoucher,
+    getNextVoucherNumber,
+    getLastVoucher(input) {
+      return getNextVoucherNumber(input);
+    },
     async getSalesPoints({ representedTaxId, forceAuthRefresh }) {
-      const auth = await options.auth.login("wsfe", {
-        representedTaxId,
-        forceRefresh: forceAuthRefresh
-      });
-      const response = await options.soap.execute({
-        service: "wsfe",
-        operation: "FEParamGetPtosVenta",
-        body: {
-          Auth: createWsfeAuth(
-            representedTaxId ?? options.config.taxId,
-            auth.token,
-            auth.sign
-          )
-        }
-      });
-      const result = unwrapWsfeOperationResult(
+      const result = await executeWsfeAuthenticatedOperation(
         "FEParamGetPtosVenta",
-        response.result
+        {
+          representedTaxId,
+          forceAuthRefresh
+        }
       );
-      const resultGet = result.ResultGet;
-      const rawPoints = resultGet?.PtoVenta;
+      const rawPoints = result.ResultGet?.PtoVenta;
       if (!rawPoints) {
         return [];
       }
       const entries = Array.isArray(rawPoints) ? rawPoints : [rawPoints];
       return entries.map(mapWsfeSalesPoint);
     },
+    getVoucherTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposCbte", "CbteTipo", input);
+    },
+    getDocumentTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposDoc", "DocTipo", input);
+    },
+    getConceptTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposConcepto", "ConceptoTipo", input);
+    },
+    async getCurrencyTypes({ representedTaxId, forceAuthRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetTiposMonedas",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        }
+      );
+      return getWsfeResultEntries(result, "Moneda").map(mapWsfeCurrencyType);
+    },
+    getVatRates(input) {
+      return getWsfeCatalog("FEParamGetTiposIva", "IvaTipo", input);
+    },
+    getTaxTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposTributos", "TributoTipo", input);
+    },
+    getOptionalTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposOpcional", "OpcionalTipo", input);
+    },
+    async getServerStatus() {
+      const result = await executeWsfeOperation("FEDummy");
+      return mapWsfeServerStatus(result);
+    },
+    async getQuotation({ currencyId, representedTaxId, forceAuthRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetCotizacion",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        },
+        {
+          MonId: currencyId
+        }
+      );
+      const raw = result.ResultGet ?? {};
+      return mapWsfeQuotation(raw);
+    },
     async getVoucherInfo({
       representedTaxId,
       number,
       salesPoint,
       voucherType
     }) {
-      const auth = await options.auth.login("wsfe", { representedTaxId });
-      const response = await options.soap.execute({
-        service: "wsfe",
-        operation: "FECompConsultar",
-        body: {
-          Auth: createWsfeAuth(
-            representedTaxId ?? options.config.taxId,
-            auth.token,
-            auth.sign
-          ),
+      const result = await executeWsfeAuthenticatedOperation(
+        "FECompConsultar",
+        {
+          representedTaxId
+        },
+        {
           FeCompConsReq: {
             CbteNro: number,
             PtoVta: salesPoint,
             CbteTipo: voucherType
           }
         }
-      });
-      const result = unwrapWsfeOperationResult(
-        "FECompConsultar",
-        response.result
       );
       const raw = result.ResultGet ?? null;
       if (!raw) {
@@ -520,8 +619,8 @@ function mapWsfeVoucherInput(input, voucherNumber) {
         Tipo: v.type,
         PtoVta: v.salesPoint,
         Nro: v.number,
-        ...v.taxId !== void 0 ? { Cuit: v.taxId } : {},
-        ...v.voucherDate !== void 0 ? { CbteFch: v.voucherDate } : {}
+        ...v.taxId === void 0 ? {} : { Cuit: v.taxId },
+        ...v.voucherDate === void 0 ? {} : { CbteFch: v.voucherDate }
       }))
     };
   }
@@ -529,7 +628,7 @@ function mapWsfeVoucherInput(input, voucherNumber) {
     data.Tributos = {
       Tributo: input.taxes.map((t) => ({
         Id: t.id,
-        ...t.description !== void 0 ? { Desc: t.description } : {},
+        ...t.description === void 0 ? {} : { Desc: t.description },
         BaseImp: t.baseAmount,
         Alic: t.rate,
         Importe: t.amount
@@ -564,25 +663,144 @@ function mapWsfeVoucherInput(input, voucherNumber) {
   }
   return data;
 }
+function normalizeWsfeVoucherInput(input) {
+  const {
+    voucherDate,
+    serviceStartDate,
+    serviceEndDate,
+    paymentDueDate,
+    associatedVouchers,
+    ...rest
+  } = input;
+  return {
+    ...rest,
+    voucherDate: normalizeWsfeDateInput(voucherDate, "voucherDate"),
+    ...serviceStartDate === void 0 ? {} : {
+      serviceStartDate: normalizeWsfeDateInput(
+        serviceStartDate,
+        "serviceStartDate"
+      )
+    },
+    ...serviceEndDate === void 0 ? {} : {
+      serviceEndDate: normalizeWsfeDateInput(
+        serviceEndDate,
+        "serviceEndDate"
+      )
+    },
+    ...paymentDueDate === void 0 ? {} : {
+      paymentDueDate: normalizeWsfeDateInput(
+        paymentDueDate,
+        "paymentDueDate"
+      )
+    },
+    ...associatedVouchers === void 0 ? {} : {
+      associatedVouchers: associatedVouchers.map((voucher, index) => {
+        const { voucherDate: associatedVoucherDate, ...associatedRest } = voucher;
+        return {
+          ...associatedRest,
+          ...associatedVoucherDate === void 0 ? {} : {
+            voucherDate: normalizeWsfeDateInput(
+              associatedVoucherDate,
+              `associatedVouchers[${index}].voucherDate`
+            )
+          }
+        };
+      })
+    }
+  };
+}
+function normalizeWsfeDateInput(value, fieldName) {
+  if (typeof value !== "string") {
+    throw new ArcaInputError(
+      `Invalid WSFE ${fieldName}: expected a YYYY-MM-DD or YYYYMMDD string`,
+      {
+        detail: { field: fieldName, value }
+      }
+    );
+  }
+  const normalizedValue = value.trim();
+  const afipMatch = normalizedValue.match(/^(\d{4})(\d{2})(\d{2})$/);
+  if (afipMatch) {
+    const [, year, month, day] = afipMatch;
+    assertValidCalendarDate(year, month, day, fieldName, normalizedValue);
+    return normalizedValue;
+  }
+  const isoMatch = normalizedValue.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (isoMatch) {
+    const [, year, month, day] = isoMatch;
+    assertValidCalendarDate(year, month, day, fieldName, normalizedValue);
+    return `${year}${month}${day}`;
+  }
+  throw new ArcaInputError(
+    `Invalid WSFE ${fieldName}: expected a YYYY-MM-DD or YYYYMMDD string`,
+    {
+      detail: { field: fieldName, value: normalizedValue }
+    }
+  );
+}
+function assertValidCalendarDate(yearInput, monthInput, dayInput, fieldName, value) {
+  const year = Number(yearInput);
+  const month = Number(monthInput);
+  const day = Number(dayInput);
+  const candidate = new Date(Date.UTC(year, month - 1, day));
+  if (candidate.getUTCFullYear() !== year || candidate.getUTCMonth() !== month - 1 || candidate.getUTCDate() !== day) {
+    throw new ArcaInputError(
+      `Invalid WSFE ${fieldName}: received a non-existent calendar date`,
+      {
+        detail: { field: fieldName, value }
+      }
+    );
+  }
+}
 function mapWsfeSalesPoint(raw) {
   const record = raw;
   return {
     number: Number(record.Nro ?? 0),
-    ...record.EmisionTipo !== void 0 ? { emissionType: String(record.EmisionTipo) } : {},
-    ...record.Bloqueado !== void 0 ? { blocked: String(record.Bloqueado) } : {},
-    ...record.FchBaja !== void 0 ? { deletedSince: String(record.FchBaja) } : {}
+    ...record.EmisionTipo === void 0 ? {} : { emissionType: String(record.EmisionTipo) },
+    ...record.Bloqueado === void 0 ? {} : { blocked: String(record.Bloqueado) },
+    ...record.FchBaja === void 0 ? {} : { deletedSince: String(record.FchBaja) }
+  };
+}
+function mapWsfeCatalogEntry(raw) {
+  const record = raw;
+  return {
+    id: Number(record.Id ?? 0),
+    description: String(record.Desc ?? "")
+  };
+}
+function mapWsfeCurrencyType(raw) {
+  const record = raw;
+  return {
+    id: String(record.Id ?? ""),
+    description: String(record.Desc ?? ""),
+    validFrom: String(record.FchDesde ?? ""),
+    validTo: String(record.FchHasta ?? "")
+  };
+}
+function mapWsfeServerStatus(raw) {
+  return {
+    appServer: String(raw.AppServer ?? ""),
+    dbServer: String(raw.DbServer ?? ""),
+    authServer: String(raw.AuthServer ?? "")
+  };
+}
+function mapWsfeQuotation(raw) {
+  return {
+    currencyId: String(raw.MonId ?? ""),
+    rate: Number(raw.MonCotiz ?? 0),
+    date: String(raw.FchCotiz ?? "")
   };
 }
 function mapWsfeVoucherInfo(raw) {
   return {
     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.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
   };
 }
@@ -654,6 +872,15 @@ function normalizeWsfeErrors(rawErrors) {
     };
   });
 }
+function getWsfeResultEntries(result, key) {
+  const rawEntries = result.ResultGet?.[key];
+  if (!rawEntries) {
+    return [];
+  }
+  return (Array.isArray(rawEntries) ? rawEntries : [rawEntries]).map(
+    (entry) => entry
+  );
+}
 
 // src/services/wsmtxca.ts
 function createWsmtxcaService(options) {
@@ -888,13 +1115,69 @@ var legacyTlsAgent = new https.Agent({
   keepAlive: true,
   ciphers: "DEFAULT@SECLEVEL=0"
 });
-var REQUEST_TIMEOUT_MS = 3e4;
 async function postXml({
   url,
   body,
   contentType,
   soapAction,
-  useLegacyTlsSecurityLevel0 = false
+  useLegacyTlsSecurityLevel0 = false,
+  timeout = 3e4,
+  retries = 0,
+  retryDelay = 500,
+  logger,
+  service,
+  operation
+}) {
+  const totalAttempts = retries + 1;
+  for (let attempt = 1; attempt <= totalAttempts; attempt += 1) {
+    try {
+      return await postXmlOnce({
+        url,
+        body,
+        contentType,
+        soapAction,
+        useLegacyTlsSecurityLevel0,
+        timeout
+      });
+    } catch (error) {
+      if (!(error instanceof ArcaTransportError)) {
+        throw error;
+      }
+      if (attempt >= totalAttempts) {
+        logger?.error("ARCA transport request failed", {
+          service,
+          operation,
+          url,
+          attempt,
+          attempts: totalAttempts,
+          error
+        });
+        throw error;
+      }
+      const nextAttempt = attempt + 1;
+      logger?.warn(
+        `Retrying ARCA request after transport failure (attempt ${nextAttempt}/${totalAttempts})`,
+        {
+          service,
+          operation,
+          url,
+          attempt: nextAttempt,
+          attempts: totalAttempts,
+          error
+        }
+      );
+      await delay(retryDelay);
+    }
+  }
+  throw new ArcaTransportError("ARCA HTTP request exhausted retries");
+}
+async function postXmlOnce({
+  url,
+  body,
+  contentType,
+  soapAction,
+  useLegacyTlsSecurityLevel0,
+  timeout
 }) {
   const endpoint = new URL(url);
   const requestBody = Buffer.from(body, "utf8");
@@ -983,9 +1266,9 @@ async function postXml({
         });
       }
     );
-    request.setTimeout(REQUEST_TIMEOUT_MS, () => {
+    request.setTimeout(timeout, () => {
       request.destroy(
-        new Error(`ARCA HTTP request timed out after ${REQUEST_TIMEOUT_MS}ms`)
+        new Error(`ARCA HTTP request timed out after ${timeout}ms`)
       );
     });
     request.on("error", (error) => {
@@ -1006,6 +1289,11 @@ function isXmlLikeResponse(body, contentType) {
   }
   return body.trimStart().startsWith("<");
 }
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
 
 // src/internal/xml.ts
 import { XMLBuilder, XMLParser } from "fast-xml-parser";
@@ -1093,9 +1381,9 @@ function createSoapFaultError(fault) {
     detail: fault
   });
 }
-function getNestedString(value, path2) {
+function getNestedString(value, path) {
   let current = value;
-  for (const key of path2) {
+  for (const key of path) {
     if (!current || typeof current !== "object") {
       return null;
     }
@@ -1109,6 +1397,7 @@ function createSoapTransport(options) {
   return {
     async execute(request) {
       const serviceConfig = getArcaServiceConfig(request.service);
+      const url = serviceConfig.endpoint[options.config.environment];
       const soapActionOperation = request.operation;
       const bodyElementName = request.bodyElementName ?? request.operation;
       const soapAction = serviceConfig.usesEmptySoapAction ? "" : `${serviceConfig.soapActionBase}${soapActionOperation}`;
@@ -1122,34 +1411,61 @@ function createSoapTransport(options) {
           namespaceMode: request.bodyElementNamespaceMode
         }
       );
-      const responseXml = await postXml({
-        url: serviceConfig.endpoint[options.config.environment],
-        body: xml,
-        contentType,
-        soapAction: serviceConfig.soapVersion === "1.1" ? soapAction : void 0,
-        useLegacyTlsSecurityLevel0: options.config.environment === "production" && serviceConfig.useLegacyTlsSecurityLevel0 === true
-      });
-      const soapBody = parseSoapBody(responseXml);
-      const [, result] = getSingleBodyEntry(soapBody);
-      return {
+      const startedAt = Date.now();
+      options.logger?.debug("Sending ARCA SOAP request", {
         service: request.service,
         operation: request.operation,
-        raw: responseXml,
-        result
-      };
+        url
+      });
+      try {
+        const responseXml = await postXml({
+          url,
+          body: xml,
+          contentType,
+          soapAction: serviceConfig.soapVersion === "1.1" ? soapAction : void 0,
+          useLegacyTlsSecurityLevel0: options.config.environment === "production" && serviceConfig.useLegacyTlsSecurityLevel0 === true,
+          timeout: options.config.timeout,
+          retries: options.config.retries,
+          retryDelay: options.config.retryDelay,
+          logger: options.logger,
+          service: request.service,
+          operation: request.operation
+        });
+        options.logger?.debug("Received ARCA SOAP response", {
+          service: request.service,
+          operation: request.operation,
+          durationMs: Date.now() - startedAt
+        });
+        const soapBody = parseSoapBody(responseXml);
+        const [, result] = getSingleBodyEntry(soapBody);
+        return {
+          service: request.service,
+          operation: request.operation,
+          raw: responseXml,
+          result
+        };
+      } catch (error) {
+        if (error instanceof ArcaSoapFaultError) {
+          options.logger?.error("ARCA SOAP fault response", {
+            service: request.service,
+            operation: request.operation,
+            url,
+            faultCode: error.faultCode,
+            error
+          });
+        }
+        throw error;
+      }
     }
   };
 }
 
 // src/wsaa/index.ts
 import { createHash } from "crypto";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import path from "path";
 import forge from "node-forge";
 function createWsaaAuthModule(options) {
   const cache = /* @__PURE__ */ new Map();
   const inFlight = /* @__PURE__ */ new Map();
-  const persistedCache = createPersistedCredentialStore(options.config.wsaa?.cache);
   return {
     async login(service, authOptions = {}) {
       const cacheKey = buildWsaaCacheKey(options.config, service);
@@ -1159,18 +1475,27 @@ function createWsaaAuthModule(options) {
       }
       const loginPromise = (async () => {
         if (!authOptions.forceRefresh) {
-          const cached = await getCachedCredentials(
-            cache,
-            cacheKey,
-            persistedCache
-          );
+          const cached = getCachedCredentials(cache, cacheKey);
           if (cached) {
+            options.logger?.debug("Attempting WSAA login", {
+              service,
+              source: "cached"
+            });
             return cached;
           }
         }
-        const credentials = await requestCredentials(options.config, service);
+        options.logger?.debug("Attempting WSAA login", {
+          service,
+          source: "fresh"
+        });
+        const credentials = await requestCredentials(options.config, service, {
+          logger: options.logger
+        });
+        options.logger?.info("WSAA login succeeded", {
+          service,
+          expiresAt: credentials.expiresAt
+        });
         cache.set(cacheKey, credentials);
-        await persistedCache.write(cacheKey, credentials);
         return credentials;
       })();
       inFlight.set(cacheKey, loginPromise);
@@ -1178,15 +1503,27 @@ function createWsaaAuthModule(options) {
         return await loginPromise;
       } catch (error) {
         if (!authOptions.forceRefresh && error instanceof ArcaSoapFaultError && error.faultCode === "ns1:coe.alreadyAuthenticated") {
-          const cached = await getCachedCredentials(
-            cache,
-            cacheKey,
-            persistedCache
-          );
+          const cached = getCachedCredentials(cache, cacheKey);
           if (cached) {
+            options.logger?.warn(
+              "Recovered WSAA coe.alreadyAuthenticated fault",
+              {
+                service,
+                faultCode: error.faultCode
+              }
+            );
             return cached;
           }
         }
+        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;
       } finally {
         inFlight.delete(cacheKey);
@@ -1194,7 +1531,7 @@ function createWsaaAuthModule(options) {
     }
   };
 }
-async function requestCredentials(config, service) {
+async function requestCredentials(config, service, options) {
   const loginTicketRequestXml = buildLoginTicketRequest(service);
   const signedCms = signLoginTicketRequest(loginTicketRequestXml, {
     certificatePem: config.certificatePem,
@@ -1210,7 +1547,13 @@ async function requestCredentials(config, service) {
     url: ARCA_WSAA_CONFIG.endpoint[config.environment],
     body: requestXml,
     contentType: 'text/xml; charset="utf-8"',
-    soapAction: ARCA_WSAA_CONFIG.soapActionBase
+    soapAction: ARCA_WSAA_CONFIG.soapActionBase,
+    timeout: config.timeout,
+    retries: config.retries,
+    retryDelay: config.retryDelay,
+    logger: options?.logger,
+    service: "wsaa",
+    operation: "loginCms"
   });
   const soapBody = parseSoapBody(responseXml);
   const [, response] = getSingleBodyEntry(soapBody);
@@ -1233,64 +1576,13 @@ function getCertificateFingerprint(config) {
 function isCredentialValid(credentials) {
   return new Date(credentials.expiresAt).getTime() - Date.now() > 6e4;
 }
-async function getCachedCredentials(cache, cacheKey, persistedCache) {
+function getCachedCredentials(cache, cacheKey) {
   const localCached = cache.get(cacheKey);
   if (localCached && isCredentialValid(localCached)) {
     return localCached;
   }
-  const persisted = await persistedCache.read(cacheKey);
-  if (persisted) {
-    cache.set(cacheKey, persisted);
-    return persisted;
-  }
   return null;
 }
-function createPersistedCredentialStore(cacheConfig) {
-  if (!cacheConfig || cacheConfig.mode !== "disk") {
-    return {
-      async read() {
-        return null;
-      },
-      async write() {
-      }
-    };
-  }
-  const cacheDir = path.resolve(cacheConfig.directory);
-  return {
-    async read(cacheKey) {
-      try {
-        const serialized = await readFile(
-          getSharedCacheFilePath(cacheDir, cacheKey),
-          "utf8"
-        );
-        const parsed = JSON.parse(serialized);
-        if (typeof parsed.token !== "string" || typeof parsed.sign !== "string" || typeof parsed.expiresAt !== "string") {
-          return null;
-        }
-        const credentials = {
-          token: parsed.token,
-          sign: parsed.sign,
-          expiresAt: parsed.expiresAt
-        };
-        return isCredentialValid(credentials) ? credentials : null;
-      } catch {
-        return null;
-      }
-    },
-    async write(cacheKey, credentials) {
-      await mkdir(cacheDir, { recursive: true });
-      await writeFile(
-        getSharedCacheFilePath(cacheDir, cacheKey),
-        JSON.stringify(credentials),
-        "utf8"
-      );
-    }
-  };
-}
-function getSharedCacheFilePath(cacheDir, cacheKey) {
-  const fileName = `${createHash("sha256").update(cacheKey).digest("hex")}.json`;
-  return path.join(cacheDir, fileName);
-}
 function buildLoginTicketRequest(service) {
   const uniqueId = Math.floor(Date.now() / 1e3);
   const generationTime = new Date(Date.now() - 5 * 6e4).toISOString().replace(".000Z", "Z");
@@ -1359,8 +1651,9 @@ function parseLoginTicketResponse(xml) {
 function createArcaClient(config) {
   assertArcaClientConfig(config);
   const normalizedConfig = normalizeArcaClientConfig(config);
-  const auth = createWsaaAuthModule({ config: normalizedConfig });
-  const soap = createSoapTransport({ config: normalizedConfig });
+  const logger = createArcaLogger(normalizedConfig.logger);
+  const auth = createWsaaAuthModule({ config: normalizedConfig, logger });
+  const soap = createSoapTransport({ config: normalizedConfig, logger });
   return {
     config: normalizedConfig,
     wsfe: createWsfeService({ config: normalizedConfig, auth, soap }),
@@ -1373,6 +1666,7 @@ export {
   ARCA_ENV_VARIABLES,
   ArcaConfigurationError,
   ArcaError,
+  ArcaInputError,
   ArcaServiceError,
   ArcaSoapFaultError,
   ArcaTransportError,