facturas 0.21.0 → 0.22.0

package/dist/{chunk-WEEV76IC.mjs → chunk-R4MOVPYT.mjs}

@@ -7,10 +7,10 @@ import {
   ARCA_RECEIVER_CONDITION_IDS,
   ARCA_VAT_RATES,
   ARCA_VOUCHER_TYPES
-} from "./chunk-C2KX652X.mjs";
+} from "./chunk-5CGIRDZY.mjs";
 import {
   createPadronService
-} from "./chunk-QHNI4ZIA.mjs";
+} from "./chunk-FSJHE4VS.mjs";
 import {
   arcaMinorUnitsToNumber,
   assertArcaMinorUnits,
@@ -20,12 +20,19 @@ import {
   normalizeWsfeDateInput,
   normalizeWsfeVoucherInput,
   roundHalfEvenRatio,
+  serializeArcaAmount,
   serializeArcaExchangeRate,
   toIsoDate
-} from "./chunk-FQD2PZXE.mjs";
+} from "./chunk-67ISWKGE.mjs";
 import {
   createWsmtxcaService
-} from "./chunk-HSGTCGUX.mjs";
+} from "./chunk-GQGYO2Z2.mjs";
+import {
+  classifyArcaAuthenticationError,
+  classifyArcaAuthenticationIssues,
+  createArcaAuthenticationEvidence,
+  executeWithAuthenticationRecovery
+} from "./chunk-7MNVZSW6.mjs";
 import {
   ArcaConfigurationError,
   ArcaError,
@@ -155,6 +162,16 @@ var ARCA_SERVICE_CONFIG = {
     soapActionBase: "http://ar.gov.afip.dif.FEV1/",
     useLegacyTlsSecurityLevel0: true
   },
+  wsfex: {
+    namespace: "http://ar.gov.afip.dif.fexv1/",
+    endpoint: {
+      production: "https://servicios1.afip.gov.ar/wsfexv1/service.asmx",
+      test: "https://wswhomo.afip.gov.ar/wsfexv1/service.asmx"
+    },
+    soapVersion: "1.1",
+    soapActionBase: "http://ar.gov.afip.dif.fexv1/",
+    useLegacyTlsSecurityLevel0: true
+  },
   wsmtxca: {
     namespace: "http://impl.service.wsmtxca.afip.gov.ar/service/",
     endpoint: {
@@ -303,7 +320,16 @@ function voucherFamily(type) {
   });
 }
 var KINDS = ["invoice", "debit_note", "credit_note"];
+var EXPORT_TYPES = [19, 20, 21];
 function describeVoucherType(voucherType) {
+  const exportIndex = EXPORT_TYPES.indexOf(voucherType);
+  if (exportIndex !== -1) {
+    return {
+      family: "export",
+      voucherClass: "E",
+      kind: KINDS[exportIndex]
+    };
+  }
   const { family, voucherClass, types } = voucherFamily(voucherType);
   return {
     family,
@@ -699,20 +725,17 @@ function receiverDocument(document) {
     invalid("document.type", "an ARCA document type");
   }
   const number = digits(document.number, "document.number", 0, 20);
-  if (document.type === 99 || number === 0) {
-    return {};
-  }
   return { tipoDocRec: document.type, nroDocRec: number };
 }
 function digits(value, field, min, max) {
-  const text = String(value).trim();
-  if (!/^\d*$/.test(text) || text.length < min || text.length > max) {
+  const text2 = String(value).trim();
+  if (!/^\d*$/.test(text2) || text2.length < min || text2.length > max) {
     invalid(field, min === max ? `${min} digits` : `${min} to ${max} digits`);
   }
-  if (text === "") {
+  if (text2 === "") {
     return 0;
   }
-  const parsed = Number(text);
+  const parsed = Number(text2);
   if (!Number.isSafeInteger(parsed)) {
     invalid(field, "a safe integer");
   }
@@ -1175,10 +1198,10 @@ function deriveWsfeInvoice(input, now = /* @__PURE__ */ new Date()) {
   const headerTotal = Number(
     normalizeArcaAmountToMinorUnits(data.netAmount, "net") + normalizeArcaAmountToMinorUnits(data.vatAmount, "vat") + normalizeArcaAmountToMinorUnits(data.exemptAmount, "exempt") + normalizeArcaAmountToMinorUnits(data.nonTaxableAmount, "untaxed") + normalizeArcaAmountToMinorUnits(data.taxAmount, "tax")
   );
-  const reviewedTotal = input.amounts ? input.total : void 0;
-  data.totalAmount = reviewedTotal === void 0 ? headerTotal / 100 : minor(reviewedTotal, "total");
+  const reviewedTotal2 = input.amounts ? input.total : void 0;
+  data.totalAmount = reviewedTotal2 === void 0 ? headerTotal / 100 : minor(reviewedTotal2, "total");
   amounts.computedTotal += headerTotal - amounts.sentTotal;
-  amounts.sentTotal = reviewedTotal ?? headerTotal;
+  amounts.sentTotal = reviewedTotal2 ?? headerTotal;
   if (receiver.receiverVatConditionId === 5 && receiver.documentType === ARCA_DOCUMENT_TYPES.CONSUMIDOR_FINAL) {
     const [whole, fraction = ""] = currency.exchangeRate.split(".");
     const rate = BigInt(whole) * 1000000n + BigInt(fraction.padEnd(6, "0"));
@@ -1290,11 +1313,11 @@ function issueDocumentNumber(value, field, min, max) {
   if (typeof value !== "number" && typeof value !== "string") {
     invalid2(field, `a positive document number with ${min} to ${max} digits`);
   }
-  const text = String(value);
-  if (!/^\d+$/.test(text) || text.length < min || text.length > max || !Number.isSafeInteger(Number(text)) || Number(text) <= 0) {
+  const text2 = String(value);
+  if (!/^\d+$/.test(text2) || text2.length < min || text2.length > max || !Number.isSafeInteger(Number(text2)) || Number(text2) <= 0) {
     invalid2(field, `a positive document number with ${min} to ${max} digits`);
   }
-  return Number(text);
+  return Number(text2);
 }
 function deriveCurrency(input) {
   const currency = input.currency === void 0 ? "ARS" : input.currency;
@@ -1407,6 +1430,16 @@ function voucherDateWindow(input) {
   if (!(now instanceof Date) || Number.isNaN(now.getTime())) {
     invalid2("now", "a valid Date");
   }
+  if (EXPORT_TYPES.includes(input.voucherType)) {
+    if (input.service !== void 0) {
+      invalid2("service", "absent: export vouchers always use WSFEX");
+    }
+    const { from: from2, to: to2 } = exportDateWindow(
+      concept === "services",
+      buenosAiresDate(now)
+    );
+    return { from: isoDay(from2), to: isoDay(to2) };
+  }
   voucherFamily(input.voucherType);
   const { from, to } = dateWindow(
     { concept: CONCEPT_IDS[concept], voucherType: input.voucherType },
@@ -1434,18 +1467,32 @@ function dateWindow(data, service, today) {
 function assertVoucherDateWindow(data, service, today) {
   const { from, to } = dateWindow(data, service, today);
   if (data.voucherDate < from || data.voucherDate > to) {
-    const window = { from: isoDay(from), to: isoDay(to) };
-    throw new ArcaInputError(
-      `date must be from ${window.from} through ${window.to}, the window ARCA accepts on ${isoDay(today)}.`,
-      {
-        code: "ARCA_INPUT_DATE_OUTSIDE_WINDOW",
-        field: "date",
-        expected: `a date from ${window.from} through ${window.to}`,
-        window
-      }
-    );
+    throwOutsideWindow(from, to, today);
+  }
+}
+function assertExportDateWindow(voucherDate, services, today) {
+  const { from, to } = exportDateWindow(services, today);
+  if (voucherDate < from || voucherDate > to) {
+    throwOutsideWindow(from, to, today);
   }
 }
+function exportDateWindow(services, today) {
+  const from = addDays(today, -5);
+  const to = addDays(today, 5);
+  return { from, to: services ? minDate(to, endOfMonth(today)) : to };
+}
+function throwOutsideWindow(from, to, today) {
+  const window = { from: isoDay(from), to: isoDay(to) };
+  throw new ArcaInputError(
+    `date must be from ${window.from} through ${window.to}, the window ARCA accepts on ${isoDay(today)}.`,
+    {
+      code: "ARCA_INPUT_DATE_OUTSIDE_WINDOW",
+      field: "date",
+      expected: `a date from ${window.from} through ${window.to}`,
+      window
+    }
+  );
+}
 function isoDay(date) {
   return toIsoDate(date) ?? date;
 }
@@ -1546,74 +1593,1138 @@ function deriveNumericReceiver(to) {
   };
 }
 
-// src/store/types.ts
-import { createHash } from "crypto";
-function attemptKey(environment, taxId, key) {
-  return `arca:v1:attempt:${environment}:${taxId}:${key}`;
+// src/services/wsfex.ts
+function createWsfexService(options) {
+  async function executeWsfexRawOperation(operation, input, body = {}, authFields = {}) {
+    const auth2 = await options.auth.login("wsfex", {
+      representedTaxId: input.representedTaxId,
+      forceRefresh: input.forceRefresh,
+      abortSignal: input.abortSignal
+    });
+    const response = await options.soap.execute({
+      service: "wsfex",
+      operation,
+      signal: input.abortSignal,
+      body: {
+        Auth: {
+          ...createWsfexAuth(
+            input.representedTaxId ?? options.config.taxId,
+            auth2.token,
+            auth2.sign
+          ),
+          ...authFields
+        },
+        ...body
+      }
+    });
+    return unwrapWsfexOperationEnvelope(operation, response.result);
+  }
+  function executeWsfexOperation(operation, input, body = {}, authFields = {}) {
+    return executeWithAuthenticationRecovery({
+      service: "wsfex",
+      operation,
+      forceRefresh: input.forceRefresh,
+      async execute(forceRefresh) {
+        const result = await executeWsfexRawOperation(
+          operation,
+          {
+            representedTaxId: input.representedTaxId,
+            forceRefresh,
+            abortSignal: input.abortSignal
+          },
+          body,
+          authFields
+        );
+        throwForWsfexOperationError(operation, result);
+        return result;
+      }
+    });
+  }
+  async function getWsfexResultRows(operation, rowKey, input) {
+    const result = await executeWsfexOperation(operation, {
+      representedTaxId: input.representedTaxId,
+      forceRefresh: input.forceRefresh
+    });
+    return getWsfexRows(result.FEXResultGet, rowKey);
+  }
+  async function getWsfexCatalog(operation, rowKey, fields, input) {
+    const rows2 = await getWsfexResultRows(operation, rowKey, input);
+    return rows2.flatMap((row) => {
+      const id = readWsfexText(row[fields.id]);
+      return id === void 0 ? [] : [{ id, description: readWsfexText(row[fields.description]) ?? "" }];
+    });
+  }
+  function issue(input) {
+    const request = createWsfexRequest(input);
+    return executeWsfexAuthorization(input, request);
+  }
+  async function executeWsfexAuthorization(input, request) {
+    try {
+      const result = await executeWsfexRawOperation(
+        "FEXAuthorize",
+        {
+          representedTaxId: input.representedTaxId,
+          forceRefresh: input.forceRefresh,
+          abortSignal: input.abortSignal
+        },
+        { Cmp: request }
+      );
+      return classifyWsfexAuthorization(result);
+    } catch (error) {
+      return createWsfexIndeterminateOutcome(error);
+    }
+  }
+  function lookupVoucher2(input) {
+    return executeWithAuthenticationRecovery({
+      service: "wsfex",
+      operation: "FEXGetCMP",
+      forceRefresh: input.forceRefresh,
+      execute: (forceRefresh) => lookupVoucherOnce({ ...input, forceRefresh })
+    });
+  }
+  async function lookupVoucherOnce(input) {
+    const operation = "FEXGetCMP";
+    const result = await executeWsfexRawOperation(operation, input, {
+      // ClsFEXGetCMP spells it `Cbte_tipo`; the manual's `Cbte_Tipo` would
+      // be dropped by the server and consult type 0.
+      Cmp: {
+        Cbte_tipo: input.voucherType,
+        Punto_vta: input.salesPoint,
+        Cbte_nro: input.number
+      }
+    });
+    const errors = extractWsfexErrors(result, operation);
+    if (errors.length > 0 && errors.every((issue2) => issue2.code === "1020")) {
+      return {
+        kind: "not_found",
+        service: "wsfex",
+        operation,
+        errors,
+        observations: [],
+        raw: result
+      };
+    }
+    if (errors.length > 0) {
+      throw createWsfexServiceError(operation, errors);
+    }
+    const raw = toWsfexRecord(result.FEXResultGet);
+    if (!raw) {
+      throw new ArcaServiceError("WSFEX did not return the consulted voucher", {
+        service: "wsfex",
+        operation
+      });
+    }
+    return {
+      kind: "found",
+      service: "wsfex",
+      operation,
+      voucher: mapWsfexVoucherInfo(raw),
+      observations: extractWsfexReasons(
+        raw.Motivos_Obs,
+        operation,
+        "observation"
+      ),
+      raw: result
+    };
+  }
+  return {
+    issue,
+    async getLastRequestId(input = {}) {
+      const operation = "FEXGetLast_ID";
+      const result = await executeWsfexOperation(operation, input);
+      return parseWsfexInteger(toWsfexRecord(result.FEXResultGet)?.Id, {
+        operation,
+        field: "Id",
+        min: 0,
+        max: WSFEX_MAX_REQUEST_ID
+      });
+    },
+    async getLastVoucherNumber({ salesPoint, voucherType, ...input }) {
+      const operation = "FEXGetLast_CMP";
+      const result = await executeWsfexOperation(
+        operation,
+        input,
+        {},
+        { Pto_venta: salesPoint, Cbte_Tipo: voucherType }
+      );
+      return parseWsfexInteger(
+        toWsfexRecord(result.FEXResult_LastCMP)?.Cbte_nro,
+        { operation, field: "Cbte_nro", min: 0, max: 99999999 }
+      );
+    },
+    lookupVoucher: lookupVoucher2,
+    async getSalesPoints(input = {}) {
+      const rows2 = await getWsfexResultRows(
+        "FEXGetPARAM_PtoVenta",
+        "ClsFEXResponse_PtoVenta",
+        input
+      );
+      return rows2.map(mapWsfexSalesPoint);
+    },
+    getCountries(input = {}) {
+      return getWsfexCatalog(
+        "FEXGetPARAM_DST_pais",
+        "ClsFEXResponse_DST_pais",
+        { id: "DST_Codigo", description: "DST_Ds" },
+        input
+      );
+    },
+    async getCountryTaxIds(input = {}) {
+      const rows2 = await getWsfexResultRows(
+        "FEXGetPARAM_DST_CUIT",
+        "ClsFEXResponse_DST_cuit",
+        input
+      );
+      return rows2.flatMap((row) => {
+        const taxId = readWsfexText(row.DST_CUIT);
+        return taxId === void 0 ? [] : [{ taxId, description: readWsfexText(row.DST_Ds) ?? "" }];
+      });
+    },
+    getCurrencies(input = {}) {
+      return getWsfexCatalog(
+        "FEXGetPARAM_MON",
+        "ClsFEXResponse_Mon",
+        { id: "Mon_Id", description: "Mon_Ds" },
+        input
+      );
+    },
+    getIncoterms(input = {}) {
+      return getWsfexCatalog(
+        "FEXGetPARAM_Incoterms",
+        "ClsFEXResponse_Inc",
+        { id: "Inc_Id", description: "Inc_Ds" },
+        input
+      );
+    },
+    getUnits(input = {}) {
+      return getWsfexCatalog(
+        "FEXGetPARAM_UMed",
+        "ClsFEXResponse_UMed",
+        { id: "Umed_Id", description: "Umed_Ds" },
+        input
+      );
+    },
+    getLanguages(input = {}) {
+      return getWsfexCatalog(
+        "FEXGetPARAM_Idiomas",
+        "ClsFEXResponse_Idi",
+        { id: "Idi_Id", description: "Idi_Ds" },
+        input
+      );
+    },
+    getVoucherTypes(input = {}) {
+      return getWsfexCatalog(
+        "FEXGetPARAM_Cbte_Tipo",
+        "ClsFEXResponse_Cbte_Tipo",
+        { id: "Cbte_Id", description: "Cbte_Ds" },
+        input
+      );
+    },
+    getExportTypes(input = {}) {
+      return getWsfexCatalog(
+        "FEXGetPARAM_Tipo_Expo",
+        "ClsFEXResponse_Tex",
+        { id: "Tex_Id", description: "Tex_Ds" },
+        input
+      );
+    },
+    async getActivities(input = {}) {
+      const rows2 = await getWsfexResultRows(
+        "FEXGetPARAM_Actividades",
+        "ClsFEXResponse_ActividadTipo",
+        input
+      );
+      return rows2.flatMap((row) => {
+        const id = toWsfexActivityId(row.Id);
+        return id === void 0 ? [] : [{ id, description: readWsfexText(row.Desc) ?? "" }];
+      });
+    },
+    async getExchangeRate({ currencyId, date, ...input }) {
+      const operation = "FEXGetPARAM_Ctz";
+      const quotationDate = date === void 0 ? void 0 : toIsoDate(normalizeWsfexDate(date, "date"));
+      const result = await executeWsfexOperation(operation, input, {
+        Mon_id: currencyId,
+        ...optionalWsfexField("FchCotiz", quotationDate)
+      });
+      const raw = toWsfexRecord(result.FEXResultGet);
+      const rate = canonicalizeWsfexDecimal(raw?.Mon_ctz);
+      const rateDate = toIsoDate(readWsfexText(raw?.Mon_fecha));
+      if (rate === void 0 || rateDate === void 0) {
+        throw new ArcaInvalidSoapResponseError("Invalid WSFEX exchange rate", {
+          service: "wsfex",
+          operation
+        });
+      }
+      return { currencyId, rate, date: rateDate };
+    },
+    async checkPermit({ id, destination, ...input }) {
+      const operation = "FEXCheck_Permiso";
+      const result = await executeWsfexOperation(operation, input, {
+        ID_Permiso: id,
+        Dst_merc: destination
+      });
+      const status = readWsfexText(
+        toWsfexRecord(result.FEXResultGet)?.Status
+      )?.toUpperCase();
+      if (status === "OK" || status === "NO") {
+        return status === "OK";
+      }
+      throw new ArcaInvalidSoapResponseError("Invalid WSFEX permit status", {
+        service: "wsfex",
+        operation
+      });
+    }
+  };
 }
-function sequenceKey(environment, taxId, salesPoint, voucherType) {
-  return `arca:v1:sequence:${environment}:${taxId}:${salesPoint}:${voucherType}`;
+var WSFEX_MAX_REQUEST_ID = 999999999999999;
+var WSFEX_VOUCHER_TYPES = [19, 20, 21];
+var WSFEX_EXPORT_TYPES = [1, 2, 4];
+var WSFEX_LANGUAGES = [1, 2, 3];
+var WSFEX_ITEM_DECIMAL_PATTERN = /^(\d{1,12})(?:\.(\d{1,6}))?$/;
+var WSFEX_TAX_ID_PATTERN = /^\d{11}$/;
+function assertWsfexVoucherInput(voucher) {
+  createWsfexRequest({ ...voucher, id: 0, number: 1 });
 }
-function sequenceLockKey(environment, taxId, salesPoint, voucherType) {
-  return `arca:v1:lock:sequence:${environment}:${taxId}:${salesPoint}:${voucherType}`;
+function createWsfexRequest(input) {
+  return {
+    Id: assertWsfexInteger(input.id, "id", 0, WSFEX_MAX_REQUEST_ID),
+    ...optionalWsfexField(
+      "Fecha_cbte",
+      normalizeOptionalWsfexDate(input.voucherDate, "voucherDate")
+    ),
+    Cbte_Tipo: assertWsfexCode(
+      input.voucherType,
+      "voucherType",
+      WSFEX_VOUCHER_TYPES
+    ),
+    Punto_vta: assertWsfexInteger(input.salesPoint, "salesPoint", 1, 99999),
+    Cbte_nro: assertWsfexInteger(input.number, "number", 1, 99999999),
+    Tipo_expo: assertWsfexCode(
+      input.exportType,
+      "exportType",
+      WSFEX_EXPORT_TYPES
+    ),
+    // ARCA expects the element present and empty for notes and services.
+    Permiso_existente: assertOptionalWsfexFlag(input.permitExists, "permitExists") ?? "",
+    ...optionalWsfexField(
+      "Permisos",
+      createWsfexList(input.permits, "Permiso", createWsfexPermit)
+    ),
+    Dst_cmp: assertWsfexInteger(input.destination, "destination", 1, 999),
+    Cliente: requireWsfexText(input.receiverName, "receiverName"),
+    ...optionalWsfexField(
+      "Cuit_pais_cliente",
+      assertOptionalWsfexTaxId(
+        input.receiverCountryTaxId,
+        "receiverCountryTaxId"
+      )
+    ),
+    Domicilio_cliente: requireWsfexText(
+      input.receiverAddress,
+      "receiverAddress"
+    ),
+    ...optionalWsfexField(
+      "Id_impositivo",
+      optionalWsfexText(input.receiverTaxId, "receiverTaxId")
+    ),
+    Moneda_Id: requireWsfexText(input.currencyId, "currencyId"),
+    ...optionalWsfexField(
+      "Moneda_ctz",
+      input.exchangeRate === void 0 ? void 0 : serializeArcaExchangeRate(input.exchangeRate, "exchangeRate")
+    ),
+    ...optionalWsfexField(
+      "CanMisMonExt",
+      assertOptionalWsfexFlag(
+        input.sameCurrencyForeignCancellation,
+        "sameCurrencyForeignCancellation"
+      )
+    ),
+    ...optionalWsfexField(
+      "Obs_comerciales",
+      optionalWsfexText(input.commercialObservations, "commercialObservations")
+    ),
+    Imp_total: serializeArcaAmount(input.totalAmount, "totalAmount"),
+    ...optionalWsfexField(
+      "Obs",
+      optionalWsfexText(input.observations, "observations")
+    ),
+    ...optionalWsfexField(
+      "Cmps_asoc",
+      createWsfexList(
+        input.associatedVouchers,
+        "Cmp_asoc",
+        createWsfexAssociatedVoucher
+      )
+    ),
+    ...optionalWsfexField(
+      "Forma_pago",
+      optionalWsfexText(input.paymentTerms, "paymentTerms")
+    ),
+    ...optionalWsfexField(
+      "Incoterms",
+      optionalWsfexText(input.incoterms, "incoterms")
+    ),
+    ...optionalWsfexField(
+      "Incoterms_Ds",
+      optionalWsfexText(input.incotermsDetail, "incotermsDetail")
+    ),
+    Idioma_cbte: assertWsfexCode(input.language, "language", WSFEX_LANGUAGES),
+    Items: createWsfexItems(input.items),
+    ...optionalWsfexField(
+      "Fecha_pago",
+      normalizeOptionalWsfexDate(input.paymentDate, "paymentDate")
+    ),
+    ...optionalWsfexField(
+      "Actividades",
+      createWsfexList(input.activities, "Actividad", createWsfexActivity)
+    )
+  };
 }
-function settledKey(environment, taxId, key) {
-  return `arca:v1:settled:${environment}:${taxId}:${key}`;
+function createWsfexList(rows2, key, map) {
+  if (rows2 === void 0 || rows2.length === 0) {
+    return void 0;
+  }
+  return { [key]: rows2.map(map) };
 }
-function canonicalHash(input) {
-  return createHash("sha256").update(JSON.stringify(canonical(input))).digest("hex");
+function createWsfexPermit(permit, index) {
+  return {
+    Id_permiso: requireWsfexText(permit.id, `permits[${index}].id`),
+    Dst_merc: assertWsfexInteger(
+      permit.destination,
+      `permits[${index}].destination`,
+      1,
+      999
+    )
+  };
 }
-function canonical(value) {
-  if (Array.isArray(value)) {
-    return value.map(canonical);
+function createWsfexAssociatedVoucher(voucher, index) {
+  const field = `associatedVouchers[${index}]`;
+  return {
+    Cbte_tipo: assertWsfexInteger(
+      voucher.voucherType,
+      `${field}.voucherType`,
+      1,
+      999
+    ),
+    Cbte_punto_vta: assertWsfexInteger(
+      voucher.salesPoint,
+      `${field}.salesPoint`,
+      1,
+      99999
+    ),
+    Cbte_nro: assertWsfexInteger(
+      voucher.number,
+      `${field}.number`,
+      1,
+      999999999
+    ),
+    ...optionalWsfexField(
+      "Cbte_cuit",
+      assertOptionalWsfexTaxId(voucher.issuerTaxId, `${field}.issuerTaxId`)
+    )
+  };
+}
+function createWsfexItems(items) {
+  if (!Array.isArray(items) || items.length === 0) {
+    throw new ArcaInputError("items must contain at least one item.", {
+      code: "ARCA_INPUT_MISSING_FIELD",
+      field: "items",
+      expected: "from 1 to 9999 items"
+    });
   }
-  if (value instanceof Date) {
-    return value.toJSON();
+  return { Item: items.map(createWsfexItem) };
+}
+function createWsfexItem(item, index) {
+  const field = `items[${index}]`;
+  return {
+    ...optionalWsfexField(
+      "Pro_codigo",
+      optionalWsfexText(item.code, `${field}.code`)
+    ),
+    Pro_ds: requireWsfexText(item.description, `${field}.description`),
+    ...optionalWsfexField(
+      "Pro_qty",
+      serializeWsfexItemDecimal(item.quantity, `${field}.quantity`)
+    ),
+    Pro_umed: assertWsfexInteger(item.unit, `${field}.unit`, 0, 99),
+    ...optionalWsfexField(
+      "Pro_precio_uni",
+      serializeWsfexItemDecimal(item.unitPrice, `${field}.unitPrice`)
+    ),
+    ...optionalWsfexField(
+      "Pro_bonificacion",
+      serializeWsfexItemDecimal(item.discount, `${field}.discount`)
+    ),
+    Pro_total_item: serializeWsfexSignedAmount(item.amount, `${field}.amount`)
+  };
+}
+function createWsfexActivity(activity, index) {
+  const field = `activities[${index}].id`;
+  if (typeof activity.id !== "string" || !/^\d{1,6}$/.test(activity.id)) {
+    throw new ArcaInputError(`${field} must be an activity code.`, {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field,
+      expected: "a code of up to 6 digits from getActivities()"
+    });
   }
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonical(item)])
+  return { Id: Number.parseInt(activity.id, 10) };
+}
+function serializeWsfexSignedAmount(value, field) {
+  return typeof value === "number" && value < 0 ? `-${serializeArcaAmount(-value, field)}` : serializeArcaAmount(value, field);
+}
+function serializeWsfexItemDecimal(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const text2 = typeof value === "number" && Number.isFinite(value) ? String(value) : value;
+  const match = typeof text2 === "string" ? WSFEX_ITEM_DECIMAL_PATTERN.exec(text2.trim()) : null;
+  if (!match) {
+    throw new ArcaInputError(
+      `${field} must be a non-negative decimal with at most 12 integer and 6 fractional digits.`,
+      {
+        code: "ARCA_INPUT_INVALID_AMOUNT",
+        field,
+        expected: "a non-negative decimal with up to 12 integer and 6 fractional digits"
+      }
     );
   }
-  return value;
+  return formatWsfexDecimal(match[1] ?? "0", match[2]);
 }
-async function storeCall(fn) {
-  try {
-    return await fn();
-  } catch (cause) {
-    throw new ArcaConfigurationError("ARCA store operation failed.", { cause });
+function formatWsfexDecimal(integerPart, fractionPart = "") {
+  const integer = integerPart.replace(/^0+(?=\d)/, "");
+  const fraction = fractionPart.replace(/0+$/, "");
+  return fraction ? `${integer}.${fraction}` : integer;
+}
+function canonicalizeWsfexDecimal(value) {
+  const match = /^(\d+)(?:\.(\d+))?$/.exec(readWsfexText(value) ?? "");
+  return match ? formatWsfexDecimal(match[1] ?? "0", match[2]) : void 0;
+}
+function optionalWsfexField(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function assertWsfexInteger(value, field, min, max) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= min && value <= max) {
+    return value;
   }
+  return throwWsfexInvalidInput(
+    value,
+    field,
+    `an integer from ${min} to ${max}`
+  );
 }
-
-// src/services/wsfe-identity.ts
-function matchWsfeVoucherIdentity(sent, number, found) {
-  let missing;
-  const compare = (field, expected, actual, normalize) => {
-    if (actual === void 0 || actual === null || expected === void 0) {
-      missing ??= field;
-      return void 0;
+function assertWsfexCode(value, field, allowed) {
+  if (allowed.includes(value)) {
+    return value;
+  }
+  return throwWsfexInvalidInput(value, field, `one of ${allowed.join(", ")}`);
+}
+function assertOptionalWsfexFlag(value, field) {
+  if (value === void 0 || value === "S" || value === "N") {
+    return value;
+  }
+  return throwWsfexInvalidInput(value, field, "S or N");
+}
+function assertOptionalWsfexTaxId(value, field) {
+  if (value === void 0 || typeof value === "string" && WSFEX_TAX_ID_PATTERN.test(value)) {
+    return value;
+  }
+  return throwWsfexInvalidInput(value, field, "an 11-digit CUIT string");
+}
+function requireWsfexText(value, field) {
+  if (typeof value === "string" && value.trim() !== "") {
+    return value;
+  }
+  return throwWsfexInvalidInput(value, field, "a non-empty string");
+}
+function optionalWsfexText(value, field) {
+  if (value === void 0 || typeof value === "string") {
+    return value;
+  }
+  return throwWsfexInvalidInput(value, field, "a string");
+}
+function throwWsfexInvalidInput(value, field, expected) {
+  throw new ArcaInputError(
+    value === void 0 ? `${field} is required.` : `${field} must be ${expected}.`,
+    {
+      code: value === void 0 ? "ARCA_INPUT_MISSING_FIELD" : "ARCA_INPUT_INVALID_VALUE",
+      field,
+      expected
     }
-    try {
-      const left = normalize ? normalize(expected) : expected;
-      const right = normalize ? normalize(actual) : actual;
-      if (left !== right) {
-        return {
-          matches: false,
-          evidence: "conflict",
-          reason: `${field} differs from the sent input`
-        };
-      }
-    } catch {
-      missing ??= field;
+  );
+}
+function normalizeOptionalWsfexDate(value, field) {
+  return value === void 0 ? void 0 : normalizeWsfexDate(value, field);
+}
+function normalizeWsfexDate(value, field) {
+  const text2 = typeof value === "string" ? value.trim() : "";
+  const [, year = "", month = "", day = ""] = /^(\d{4})(\d{2})(\d{2})$/.exec(text2) ?? /^(\d{4})-(\d{2})-(\d{2})$/.exec(text2) ?? [];
+  const candidate = new Date(
+    Date.UTC(Number(year), Number(month) - 1, Number(day))
+  );
+  if (year !== "" && candidate.getUTCFullYear() === Number(year) && candidate.getUTCMonth() === Number(month) - 1 && candidate.getUTCDate() === Number(day)) {
+    return `${year}${month}${day}`;
+  }
+  throw new ArcaInputError(
+    `Invalid WSFEX ${field}: expected an existing YYYYMMDD or YYYY-MM-DD date`,
+    {
+      code: "ARCA_INPUT_INVALID_DATE",
+      field,
+      expected: "an existing YYYYMMDD or YYYY-MM-DD calendar date"
     }
-    return void 0;
+  );
+}
+function createWsfexAuth(representedTaxId, token, sign) {
+  return {
+    Token: token,
+    Sign: sign,
+    Cuit: Number.parseInt(String(representedTaxId), 10)
   };
-  const checks = [
-    ["voucherType", sent.voucherType, found.voucherType],
-    ["salesPoint", sent.salesPoint, found.salesPoint],
-    ["number", number, found.voucherNumber, normalizeVoucherNumber],
-    [
-      "date",
+}
+function unwrapWsfexOperationEnvelope(operation, response) {
+  const operationResponse = response[`${operation}Response`];
+  const result = operationResponse?.[`${operation}Result`] ?? response[`${operation}Result`] ?? response;
+  return result;
+}
+function throwForWsfexOperationError(operation, result) {
+  const errors = extractWsfexErrors(result, operation);
+  if (errors.length > 0) {
+    throw createWsfexServiceError(operation, errors);
+  }
+}
+function createWsfexServiceError(operation, issues) {
+  const authenticationError = classifyArcaAuthenticationIssues(issues, {
+    service: "wsfex",
+    operation
+  });
+  if (authenticationError) {
+    return authenticationError;
+  }
+  const firstIssue = issues[0];
+  return new ArcaServiceError(
+    firstIssue ? formatWsfexIssue(firstIssue) : "WSFEX returned a service error",
+    {
+      service: "wsfex",
+      operation,
+      ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
+      issues
+    }
+  );
+}
+function formatWsfexIssue(issue) {
+  return issue.code ? `(${issue.code}) ${issue.message}` : issue.message;
+}
+function extractWsfexErrors(result, operation, resultLevel) {
+  const error = toWsfexRecord(result.FEXErr);
+  const code = readWsfexText(error?.ErrCode);
+  if (code === void 0 || /^0+$/.test(code)) {
+    return [];
+  }
+  return [
+    {
+      service: "wsfex",
+      operation,
+      source: "error",
+      category: getWsfexErrorCategory(operation, code),
+      code,
+      message: readWsfexText(error?.ErrMsg) ?? readWsfexText(error?.Errmsg) ?? "Unknown WSFEX error",
+      ...resultLevel === void 0 ? {} : { resultLevel }
+    }
+  ];
+}
+function getWsfexErrorCategory(operation, code) {
+  if (operation !== "FEXAuthorize") {
+    return "unknown";
+  }
+  return WSFEX_AUTHORIZATION_INFRASTRUCTURE_CODES.has(code) ? "infrastructure" : "business";
+}
+var WSFEX_AUTHORIZATION_INFRASTRUCTURE_CODES = /* @__PURE__ */ new Set([
+  "500",
+  "501",
+  "502",
+  "505",
+  "1000",
+  "1001"
+]);
+function extractWsfexReasons(value, operation, category) {
+  const text2 = readWsfexText(value);
+  if (text2 === void 0) {
+    return [];
+  }
+  const base = {
+    service: "wsfex",
+    operation,
+    source: "observation",
+    category,
+    resultLevel: "header"
+  };
+  if (!/^\d+(?:\s*[,;|\s]\s*\d+)*$/.test(text2)) {
+    return [{ ...base, message: text2 }];
+  }
+  return text2.split(/\D+/).filter(Boolean).map((token) => {
+    const code = String(Number.parseInt(token, 10));
+    return { ...base, code, message: code };
+  });
+}
+function classifyWsfexAuthorization(result) {
+  const operation = "FEXAuthorize";
+  const authorization = toWsfexRecord(result.FEXResultAuth);
+  const resultCode = normalizeWsfexResult(authorization?.Resultado);
+  const echo = readWsfexEcho(authorization);
+  const reprocessed = readWsfexReprocessed(authorization?.Reproceso);
+  const base = {
+    service: "wsfex",
+    operation,
+    results: resultCode === void 0 ? {} : { header: resultCode },
+    errors: extractWsfexErrors(result, operation, "header"),
+    observations: extractWsfexReasons(
+      authorization?.Motivos_Obs,
+      operation,
+      resultCode === "R" ? "business" : "observation"
+    ),
+    raw: result
+  };
+  assignWsfexValue(base, "reprocessed", reprocessed);
+  assignWsfexValue(base, "echo", echo);
+  const context = {
+    base,
+    resultCode,
+    cae: readWsfexText(authorization?.Cae),
+    caeExpiry: readWsfexText(authorization?.Fch_venc_Cae),
+    voucherNumber: echo?.number
+  };
+  return base.errors.length > 0 ? classifyWsfexErrorAnswer(context) : classifyWsfexResultAnswer(context);
+}
+function classifyWsfexErrorAnswer(context) {
+  if (context.cae || context.resultCode === "A") {
+    return createWsfexStructuredIndeterminate(
+      context,
+      "contradictory_response"
+    );
+  }
+  const authenticationError = classifyArcaAuthenticationIssues(
+    context.base.errors,
+    { service: "wsfex", operation: context.base.operation }
+  );
+  if (authenticationError) {
+    return {
+      ...createWsfexStructuredIndeterminate(context, "authentication_rejected"),
+      authentication: createArcaAuthenticationEvidence(authenticationError)
+    };
+  }
+  if (context.base.errors.some((issue) => issue.category === "infrastructure")) {
+    return createWsfexStructuredIndeterminate(context, "incomplete_response");
+  }
+  return {
+    ...context.base,
+    kind: "rejected",
+    result: "R",
+    resultLevel: "header"
+  };
+}
+function classifyWsfexResultAnswer(context) {
+  const { cae, caeExpiry, voucherNumber } = context;
+  if (context.resultCode === "A") {
+    return cae && caeExpiry && voucherNumber !== void 0 ? {
+      ...context.base,
+      kind: "authorized",
+      result: "A",
+      resultLevel: "header",
+      cae,
+      caeExpiry,
+      voucherNumber
+    } : createWsfexStructuredIndeterminate(context, "incomplete_response");
+  }
+  if (context.resultCode === "R") {
+    return cae ? createWsfexStructuredIndeterminate(context, "contradictory_response") : {
+      ...context.base,
+      kind: "rejected",
+      result: "R",
+      resultLevel: "header"
+    };
+  }
+  return createWsfexStructuredIndeterminate(context, "incomplete_response");
+}
+function createWsfexStructuredIndeterminate(context, reason) {
+  const outcome = {
+    ...context.base,
+    kind: "indeterminate",
+    reason
+  };
+  assignWsfexValue(outcome, "result", context.resultCode);
+  if (context.resultCode !== void 0) {
+    outcome.resultLevel = "header";
+  }
+  assignWsfexValue(outcome, "cae", context.cae);
+  assignWsfexValue(outcome, "caeExpiry", context.caeExpiry);
+  return outcome;
+}
+function createWsfexIndeterminateOutcome(error) {
+  const operation = "FEXAuthorize";
+  const authenticationError = classifyArcaAuthenticationError(error, {
+    service: "wsfex",
+    operation
+  });
+  return {
+    kind: "indeterminate",
+    service: "wsfex",
+    operation,
+    results: {},
+    reason: authenticationError ? "authentication_rejected" : getWsfexIndeterminateReason(error),
+    ...authenticationError ? {
+      authentication: createArcaAuthenticationEvidence(authenticationError)
+    } : {},
+    errors: [],
+    observations: []
+  };
+}
+function getWsfexIndeterminateReason(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 readWsfexEcho(authorization) {
+  if (!authorization) {
+    return void 0;
+  }
+  const echo = {};
+  assignWsfexValue(
+    echo,
+    "id",
+    readWsfexInteger(authorization.Id, 0, WSFEX_MAX_REQUEST_ID)
+  );
+  assignWsfexValue(
+    echo,
+    "salesPoint",
+    readWsfexInteger(authorization.Punto_vta, 1, 99999)
+  );
+  assignWsfexValue(
+    echo,
+    "voucherType",
+    readWsfexInteger(authorization.Cbte_tipo ?? authorization.Cbte_Tipo, 1, 999)
+  );
+  assignWsfexValue(
+    echo,
+    "number",
+    readWsfexInteger(authorization.Cbte_nro, 1, 99999999)
+  );
+  assignWsfexValue(echo, "date", readWsfexText(authorization.Fch_cbte));
+  return Object.keys(echo).length > 0 ? echo : void 0;
+}
+function readWsfexReprocessed(value) {
+  const flag = normalizeWsfexResult(value);
+  return flag === "S" || flag === "N" ? flag === "S" : void 0;
+}
+function mapWsfexVoucherInfo(raw) {
+  const operation = "FEXGetCMP";
+  const voucher = {
+    voucherType: parseWsfexInteger(raw.Cbte_tipo ?? raw.Cbte_Tipo, {
+      operation,
+      field: "Cbte_tipo",
+      min: 1,
+      max: 999
+    }),
+    salesPoint: parseWsfexInteger(raw.Punto_vta, {
+      operation,
+      field: "Punto_vta",
+      min: 1,
+      max: 99999
+    }),
+    number: parseWsfexInteger(raw.Cbte_nro, {
+      operation,
+      field: "Cbte_nro",
+      min: 1,
+      max: 99999999
+    }),
+    destination: parseWsfexNumber(raw.Dst_cmp, operation, "Dst_cmp"),
+    receiverName: readWsfexText(raw.Cliente) ?? "",
+    receiverAddress: readWsfexText(raw.Domicilio_cliente) ?? "",
+    currencyId: readWsfexText(raw.Moneda_Id) ?? "",
+    totalAmount: parseWsfexNumber(raw.Imp_total, operation, "Imp_total"),
+    items: getWsfexRows(raw.Items, "Item").map(mapWsfexLookupItem)
+  };
+  assignWsfexValue(
+    voucher,
+    "id",
+    readWsfexInteger(raw.Id, 0, WSFEX_MAX_REQUEST_ID)
+  );
+  assignWsfexValue(voucher, "voucherDate", readWsfexText(raw.Fecha_cbte));
+  assignWsfexValue(voucher, "exportType", readWsfexNumber(raw.Tipo_expo));
+  assignWsfexValue(
+    voucher,
+    "permitExists",
+    readWsfexFlag(raw.Permiso_existente)
+  );
+  assignWsfexValue(
+    voucher,
+    "permits",
+    mapWsfexLookupList(raw.Permisos, "Permiso", mapWsfexLookupPermit)
+  );
+  assignWsfexValue(
+    voucher,
+    "receiverCountryTaxId",
+    readWsfexTaxId(raw.Cuit_pais_cliente)
+  );
+  assignWsfexValue(voucher, "receiverTaxId", readWsfexText(raw.Id_impositivo));
+  assignWsfexValue(
+    voucher,
+    "exchangeRate",
+    canonicalizeWsfexDecimal(raw.Moneda_ctz)
+  );
+  assignWsfexValue(
+    voucher,
+    "sameCurrencyForeignCancellation",
+    readWsfexFlag(raw.CanMisMonExt)
+  );
+  assignWsfexValue(
+    voucher,
+    "commercialObservations",
+    readWsfexText(raw.Obs_comerciales)
+  );
+  assignWsfexValue(voucher, "observations", readWsfexText(raw.Obs));
+  assignWsfexValue(
+    voucher,
+    "associatedVouchers",
+    mapWsfexLookupList(
+      raw.Cmps_asoc,
+      "Cmp_asoc",
+      mapWsfexLookupAssociatedVoucher
+    )
+  );
+  assignWsfexValue(voucher, "paymentTerms", readWsfexText(raw.Forma_pago));
+  assignWsfexValue(voucher, "incoterms", readWsfexText(raw.Incoterms));
+  assignWsfexValue(voucher, "incotermsDetail", readWsfexText(raw.Incoterms_Ds));
+  assignWsfexValue(voucher, "language", readWsfexNumber(raw.Idioma_cbte));
+  assignWsfexValue(voucher, "paymentDate", readWsfexText(raw.Fecha_pago));
+  assignWsfexValue(
+    voucher,
+    "activities",
+    mapWsfexLookupList(raw.Actividades, "Actividad", (row) => {
+      const id = toWsfexActivityId(row.Id);
+      return id === void 0 ? void 0 : { id };
+    })
+  );
+  assignWsfexValue(voucher, "result", normalizeWsfexResult(raw.Resultado));
+  assignWsfexValue(voucher, "cae", readWsfexText(raw.Cae));
+  assignWsfexValue(voucher, "caeExpiry", readWsfexText(raw.Fch_venc_Cae));
+  assignWsfexValue(voucher, "authorizedAt", readWsfexText(raw.Fecha_cbte_cae));
+  return voucher;
+}
+function mapWsfexLookupItem(row) {
+  const operation = "FEXGetCMP";
+  const code = readWsfexText(row.Pro_codigo);
+  const quantity = canonicalizeWsfexDecimal(row.Pro_qty);
+  const unitPrice = canonicalizeWsfexDecimal(row.Pro_precio_uni);
+  const discount = canonicalizeWsfexDecimal(row.Pro_bonificacion);
+  return {
+    ...code === void 0 ? {} : { code },
+    description: readWsfexText(row.Pro_ds) ?? "",
+    ...quantity === void 0 ? {} : { quantity },
+    unit: parseWsfexNumber(row.Pro_umed, operation, "Pro_umed"),
+    ...unitPrice === void 0 ? {} : { unitPrice },
+    ...discount === void 0 ? {} : { discount },
+    amount: parseWsfexNumber(row.Pro_total_item, operation, "Pro_total_item")
+  };
+}
+function mapWsfexLookupPermit(row) {
+  const id = readWsfexText(row.Id_permiso);
+  const destination = readWsfexNumber(row.Dst_merc);
+  return id === void 0 || destination === void 0 ? void 0 : { id, destination };
+}
+function mapWsfexLookupAssociatedVoucher(row) {
+  const voucherType = readWsfexNumber(row.Cbte_tipo ?? row.Cbte_Tipo);
+  const salesPoint = readWsfexNumber(row.Cbte_punto_vta);
+  const number = readWsfexNumber(row.Cbte_nro);
+  if (voucherType === void 0 || salesPoint === void 0 || number === void 0) {
+    return void 0;
+  }
+  const issuerTaxId2 = readWsfexTaxId(row.Cbte_cuit);
+  return {
+    voucherType,
+    salesPoint,
+    number,
+    ...issuerTaxId2 === void 0 ? {} : { issuerTaxId: issuerTaxId2 }
+  };
+}
+function mapWsfexLookupList(container, key, map) {
+  const rows2 = getWsfexRows(container, key);
+  if (rows2.length === 0) {
+    return void 0;
+  }
+  const result = [];
+  for (const row of rows2) {
+    const mapped = map(row);
+    if (mapped === void 0) {
+      return void 0;
+    }
+    result.push(mapped);
+  }
+  return result;
+}
+function mapWsfexSalesPoint(row) {
+  const deactivatedAt = toIsoDate(readWsfexText(row.Pve_FchBaja));
+  return {
+    number: parseWsfexInteger(row.Pve_Nro, {
+      operation: "FEXGetPARAM_PtoVenta",
+      field: "Pve_Nro",
+      min: 1,
+      max: 99999
+    }),
+    blocked: normalizeWsfexResult(row.Pve_Bloqueado) === "S",
+    ...deactivatedAt === void 0 ? {} : { deactivatedAt }
+  };
+}
+function toWsfexActivityId(value) {
+  const text2 = readWsfexText(value);
+  return text2 !== void 0 && /^\d+$/.test(text2) && Number(text2) !== 0 ? text2.padStart(6, "0") : void 0;
+}
+function readWsfexTaxId(value) {
+  const text2 = readWsfexText(value);
+  return text2 !== void 0 && /^\d+$/.test(text2) && Number(text2) !== 0 ? text2 : void 0;
+}
+function readWsfexFlag(value) {
+  const flag = normalizeWsfexResult(value);
+  return flag === "S" || flag === "N" ? flag : void 0;
+}
+function getWsfexRows(container, key) {
+  const value = toWsfexRecord(container)?.[key];
+  if (value === void 0) {
+    return [];
+  }
+  return (Array.isArray(value) ? value : [value]).flatMap((row) => {
+    const record = toWsfexRecord(row);
+    return record ? [record] : [];
+  });
+}
+function toWsfexRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  return Object.keys(record).some((key) => !key.startsWith("@_")) ? record : void 0;
+}
+function readWsfexText(value) {
+  if (typeof value !== "string" && typeof value !== "number") {
+    return void 0;
+  }
+  const text2 = String(value).trim();
+  return text2 || void 0;
+}
+function readWsfexNumber(value) {
+  const text2 = readWsfexText(value);
+  return text2 !== void 0 && /^-?\d+(?:\.\d+)?$/.test(text2) ? Number(text2) : void 0;
+}
+function readWsfexInteger(value, min, max) {
+  const text2 = readWsfexText(value);
+  if (text2 === void 0 || !/^\d+$/.test(text2)) {
+    return void 0;
+  }
+  const parsed = Number(text2);
+  return Number.isSafeInteger(parsed) && parsed >= min && parsed <= max ? parsed : void 0;
+}
+function parseWsfexInteger(value, options) {
+  const parsed = readWsfexInteger(value, options.min, options.max);
+  if (parsed === void 0) {
+    throw new ArcaInvalidSoapResponseError(`Invalid WSFEX ${options.field}`, {
+      service: "wsfex",
+      operation: options.operation
+    });
+  }
+  return parsed;
+}
+function parseWsfexNumber(value, operation, field) {
+  const parsed = readWsfexNumber(value);
+  if (parsed === void 0) {
+    throw new ArcaInvalidSoapResponseError(`Invalid WSFEX ${field}`, {
+      service: "wsfex",
+      operation
+    });
+  }
+  return parsed;
+}
+function normalizeWsfexResult(value) {
+  return readWsfexText(value)?.toUpperCase();
+}
+function assignWsfexValue(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+
+// src/store/types.ts
+import { createHash } from "crypto";
+function attemptKey(environment, taxId, key) {
+  return `arca:v1:attempt:${environment}:${taxId}:${key}`;
+}
+function sequenceKey(environment, taxId, salesPoint, voucherType) {
+  return `arca:v1:sequence:${environment}:${taxId}:${salesPoint}:${voucherType}`;
+}
+function sequenceLockKey(environment, taxId, salesPoint, voucherType) {
+  return `arca:v1:lock:sequence:${environment}:${taxId}:${salesPoint}:${voucherType}`;
+}
+function settledKey(environment, taxId, key) {
+  return `arca:v1:settled:${environment}:${taxId}:${key}`;
+}
+function canonicalHash(input) {
+  return createHash("sha256").update(JSON.stringify(canonical(input))).digest("hex");
+}
+function canonical(value) {
+  if (Array.isArray(value)) {
+    return value.map(canonical);
+  }
+  if (value instanceof Date) {
+    return value.toJSON();
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonical(item)])
+    );
+  }
+  return value;
+}
+async function storeCall(fn) {
+  try {
+    return await fn();
+  } catch (cause) {
+    throw new ArcaConfigurationError("ARCA store operation failed.", { cause });
+  }
+}
+
+// src/services/wsfe-identity.ts
+function matchWsfeVoucherIdentity(sent, number, found) {
+  let missing;
+  const compare = (field, expected, actual, normalize) => {
+    if (actual === void 0 || actual === null || expected === void 0) {
+      missing ??= field;
+      return void 0;
+    }
+    try {
+      const left = normalize ? normalize(expected) : expected;
+      const right = normalize ? normalize(actual) : actual;
+      if (left !== right) {
+        return {
+          matches: false,
+          evidence: "conflict",
+          reason: `${field} differs from the sent input`
+        };
+      }
+    } catch {
+      missing ??= field;
+    }
+    return void 0;
+  };
+  const checks = [
+    ["voucherType", sent.voucherType, found.voucherType],
+    ["salesPoint", sent.salesPoint, found.salesPoint],
+    ["number", number, found.voucherNumber, normalizeVoucherNumber],
+    [
+      "date",
       sent.voucherDate,
       found.voucherDate,
       (value) => normalizeWsfeDateInput(value, "date")
@@ -1719,11 +2830,11 @@ function normalizeVoucherNumber(value) {
   return value;
 }
 function normalizeDocument(value) {
-  const text = String(value);
-  if (!/^\d+$/.test(text)) {
+  const text2 = String(value);
+  if (!/^\d+$/.test(text2)) {
     throw new Error("Invalid document number");
   }
-  return BigInt(text);
+  return BigInt(text2);
 }
 function compareVatRates(expected, actual) {
   if (actual === void 0) {
@@ -2145,19 +3256,19 @@ async function postXmlOnce({
     });
   }
   return await new Promise((resolve, reject) => {
-    let settled = false;
+    let settled2 = false;
     const settleResolve = (response) => {
-      if (settled) {
+      if (settled2) {
         return;
       }
-      settled = true;
+      settled2 = true;
       resolve(response);
     };
     const settleReject = (error) => {
-      if (settled) {
+      if (settled2) {
         return;
       }
-      settled = true;
+      settled2 = true;
       reject(error);
     };
     const request = https.request(
@@ -2805,25 +3916,1343 @@ function createArcaLogger(config) {
     }
   };
 }
-function resolveArcaLogLevel(level) {
-  if (isArcaLogLevel(level)) {
-    return level;
+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/store/lock.ts
+import { randomUUID } from "crypto";
+var ARCA_LEASE_MS = 6e4;
+var RENEW_MS = 2e4;
+var POLL_MS = 50;
+var MAX_WAIT_MS = 2 * ARCA_LEASE_MS;
+async function withLease(driver, fn, { signal } = {}) {
+  const owner = randomUUID();
+  const deadline = Date.now() + MAX_WAIT_MS;
+  throwIfAborted(signal);
+  let held = await driver.acquire(owner);
+  while (!held) {
+    if (Date.now() >= deadline) {
+      throw new ArcaLockTimeoutError(
+        "ARCA store lock stayed held; no work was attempted.",
+        { reason: "held" }
+      );
+    }
+    await delay2(POLL_MS + Math.floor(Math.random() * POLL_MS), signal);
+    throwIfAborted(signal);
+    held = await driver.acquire(owner);
+  }
+  if (signal?.aborted) {
+    await driver.release(owner).catch(() => void 0);
+    throwIfAborted(signal);
+  }
+  const renewal = setInterval(() => {
+    driver.renew(owner).catch(() => void 0);
+  }, RENEW_MS);
+  renewal.unref?.();
+  try {
+    return await fn();
+  } finally {
+    clearInterval(renewal);
+    await driver.release(owner).catch(() => void 0);
+  }
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw new ArcaLockTimeoutError(
+      "Stopped waiting for an ARCA store lock: the caller's signal aborted; no work was attempted.",
+      { reason: "aborted", cause: signal.reason }
+    );
+  }
+}
+function delay2(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const wake = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", wake);
+      resolve();
+    }, ms);
+    timer.unref?.();
+    signal?.addEventListener("abort", wake, { once: true });
+  });
+}
+
+// src/services/issuance-wsfex.ts
+var LANGUAGES = { es: 1, en: 2, pt: 3 };
+var EXPORT_KINDS = { goods: 1, services: 2, other: 4 };
+var UNPRICED_UNITS = [0, 97, 99];
+function isExportVoucherType(voucherType) {
+  return typeof voucherType === "number" && EXPORT_TYPES.includes(voucherType);
+}
+function isExportInput(input) {
+  return input !== null && typeof input === "object" && "export" in input;
+}
+function isExportNoteInput(input) {
+  if (input === null || typeof input !== "object" || !("for" in input)) {
+    return false;
+  }
+  const target = input.for;
+  return target !== null && typeof target === "object" && !Array.isArray(target) && isExportVoucherType(target.voucherType);
+}
+function deriveExportInvoice(input, now = /* @__PURE__ */ new Date()) {
+  assertIssueObject(input, "input");
+  assertIssueKeys(
+    input,
+    [
+      "salesPoint",
+      "to",
+      "export",
+      "items",
+      "total",
+      "date",
+      "currency",
+      "exchangeRate",
+      "paidInForeignCurrency",
+      "paymentTerms",
+      "language",
+      "observations",
+      "commercialObservations"
+    ],
+    "input"
+  );
+  assertSalesPoint2(input.salesPoint, "salesPoint");
+  const receiver = deriveReceiver2(input.to);
+  const exported = deriveExport(input.export);
+  const voucherDate = normalizeWsfeDateInput(
+    input.date ?? buenosAiresDate(now),
+    "date"
+  );
+  if (exported.paymentDate !== void 0 && exported.paymentDate < voucherDate) {
+    invalid3("export.paymentDate", "on or after the voucher date");
+  }
+  const currency = deriveCurrency2(input.currency, input.exchangeRate);
+  if (input.paidInForeignCurrency !== void 0) {
+    if (typeof input.paidInForeignCurrency !== "boolean") {
+      invalid3("paidInForeignCurrency", "a boolean");
+    }
+    if (currency.currencyId === ARCA_CURRENCY_IDS.ARS) {
+      invalid3("paidInForeignCurrency", "absent for an invoice in pesos");
+    }
+  }
+  const { items, total } = deriveItems(input.items, "items");
+  const reviewed = reviewedTotal(input.total, total);
+  const data = {
+    voucherType: ARCA_VOUCHER_TYPES.FACTURA_E,
+    salesPoint: input.salesPoint,
+    voucherDate,
+    exportType: exported.exportType,
+    ...exported.permitExists === void 0 ? {} : { permitExists: exported.permitExists },
+    ...exported.permits === void 0 ? {} : { permits: exported.permits },
+    ...receiver,
+    ...currency,
+    ...input.paidInForeignCurrency === void 0 ? {} : {
+      sameCurrencyForeignCancellation: input.paidInForeignCurrency ? "S" : "N"
+    },
+    ...optionalText(
+      input.commercialObservations,
+      "commercialObservations",
+      4e3
+    ),
+    totalAmount: reviewed / 100,
+    ...optionalText(input.observations, "observations", 1e3),
+    paymentTerms: text(input.paymentTerms, "paymentTerms", 50),
+    ...exported.incoterms === void 0 ? {} : { incoterms: exported.incoterms },
+    ...exported.incotermsDetail === void 0 ? {} : { incotermsDetail: exported.incotermsDetail },
+    language: deriveLanguage(input.language),
+    items,
+    ...exported.paymentDate === void 0 ? {} : { paymentDate: exported.paymentDate }
+  };
+  assertWsfexVoucherInput(data);
+  return {
+    data,
+    amounts: { computedTotal: total, sentTotal: reviewed, vatAdjustment: 0 }
+  };
+}
+function deriveExportNote(original, input, kind, now = /* @__PURE__ */ new Date()) {
+  assertIssueKeys(
+    input,
+    [
+      "for",
+      "salesPoint",
+      "date",
+      "exchangeRate",
+      "observations",
+      "commercialObservations",
+      "items",
+      ...kind === "creditNote" ? ["all"] : []
+    ],
+    "input",
+    kind === "creditNote" ? "issueCreditNote()" : "issueDebitNote()"
+  );
+  const exportType = noteExportType(original, kind);
+  const salesPoint = input.salesPoint ?? original.salesPoint;
+  assertSalesPoint2(salesPoint, "salesPoint");
+  const voucherDate = normalizeWsfeDateInput(
+    input.date ?? buenosAiresDate(now),
+    "date"
+  );
+  if (exportType === 2 && original.voucherDate !== void 0 && voucherDate < original.voucherDate) {
+    invalid3("date", "on or after the original's date for services");
+  }
+  const exchangeRate2 = noteRate(original, input.exchangeRate, exportType);
+  const lines = noteLines(original, input);
+  const data = {
+    voucherType: kind === "creditNote" ? ARCA_VOUCHER_TYPES.NOTA_CREDITO_E : ARCA_VOUCHER_TYPES.NOTA_DEBITO_E,
+    salesPoint,
+    voucherDate,
+    exportType,
+    ...inheritedReceiver(original),
+    currencyId: original.currencyId,
+    ...exchangeRate2 === void 0 ? {} : { exchangeRate: exchangeRate2 },
+    ...optionalText(
+      input.commercialObservations,
+      "commercialObservations",
+      4e3
+    ),
+    totalAmount: lines.total / 100,
+    ...optionalText(input.observations, "observations", 1e3),
+    associatedVouchers: [
+      {
+        voucherType: original.voucherType,
+        salesPoint: original.salesPoint,
+        number: original.number
+      }
+    ],
+    ...original.incoterms === void 0 ? {} : { incoterms: original.incoterms },
+    language: original.language === 2 || original.language === 3 ? original.language : 1,
+    items: lines.items
+  };
+  assertWsfexVoucherInput(data);
+  return {
+    data,
+    amounts: {
+      computedTotal: lines.total,
+      sentTotal: lines.total,
+      vatAdjustment: 0
+    }
+  };
+}
+function noteExportType(original, kind) {
+  if (original.result !== void 0 && original.result !== "A") {
+    invalid3("for", "an authorized voucher");
+  }
+  const allowed = kind === "creditNote" ? [ARCA_VOUCHER_TYPES.FACTURA_E, ARCA_VOUCHER_TYPES.NOTA_DEBITO_E] : [ARCA_VOUCHER_TYPES.FACTURA_E];
+  if (!allowed.includes(original.voucherType)) {
+    invalid3(
+      "for.voucherType",
+      kind === "creditNote" ? "19 or 20" : "19, a Factura E"
+    );
+  }
+  const exportType = original.exportType;
+  if (exportType !== 1 && exportType !== 2 && exportType !== 4) {
+    throw new ArcaConfigurationError(
+      "The original voucher reports no export type."
+    );
+  }
+  return exportType;
+}
+function noteRate(original, rate, exportType) {
+  if (rate === void 0) {
+    return original.exchangeRate;
+  }
+  if (exportType === 2) {
+    invalid3("exchangeRate", "absent: services notes keep the original's");
+  }
+  return deriveCurrency2(
+    original.currencyId === ARCA_CURRENCY_IDS.ARS ? "ARS" : { id: original.currencyId },
+    rate
+  ).exchangeRate;
+}
+function noteLines(original, input) {
+  const all = "all" in input ? input.all : void 0;
+  if (input.items === void 0 === (all === void 0)) {
+    throw new ArcaInputError(
+      "issueCreditNote needs exactly one mode: items for a partial note, or all: true for the whole original.",
+      {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field: input.items === void 0 ? "items" : "all",
+        expected: "exactly one of items or all: true"
+      }
+    );
+  }
+  if (all === void 0) {
+    return deriveItems(input.items, "items");
+  }
+  if (all !== true) {
+    invalid3("all", "true");
+  }
+  if (original.items.length === 0) {
+    throw new ArcaInputError(
+      "ARCA reports no lines for the original, so all: true has nothing to credit; list the items instead.",
+      {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field: "all",
+        expected: "items, since the original reports no lines"
+      }
+    );
+  }
+  return { items: original.items, total: originalTotal(original) };
+}
+function inheritedReceiver(original) {
+  return {
+    destination: original.destination,
+    receiverName: original.receiverName,
+    ...original.receiverCountryTaxId === void 0 ? {} : { receiverCountryTaxId: original.receiverCountryTaxId },
+    receiverAddress: original.receiverAddress,
+    ...original.receiverTaxId === void 0 ? {} : { receiverTaxId: original.receiverTaxId }
+  };
+}
+function assertExportWindow(data, now = /* @__PURE__ */ new Date()) {
+  assertExportDateWindow(
+    data.voucherDate ?? buenosAiresDate(now),
+    data.exportType === 2,
+    buenosAiresDate(now)
+  );
+}
+function exportPreview(prepared, originals) {
+  return {
+    voucherClass: "E",
+    voucherType: prepared.data.voucherType,
+    date: isoDate(prepared.data.voucherDate),
+    header: exportHeader(prepared.data),
+    amounts: { ...prepared.amounts },
+    request: structuredClone(prepared.data),
+    service: "wsfex",
+    ...originals === void 0 ? {} : { originals }
+  };
+}
+function createExportIssuance(wsfex, context) {
+  return {
+    issue: (prepare, operation, hashInput, options) => issueExport(wsfex, context, prepare, operation, hashInput, options),
+    async original(coordinates, options) {
+      const result = await wsfex.lookupVoucher({
+        ...auth(options),
+        ...coordinates
+      });
+      return result.kind === "found" ? result.voucher : null;
+    },
+    async lookup(coordinates, options) {
+      const result = await wsfex.lookupVoucher({
+        ...auth(options),
+        ...coordinates
+      });
+      return result.kind === "found" ? exportSummary(result.voucher) : null;
+    },
+    lastAuthorized: (sequence, options) => wsfex.getLastVoucherNumber({ ...auth(options), ...sequence }),
+    recover: (key, json, options) => recoverExport(wsfex, context, key, json, options)
+  };
+}
+async function recoverExport(wsfex, context, key, json, options) {
+  const first = readExportRecord(json);
+  const issuer = first.representedTaxId ?? context.taxId;
+  if (options.representedTaxId !== void 0 && String(options.representedTaxId) !== issuer) {
+    throw new ArcaInputError(
+      "Reservation belongs to another represented taxpayer",
+      { code: "ARCA_INPUT_IDEMPOTENCY_MISMATCH" }
+    );
+  }
+  const consulted = {
+    ...options,
+    ...first.representedTaxId === void 0 ? {} : { representedTaxId: first.representedTaxId }
+  };
+  return await exportLock(
+    context,
+    issuer,
+    options
+  )(async () => {
+    const store = context.store;
+    const latest = store ? await storeCall(
+      () => store.get(attemptKey(context.environment, context.taxId, key))
+    ) : null;
+    const record = latest === null ? first : readExportRecord(latest);
+    const outcome = await consultReservation(wsfex, record, consulted, issuer);
+    return {
+      ...outcome,
+      service: "wsfex",
+      ...options.include?.request ? {
+        request: {
+          ...structuredClone(record.sent),
+          id: record.requestId,
+          number: record.number
+        }
+      } : {}
+    };
+  });
+}
+async function consultReservation(wsfex, record, options, issuer) {
+  const attempted = {
+    salesPoint: record.salesPoint,
+    voucherType: record.voucherType,
+    number: record.number
+  };
+  const attempt = {
+    service: "wsfex",
+    operation: "FEXAuthorize",
+    kind: "indeterminate",
+    reason: "incomplete_response",
+    results: {},
+    errors: [],
+    observations: []
+  };
+  const total = Math.round(record.sent.totalAmount * 100);
+  const amounts = { computedTotal: total, sentTotal: total, vatAdjustment: 0 };
+  let found;
+  try {
+    const result = await wsfex.lookupVoucher({
+      ...auth(options),
+      ...attempted
+    });
+    found = result.kind === "found" ? result.voucher : null;
+  } catch (error) {
+    return {
+      kind: "indeterminate",
+      attempted,
+      attempt,
+      lookup: options.abortSignal?.aborted ? { kind: "aborted" } : { kind: "failed", error: toArcaSafeErrorMetadata(error) }
+    };
+  }
+  return settled(
+    attempt,
+    attempt,
+    found,
+    record.requestId,
+    attempted,
+    record.sent,
+    (authorization) => issuedVoucher(
+      record.sent,
+      attempted,
+      record.requestId,
+      authorization,
+      amounts,
+      issuer
+    )
+  );
+}
+function exportLock(context, issuer, options) {
+  const key = `arca:v1:lock:wsfex:${context.environment}:${issuer}`;
+  return (fn) => context.store?.withLock ? context.store.withLock(key, fn, { signal: options.abortSignal }) : withLocalLock(key, fn, options.abortSignal);
+}
+function auth(options) {
+  return {
+    ...options.representedTaxId === void 0 ? {} : { representedTaxId: options.representedTaxId },
+    ...options.forceRefresh === void 0 ? {} : { forceRefresh: options.forceRefresh },
+    ...options.abortSignal === void 0 ? {} : { abortSignal: options.abortSignal }
+  };
+}
+async function issueExport(wsfex, context, prepare, operation, hashInput, options) {
+  if (options.service !== void 0) {
+    invalid3("options.service", "absent: export vouchers always use WSFEX");
+  }
+  if (options.number !== void 0) {
+    invalid3("options.number", "absent: WSFEX numbers are read under a lock");
+  }
+  const representedTaxId = options.representedTaxId === void 0 ? void 0 : String(options.representedTaxId);
+  const issuer = representedTaxId ?? context.taxId;
+  const lock = exportLock(context, issuer, options);
+  const idempotencyKey = options.idempotencyKey;
+  if (idempotencyKey === void 0 || !context.store) {
+    const prepared2 = await prepare();
+    assertExportWindow(prepared2.data);
+    return lock(() => fresh(prepared2));
+  }
+  const store = context.store;
+  const recordKey = attemptKey(
+    context.environment,
+    context.taxId,
+    idempotencyKey
+  );
+  const inputHash = canonicalHash({
+    input: hashInput,
+    representedTaxId,
+    service: "wsfex"
+  });
+  const existing = await storeCall(() => store.get(recordKey));
+  if (existing !== null) {
+    return lock(
+      async () => replay(await storeCall(() => store.get(recordKey)) ?? existing)
+    );
+  }
+  const prepared = await prepare();
+  assertExportWindow(prepared.data);
+  return lock(async () => {
+    const prior = await storeCall(() => store.get(recordKey));
+    return prior === null ? fresh(prepared) : replay(prior);
+  });
+  async function fresh(prepared2) {
+    const { data } = prepared2;
+    const number = await wsfex.getLastVoucherNumber({
+      ...auth(options),
+      salesPoint: data.salesPoint,
+      voucherType: data.voucherType
+    }) + 1;
+    const id = await nextRequestId();
+    if (idempotencyKey === void 0 || !context.store) {
+      return submit({ id, number, data, fresh: true });
+    }
+    const record = {
+      v: 2,
+      operation,
+      service: "wsfex",
+      ...representedTaxId === void 0 ? {} : { representedTaxId },
+      salesPoint: data.salesPoint,
+      voucherType: data.voucherType,
+      number,
+      requestId: id,
+      inputHash,
+      sent: data,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const store2 = context.store;
+    if (await storeCall(() => store2.add(recordKey, JSON.stringify(record)))) {
+      return submit({ id, number, data, fresh: true, record });
+    }
+    const winner = await storeCall(() => store2.get(recordKey));
+    if (winner === null) {
+      throw new ArcaConfigurationError(
+        "ARCA reservation disappeared after atomic creation lost."
+      );
+    }
+    return replay(winner);
+  }
+  function replay(json) {
+    const stored = readExportRecord(json);
+    if (stored.operation !== operation || stored.inputHash !== inputHash || stored.representedTaxId !== representedTaxId) {
+      throw new ArcaInputError(
+        "The idempotency key was already used with different input or operation.",
+        {
+          code: "ARCA_INPUT_IDEMPOTENCY_MISMATCH",
+          field: "options.idempotencyKey"
+        }
+      );
+    }
+    return submit({
+      id: stored.requestId,
+      number: stored.number,
+      data: stored.sent,
+      fresh: false,
+      record: stored
+    });
+  }
+  async function submit(claim) {
+    const first = await attemptOnce(claim, claim.id, claim.fresh);
+    if (first !== "collided") {
+      return first;
+    }
+    const id = await nextRequestId();
+    await moveRecord(claim.record, id);
+    const second = await attemptOnce(claim, id, true);
+    if (second === "collided") {
+      throw new ArcaConfigurationError("WSFEX answered a reused id twice.");
+    }
+    return second;
+  }
+  async function attemptOnce(claim, id, mayCollide) {
+    const { number, data } = claim;
+    const attempted = {
+      salesPoint: data.salesPoint,
+      voucherType: data.voucherType,
+      number
+    };
+    const finish = (outcome2) => ({
+      ...outcome2,
+      service: "wsfex",
+      ...options.include?.request ? { request: { ...structuredClone(data), id, number } } : {}
+    });
+    const outcome = await send(data, id, number);
+    const attempt = evidence(outcome);
+    const direct = answered(outcome, attempt, id, attempted);
+    if (direct !== void 0) {
+      return finish(
+        direct.kind === "authorized" ? { ...direct, voucher: issued(data, attempted, id, direct.voucher) } : direct
+      );
+    }
+    const consulted = await consult(outcome, attempt, attempted);
+    if ("outcome" in consulted) {
+      return finish(consulted.outcome);
+    }
+    const { found } = consulted;
+    if (mayCollide && outcome.kind === "authorized" && outcome.reprocessed === true && found === null) {
+      return "collided";
+    }
+    return finish(
+      settled(
+        outcome,
+        attempt,
+        found,
+        id,
+        attempted,
+        data,
+        (voucher) => issued(data, attempted, id, voucher)
+      )
+    );
+  }
+  async function consult(outcome, attempt, attempted) {
+    const aborted = () => ({
+      outcome: {
+        kind: "indeterminate",
+        attempted,
+        attempt,
+        lookup: { kind: "aborted" }
+      }
+    });
+    if (options.abortSignal?.aborted && outcome.kind !== "authorized") {
+      return aborted();
+    }
+    try {
+      const result = await wsfex.lookupVoucher({
+        ...auth(options),
+        ...attempted
+      });
+      return { found: result.kind === "found" ? result.voucher : null };
+    } catch (error) {
+      return options.abortSignal?.aborted ? aborted() : {
+        outcome: {
+          kind: "indeterminate",
+          attempted,
+          attempt,
+          lookup: { kind: "failed", error: toArcaSafeErrorMetadata(error) }
+        }
+      };
+    }
+  }
+  async function nextRequestId() {
+    const received = await wsfex.getLastRequestId(auth(options));
+    const key = requestIdKey(context.environment, issuer);
+    const store2 = context.store;
+    const issued2 = store2 ? readRequestIdMarker(await storeCall(() => store2.get(key))) : localRequestIds.get(key) ?? 0;
+    const id = Math.max(received, issued2) + 1;
+    if (id > MAX_REQUEST_ID) {
+      throw new ArcaConfigurationError("WSFEX request ids are exhausted.");
+    }
+    if (store2) {
+      const marker = { v: 1, id };
+      await storeCall(() => store2.set(key, JSON.stringify(marker)));
+    } else {
+      localRequestIds.set(key, id);
+    }
+    return id;
+  }
+  function send(data, id, number) {
+    const once = (forceRefresh) => wsfex.issue({
+      ...data,
+      id,
+      number,
+      ...auth({
+        ...options,
+        ...forceRefresh ? { forceRefresh: true } : {}
+      })
+    });
+    return once().then(
+      (outcome) => outcome.kind === "indeterminate" && outcome.reason === "authentication_rejected" && options.forceRefresh !== true ? once(true) : outcome
+    );
+  }
+  async function moveRecord(record, id) {
+    const store2 = context.store;
+    if (record === void 0 || store2 === void 0) {
+      return;
+    }
+    const moved = { ...record, requestId: id };
+    await storeCall(() => store2.set(recordKey, JSON.stringify(moved)));
+  }
+  function issued(data, attempted, id, authorization) {
+    const total = Math.round(data.totalAmount * 100);
+    return issuedVoucher(
+      data,
+      attempted,
+      id,
+      authorization,
+      { computedTotal: total, sentTotal: total, vatAdjustment: 0 },
+      issuer
+    );
+  }
+  function evidence(outcome) {
+    const { raw, ...rest } = outcome;
+    return options.include?.rawResponse && raw !== void 0 ? { ...rest, rawResponse: raw } : rest;
+  }
+}
+function issuedVoucher(data, attempted, id, authorization, amounts, issuer) {
+  const date = isoDate(data.voucherDate);
+  return {
+    ...attempted,
+    voucherClass: "E",
+    requestId: id,
+    date,
+    header: exportHeader(data),
+    cae: authorization.cae,
+    caeExpiry: isoDate(authorization.caeExpiry) ?? "",
+    amounts: { ...amounts },
+    ...exportQr(issuer, attempted, data, date, authorization.cae)
+  };
+}
+function answered(outcome, attempt, id, attempted) {
+  if (outcome.kind === "authorized" && !outcome.reprocessed && echoes(outcome, id, attempted)) {
+    return {
+      kind: "authorized",
+      recoveredByMatch: false,
+      voucher: { cae: outcome.cae, caeExpiry: outcome.caeExpiry },
+      authorization: attempt
+    };
+  }
+  if (outcome.kind === "rejected" && !hasError(outcome, "1535")) {
+    return {
+      kind: "rejected",
+      attempted,
+      issues: [...outcome.errors, ...outcome.observations],
+      authorization: attempt
+    };
+  }
+  return void 0;
+}
+function settled(outcome, attempt, found, id, attempted, sent, issue) {
+  if (found !== null && found.id === id && sameVoucher(found, sent)) {
+    const authorized = outcome.kind === "authorized" ? outcome : void 0;
+    const cae = found.cae ?? authorized?.cae;
+    const caeExpiry = found.caeExpiry ?? authorized?.caeExpiry;
+    if (found.result !== "A" || !cae || !caeExpiry) {
+      return {
+        kind: "indeterminate",
+        attempted,
+        attempt,
+        lookup: {
+          kind: "incomplete",
+          reason: "ARCA reports no approved result, CAE and CAE expiry"
+        }
+      };
+    }
+    const voucher = issue({ cae, caeExpiry });
+    return authorized ? {
+      kind: "authorized",
+      recoveredByMatch: false,
+      voucher,
+      authorization: attempt
+    } : {
+      kind: "authorized",
+      recoveredByMatch: true,
+      voucher,
+      attempt,
+      lookup: exportSummary(found)
+    };
+  }
+  if (found !== null) {
+    return {
+      kind: "conflict",
+      attempted,
+      attempt,
+      found: exportSummary(found),
+      reason: found.id === id ? "ARCA stored different fiscal fields under this request id" : "Another request holds this voucher number"
+    };
+  }
+  if (outcome.kind === "rejected") {
+    return {
+      kind: "rejected",
+      attempted,
+      issues: [...outcome.errors, ...outcome.observations],
+      authorization: attempt
+    };
+  }
+  return {
+    kind: "indeterminate",
+    attempted,
+    attempt,
+    lookup: { kind: "not_found" }
+  };
+}
+function echoes(outcome, id, attempted) {
+  const echo = outcome.echo ?? {};
+  return (echo.id === void 0 || echo.id === id) && (echo.salesPoint === void 0 || echo.salesPoint === attempted.salesPoint) && (echo.voucherType === void 0 || echo.voucherType === attempted.voucherType) && (echo.number === void 0 || echo.number === attempted.number);
+}
+function hasError(outcome, code) {
+  return outcome.errors.some((issue) => issue.code === code);
+}
+function sameVoucher(found, sent) {
+  return canonicalHash(fiscalIdentity(found)) === canonicalHash(fiscalIdentity(sent));
+}
+function fiscalIdentity(voucher) {
+  return {
+    voucherType: voucher.voucherType,
+    salesPoint: voucher.salesPoint,
+    voucherDate: trimmed(voucher.voucherDate),
+    exportType: voucher.exportType,
+    permitExists: trimmed(voucher.permitExists),
+    permits: (voucher.permits ?? []).map((permit) => [
+      trimmed(permit.id),
+      permit.destination
+    ]),
+    destination: voucher.destination,
+    receiverName: trimmed(voucher.receiverName),
+    receiverCountryTaxId: trimmed(voucher.receiverCountryTaxId),
+    receiverAddress: trimmed(voucher.receiverAddress),
+    receiverTaxId: trimmed(voucher.receiverTaxId),
+    currencyId: trimmed(voucher.currencyId),
+    exchangeRate: decimal(voucher.exchangeRate),
+    sameCurrencyForeignCancellation: trimmed(
+      voucher.sameCurrencyForeignCancellation
+    ),
+    commercialObservations: trimmed(voucher.commercialObservations),
+    totalAmount: decimal(voucher.totalAmount),
+    observations: trimmed(voucher.observations),
+    // ARCA may fill the issuer's CUIT; the original is named by coordinates.
+    associatedVouchers: (voucher.associatedVouchers ?? []).map((original) => [
+      original.voucherType,
+      original.salesPoint,
+      original.number
+    ]),
+    paymentTerms: trimmed(voucher.paymentTerms),
+    incoterms: trimmed(voucher.incoterms),
+    incotermsDetail: trimmed(voucher.incotermsDetail),
+    language: voucher.language,
+    items: voucher.items.map((item) => [
+      trimmed(item.code),
+      trimmed(item.description),
+      decimal(item.quantity ?? 0),
+      item.unit,
+      decimal(item.unitPrice ?? "0"),
+      decimal(item.discount ?? 0),
+      decimal(item.amount)
+    ]),
+    paymentDate: trimmed(voucher.paymentDate),
+    activities: (voucher.activities ?? []).map(
+      (activity) => trimmed(activity.id)?.padStart(6, "0")
+    )
+  };
+}
+function trimmed(value) {
+  return value?.replace(/\r\n?/g, "\n").trim() || void 0;
+}
+function decimal(value) {
+  if (value === void 0) {
+    return;
+  }
+  const written = typeof value === "number" ? value.toFixed(6) : value.trim();
+  const match = /^(-?)(\d+)(?:\.(\d+))?$/.exec(written);
+  if (!match) {
+    return written;
+  }
+  const whole = (match[2] ?? "0").replace(/^0+(?=\d)/, "");
+  const fraction = (match[3] ?? "").replace(/0+$/, "");
+  const sign = whole === "0" && fraction === "" ? "" : match[1] ?? "";
+  return `${sign}${whole}${fraction ? `.${fraction}` : ""}`;
+}
+var MAX_REQUEST_ID = 999999999999999;
+var localRequestIds = /* @__PURE__ */ new Map();
+function requestIdKey(environment, issuer) {
+  return `arca:v1:wsfex:request-id:${environment}:${issuer}`;
+}
+function readRequestIdMarker(json) {
+  if (json === null) {
+    return 0;
+  }
+  try {
+    const marker = JSON.parse(json);
+    if (marker?.v === 1 && Number.isSafeInteger(marker.id) && marker.id >= 0) {
+      return marker.id;
+    }
+  } catch {
+  }
+  throw new ArcaConfigurationError(
+    "Invalid WSFEX request id marker; preserve it for reconciliation."
+  );
+}
+var localLocks = /* @__PURE__ */ new Map();
+async function withLocalLock(key, fn, signal) {
+  const previous = localLocks.get(key) ?? Promise.resolve();
+  let release = () => void 0;
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  const chained = previous.then(() => current);
+  localLocks.set(key, chained);
+  chained.then(() => {
+    if (localLocks.get(key) === chained) {
+      localLocks.delete(key);
+    }
+  });
+  try {
+    await waitForTurn(previous, signal);
+  } catch (error) {
+    release();
+    throw error;
+  }
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}
+function waitForTurn(previous, signal) {
+  throwIfAborted(signal);
+  let timer;
+  let onAbort;
+  const stopped = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(
+        new ArcaLockTimeoutError(
+          "ARCA store lock stayed held; no work was attempted.",
+          { reason: "held" }
+        )
+      ),
+      MAX_WAIT_MS
+    );
+    timer.unref?.();
+    onAbort = () => {
+      try {
+        throwIfAborted(signal);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+  return Promise.race([previous, stopped]).finally(() => {
+    clearTimeout(timer);
+    if (onAbort) {
+      signal?.removeEventListener("abort", onAbort);
+    }
+  });
+}
+function readExportRecord(json) {
+  let record;
+  try {
+    record = JSON.parse(json);
+  } catch (cause) {
+    throw new ArcaConfigurationError(
+      "Invalid ARCA reservation record; preserve it for reconciliation.",
+      { cause }
+    );
+  }
+  if (record?.service !== "wsfex") {
+    throw new ArcaInputError(
+      "The idempotency key was already used with different input or operation.",
+      {
+        code: "ARCA_INPUT_IDEMPOTENCY_MISMATCH",
+        field: "options.idempotencyKey"
+      }
+    );
+  }
+  if (record.v !== 2 || !["issue", "creditNote", "debitNote"].includes(record.operation) || typeof record.inputHash !== "string" || !record.sent || !Number.isSafeInteger(record.number) || !Number.isSafeInteger(record.requestId) || record.sent.salesPoint !== record.salesPoint || record.sent.voucherType !== record.voucherType) {
+    throw new ArcaConfigurationError(
+      "Invalid ARCA reservation record; preserve it for reconciliation."
+    );
+  }
+  return record;
+}
+function exportHeader(data) {
+  const header = {
+    exportType: data.exportType,
+    destination: data.destination,
+    receiverName: data.receiverName,
+    receiverAddress: data.receiverAddress,
+    currencyId: data.currencyId,
+    language: data.language
+  };
+  assign(header, "receiverTaxId", data.receiverTaxId);
+  assign(header, "receiverCountryTaxId", data.receiverCountryTaxId);
+  assign(header, "exchangeRate", data.exchangeRate);
+  assign(
+    header,
+    "paidInForeignCurrency",
+    data.sameCurrencyForeignCancellation === void 0 ? void 0 : data.sameCurrencyForeignCancellation === "S"
+  );
+  assign(header, "incoterms", data.incoterms);
+  assign(header, "incotermsDetail", data.incotermsDetail);
+  assign(
+    header,
+    "permitExists",
+    data.permitExists === void 0 ? void 0 : data.permitExists === "S"
+  );
+  assign(header, "paymentTerms", data.paymentTerms);
+  assign(header, "paymentDate", isoDate(data.paymentDate));
+  return header;
+}
+function exportSummary(voucher) {
+  const summary = {
+    voucherClass: "E",
+    number: voucher.number
+  };
+  assign(summary, "salesPoint", voucher.salesPoint);
+  assign(summary, "voucherType", voucher.voucherType);
+  assign(summary, "requestId", voucher.id);
+  assign(summary, "date", isoDate(voucher.voucherDate));
+  assign(summary, "exportType", voucher.exportType);
+  assign(summary, "destination", voucher.destination);
+  assign(summary, "receiverName", voucher.receiverName);
+  assign(summary, "receiverAddress", voucher.receiverAddress);
+  assign(summary, "receiverTaxId", voucher.receiverTaxId);
+  assign(summary, "receiverCountryTaxId", voucher.receiverCountryTaxId);
+  assign(summary, "currencyId", voucher.currencyId);
+  assign(summary, "exchangeRate", voucher.exchangeRate);
+  assign(
+    summary,
+    "totalAmount",
+    voucher.totalAmount === void 0 ? void 0 : Math.round(voucher.totalAmount * 100)
+  );
+  assign(summary, "result", voucher.result);
+  assign(summary, "cae", voucher.cae);
+  assign(summary, "caeExpiry", isoDate(voucher.caeExpiry));
+  return summary;
+}
+function exportQr(taxId, attempted, data, date, cae) {
+  try {
+    const qrPayload = arcaQrPayload({
+      taxId,
+      ...attempted,
+      date,
+      total: Math.round(data.totalAmount * 100),
+      currency: data.currencyId,
+      ...data.exchangeRate === void 0 ? {} : { exchangeRate: data.exchangeRate },
+      cae
+    });
+    return { qr: qrUrlForPayload(qrPayload), qrPayload };
+  } catch {
+    return {};
+  }
+}
+function originalTotal(original) {
+  return Math.round(original.totalAmount * 100);
+}
+function deriveReceiver2(to) {
+  assertIssueObject(to, "to");
+  assertIssueKeys(
+    to,
+    ["country", "name", "address", "taxId", "countryTaxId"],
+    "to"
+  );
+  const receiver = to;
+  if (!(Number.isSafeInteger(receiver.country) && receiver.country >= 1 && receiver.country <= 999)) {
+    invalid3("to.country", "an ARCA destination country code");
+  }
+  if (receiver.taxId === void 0 && receiver.countryTaxId === void 0) {
+    throw new ArcaInputError("to.taxId or to.countryTaxId is required.", {
+      code: "ARCA_INPUT_MISSING_FIELD",
+      field: "to.taxId",
+      expected: "the receiver's tax ID abroad, ARCA's country CUIT, or both"
+    });
+  }
+  if (receiver.countryTaxId !== void 0 && !(typeof receiver.countryTaxId === "string" && /^\d{11}$/.test(receiver.countryTaxId))) {
+    invalid3("to.countryTaxId", "an 11-digit string");
+  }
+  return {
+    destination: receiver.country,
+    receiverName: text(receiver.name, "to.name", 200),
+    ...receiver.countryTaxId === void 0 ? {} : { receiverCountryTaxId: receiver.countryTaxId },
+    receiverAddress: text(receiver.address, "to.address", 300),
+    ...optionalText(receiver.taxId, "receiverTaxId", 50, "to.taxId")
+  };
+}
+function deriveExport(value) {
+  assertIssueObject(value, "export");
+  const exported = value;
+  if (exported.kind === "goods") {
+    assertIssueKeys(
+      exported,
+      ["kind", "incoterms", "incotermsDetail", "permits"],
+      "export"
+    );
+    if (typeof exported.incoterms !== "string" || !/^[A-Z]{3}$/.test(exported.incoterms)) {
+      invalid3("export.incoterms", "a three-letter Incoterm such as FOB");
+    }
+    let permits;
+    if (exported.permits !== void 0) {
+      if (!Array.isArray(exported.permits) || exported.permits.length === 0) {
+        invalid3("export.permits", "a non-empty list, or absent while pending");
+      }
+      const seen = /* @__PURE__ */ new Set();
+      permits = exported.permits.map((entry, index) => {
+        const field = `export.permits[${index}]`;
+        const permit = entry;
+        assertIssueObject(permit, field);
+        assertIssueKeys(permit, ["id", "destination"], field);
+        if (typeof permit.id !== "string" || !/^\d{5}[A-Z0-9]{4}\d{6}[A-Z]$/.test(permit.id)) {
+          invalid3(`${field}.id`, "a shipping permit such as 09052EC01006154G");
+        }
+        if (!(typeof permit.destination === "number" && Number.isSafeInteger(permit.destination) && permit.destination >= 1 && permit.destination <= 999)) {
+          invalid3(`${field}.destination`, "an ARCA destination country code");
+        }
+        const pair = `${permit.id}:${permit.destination}`;
+        if (seen.has(pair)) {
+          invalid3(field, "a permit and destination listed once");
+        }
+        seen.add(pair);
+        return {
+          id: permit.id,
+          destination: permit.destination
+        };
+      });
+    }
+    return {
+      exportType: 1,
+      permitExists: permits === void 0 ? "N" : "S",
+      ...permits === void 0 ? {} : { permits },
+      incoterms: exported.incoterms,
+      ...optionalText(
+        exported.incotermsDetail,
+        "incotermsDetail",
+        20,
+        "export.incotermsDetail"
+      )
+    };
+  }
+  if (exported.kind === "services" || exported.kind === "other") {
+    assertIssueKeys(exported, ["kind", "paymentDate"], "export");
+    if (exported.paymentDate === void 0) {
+      throw new ArcaInputError("export.paymentDate is required.", {
+        code: "ARCA_INPUT_MISSING_FIELD",
+        field: "export.paymentDate",
+        expected: "the date the receiver pays"
+      });
+    }
+    return {
+      exportType: EXPORT_KINDS[exported.kind],
+      paymentDate: normalizeWsfeDateInput(
+        exported.paymentDate,
+        "export.paymentDate"
+      )
+    };
+  }
+  return invalid3("export.kind", "goods, services or other");
+}
+function deriveCurrency2(currency, rate) {
+  const value = currency ?? "ARS";
+  let currencyId;
+  if (typeof value === "object" && value !== null) {
+    assertIssueKeys(value, ["id"], "currency");
+    if (typeof value.id !== "string" || !/^[A-Z0-9]{3}$/.test(value.id)) {
+      invalid3("currency.id", "a three-character ARCA currency code");
+    }
+    currencyId = value.id;
+  } else if (value === "ARS" || value === "USD") {
+    currencyId = ARCA_CURRENCY_IDS[value];
+  } else {
+    return invalid3("currency", "ARS, USD or { id }");
+  }
+  if (rate !== void 0 && typeof rate !== "string") {
+    invalid3("exchangeRate", "a decimal string");
+  }
+  if (currencyId === ARCA_CURRENCY_IDS.ARS) {
+    const exchangeRate2 = serializeArcaExchangeRate(rate ?? "1", "exchangeRate");
+    if (Number(exchangeRate2) !== 1) {
+      invalid3("exchangeRate", "1 for pesos");
+    }
+    return { currencyId, exchangeRate: exchangeRate2 };
+  }
+  if (rate === void 0) {
+    throw new ArcaInputError("exchangeRate is required for this currency.", {
+      code: "ARCA_INPUT_MISSING_FIELD",
+      field: "exchangeRate",
+      expected: "ARCA's rate, from wsfex.getExchangeRate()"
+    });
+  }
+  return {
+    currencyId,
+    exchangeRate: serializeArcaExchangeRate(rate, "exchangeRate")
+  };
+}
+function deriveLanguage(language) {
+  if (language === void 0) {
+    return 1;
+  }
+  if (typeof language !== "string" || !Object.hasOwn(LANGUAGES, language)) {
+    return invalid3("language", "es, en or pt");
+  }
+  return LANGUAGES[language];
+}
+var SCALE_6 = 1000000n;
+function deriveItems(value, path) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > 9999) {
+    invalid3(path, "a list of 1 to 9999 items");
+  }
+  let total = 0n;
+  const items = value.map((item, index) => {
+    const line = deriveItem(item, `${path}[${index}]`);
+    total += BigInt(item.amount);
+    return line;
+  });
+  if (total < 0n) {
+    invalid3(path, "lines whose total is zero or positive");
+  }
+  return { items, total: Number(total) };
+}
+function deriveItem(item, field) {
+  assertIssueObject(item, field);
+  assertIssueKeys(
+    item,
+    [
+      "description",
+      "unit",
+      "quantity",
+      "unitPrice",
+      "discount",
+      "code",
+      "amount"
+    ],
+    field
+  );
+  if (!(Number.isSafeInteger(item.unit) && item.unit >= 0 && item.unit <= 99)) {
+    invalid3(`${field}.unit`, "an ARCA unit of measure");
+  }
+  assertItemAmount(item, field);
+  const line = {
+    ...optionalText(item.code, "code", 50, `${field}.code`),
+    description: text(item.description, `${field}.description`, 4e3),
+    unit: item.unit,
+    amount: item.amount / 100
+  };
+  if (!UNPRICED_UNITS.includes(item.unit)) {
+    return { ...line, ...pricedLine(item, field) };
+  }
+  for (const key of ["quantity", "unitPrice", "discount"]) {
+    if (item[key] !== void 0 && Number(item[key]) !== 0) {
+      invalid3(`${field}.${key}`, `absent for unit ${item.unit}`);
+    }
+  }
+  return line;
+}
+function assertItemAmount(item, field) {
+  if (!Number.isSafeInteger(item.amount)) {
+    invalid3(`${field}.amount`, "an integer amount in minor units");
+  }
+  if (item.unit === 99 && item.amount >= 0) {
+    invalid3(`${field}.amount`, "negative for a discount line");
+  }
+  if (item.unit !== 97 && item.unit !== 99 && item.amount < 0) {
+    invalid3(`${field}.amount`, "zero or positive for this unit");
+  }
+  if (Math.abs(item.amount) > 999999999999999) {
+    invalid3(`${field}.amount`, "at most 13 integer digits");
+  }
+}
+function pricedLine(item, field) {
+  const quantity = scaledQuantity(item.quantity, `${field}.quantity`);
+  const price = scaledPrice(item.unitPrice, `${field}.unitPrice`);
+  const discount = item.discount ?? 0;
+  if (!(Number.isSafeInteger(discount) && discount >= 0)) {
+    invalid3(`${field}.discount`, "a non-negative amount in minor units");
+  }
+  const exact = quantity * price - BigInt(discount) * 10000000000n;
+  if (exact < 0n) {
+    invalid3(`${field}.discount`, "at most the line's quantity \xD7 unitPrice");
+  }
+  if (!withinLineTolerance(exact, BigInt(item.amount))) {
+    throw new ArcaInputError(
+      `${field}.amount must equal quantity \xD7 unitPrice less discount.`,
+      {
+        code: "ARCA_INPUT_AMOUNT_MISMATCH",
+        field: `${field}.amount`,
+        expected: String(roundHalfEvenRatio(exact, 10000000000n))
+      }
+    );
+  }
+  return {
+    quantity: item.quantity,
+    unitPrice: item.unitPrice,
+    ...discount > 0 ? { discount: discount / 100 } : {}
+  };
+}
+function withinLineTolerance(exact, amountMinorUnits) {
+  const computed = roundHalfEvenRatio(exact, 10000000n);
+  const amount = amountMinorUnits * 1000n;
+  const error = computed > amount ? computed - amount : amount - computed;
+  if (error <= 1000n) {
+    return true;
   }
-  const envLevel = process.env.ARCA_LOG_LEVEL?.trim().toLowerCase();
-  if (isArcaLogLevel(envLevel)) {
-    return envLevel;
+  const base = computed < amount ? computed : amount;
+  return base > 0n && error * 10000n <= base;
+}
+function scaledQuantity(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return invalid3(field, "a positive number");
   }
-  return "warn";
+  const fixed = value.toFixed(6);
+  if (Number(fixed) !== value || fixed.split(".")[0].length > 12) {
+    invalid3(field, "at most 12 integer digits and 6 decimals");
+  }
+  const [whole, fraction = ""] = fixed.split(".");
+  return BigInt(whole) * SCALE_6 + BigInt(fraction.padEnd(6, "0"));
 }
-function shouldLog(threshold, messageLevel) {
-  return ARCA_LOG_LEVELS.indexOf(messageLevel) >= ARCA_LOG_LEVELS.indexOf(threshold);
+function scaledPrice(value, field) {
+  if (typeof value !== "string" || !/^\d{1,12}(\.\d{1,6})?$/.test(value)) {
+    return invalid3(field, "a decimal string with at most 6 decimals");
+  }
+  const [whole, fraction = ""] = value.split(".");
+  return BigInt(whole) * SCALE_6 + BigInt(fraction.padEnd(6, "0"));
 }
-function isArcaLogLevel(value) {
-  return ARCA_LOG_LEVELS.includes(value);
+function reviewedTotal(total, computed) {
+  if (total === void 0) {
+    return computed;
+  }
+  if (!Number.isSafeInteger(total) || total < 0) {
+    invalid3("total", "a non-negative integer amount in minor units");
+  }
+  if (total !== computed) {
+    throw new ArcaInputError("total must equal the sum of items.", {
+      code: "ARCA_INPUT_AMOUNT_MISMATCH",
+      field: "total",
+      expected: String(computed)
+    });
+  }
+  return computed;
 }
-function defaultArcaLog(level, message, ...args) {
-  const method = level === "debug" ? console.debug : level === "info" ? console.info : level === "warn" ? console.warn : console.error;
-  method(message, ...args);
+function assertSalesPoint2(value, field) {
+  if (!(typeof value === "number" && Number.isSafeInteger(value) && value >= 1 && value <= 99998)) {
+    invalid3(field, "an integer from 1 through 99998");
+  }
+}
+function text(value, field, max) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new ArcaInputError(`${field} is required.`, {
+      code: "ARCA_INPUT_MISSING_FIELD",
+      field,
+      expected: `a non-empty string of at most ${max} characters`
+    });
+  }
+  if (value.length > max) {
+    invalid3(field, `at most ${max} characters`);
+  }
+  return value;
+}
+function optionalText(value, key, max, field = key) {
+  if (value === void 0) {
+    return {};
+  }
+  return { [key]: text(value, field, max) };
+}
+function isoDate(value) {
+  return value === void 0 ? void 0 : toIsoDate(value) ?? value;
+}
+function assign(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function invalid3(field, expected) {
+  throw new ArcaInputError(`${field} must be ${expected}.`, {
+    code: "ARCA_INPUT_INVALID_VALUE",
+    field,
+    expected
+  });
 }
 
 // src/services/issuance-wsmtxca.ts
@@ -2839,7 +5268,7 @@ var iso = (value) => {
 };
 function assertWsmtxcaVoucherType(voucherType) {
   if (voucherFamily(voucherType).voucherClass === "C") {
-    invalid3(
+    invalid4(
       "voucherType",
       "WSMTXCA authorizes class A and B vouchers only; issue class C through WSFE"
     );
@@ -2860,7 +5289,7 @@ function wsmtxcaRequest(data, number) {
     (source) => source !== void 0
   ).length;
   if (!lines?.length || sources !== 1) {
-    invalid3("items", "WSMTXCA requires items with line detail");
+    invalid4("items", "WSMTXCA requires items with line detail");
   }
   const items = lines.map((line) => ({
     unidadesMtx: line.matrixUnits,
@@ -2887,7 +5316,7 @@ function wsmtxcaRequest(data, number) {
   }
   const tributes = data.taxes?.length ? data.taxes : void 0;
   if (tributes === void 0 && normalizeArcaAmountToMinorUnits(data.taxAmount, "taxes") !== 0n) {
-    invalid3("taxes", "Tribute amount requires tribute details");
+    invalid4("taxes", "Tribute amount requires tribute details");
   }
   return {
     comprobanteCAERequest: {
@@ -2956,7 +5385,7 @@ function wsmtxcaRequest(data, number) {
     }
   };
 }
-function invalid3(field, message) {
+function invalid4(field, message) {
   throw new ArcaInputError(message, {
     code: "ARCA_INPUT_INVALID_VALUE",
     field
@@ -3187,7 +5616,7 @@ function wsmtxcaAdditionalData(fields) {
 }
 
 // src/services/wsfe-credit-note.ts
-function invalid4(reason) {
+function invalid5(reason) {
   throw new ArcaInputError(`issueCreditNote cannot proceed: ${reason}.`, {
     code: "ARCA_INPUT_INVALID_VALUE"
   });
@@ -3207,7 +5636,7 @@ function originalReceiverDocument(original) {
 }
 function required(value, field) {
   if (value === void 0 || value === null) {
-    invalid4(`original is missing ${field}`);
+    invalid5(`original is missing ${field}`);
   }
   return value;
 }
@@ -3236,7 +5665,7 @@ function deriveWsfeFullCreditNote(original, input, now = /* @__PURE__ */ new Dat
 }
 function deriveWsfePartialCreditNote(originals, input, now = /* @__PURE__ */ new Date(), kind = "creditNote") {
   if (input.items === void 0 && input.amounts === void 0) {
-    invalid4("items is required to credit chosen lines");
+    invalid5("items is required to credit chosen lines");
   }
   const requestedTotal = input.total === void 0 ? void 0 : assertArcaMinorUnits(input.total, "total");
   const { note, header } = prepareCreditNote(originals, input, now, kind);
@@ -3249,7 +5678,7 @@ function deriveWsfePartialCreditNote(originals, input, now = /* @__PURE__ */ new
     input.amounts,
     input.taxes
   ) : calculateWsfeAmounts(lineSource);
-  const originalTotal = originals.reduce(
+  const originalTotal2 = originals.reduce(
     (sum, original) => sum + normalizeArcaAmountToMinorUnits(
       required(original.totalAmount, "totalAmount"),
       "totalAmount"
@@ -3257,8 +5686,8 @@ function deriveWsfePartialCreditNote(originals, input, now = /* @__PURE__ */ new
     0n
   );
   const ceiling = originals.length === 1 ? "the original" : "the sum of the originals";
-  if (kind === "creditNote" && (requestedTotal ?? BigInt(amounts.sentTotal)) > originalTotal) {
-    invalid4(
+  if (kind === "creditNote" && (requestedTotal ?? BigInt(amounts.sentTotal)) > originalTotal2) {
+    invalid5(
       `the note total is greater than ${ceiling}; the SDK does not track earlier notes against an original`
     );
   }
@@ -3281,8 +5710,8 @@ function deriveWsfePartialCreditNote(originals, input, now = /* @__PURE__ */ new
     )
   );
   const sentTotal = input.amounts && requestedTotal !== void 0 ? Number(requestedTotal) : total;
-  if (kind === "creditNote" && BigInt(sentTotal) > originalTotal) {
-    invalid4(`the note total is greater than ${ceiling}`);
+  if (kind === "creditNote" && BigInt(sentTotal) > originalTotal2) {
+    invalid5(`the note total is greater than ${ceiling}`);
   }
   data.totalAmount = minor(sentTotal, "total");
   amounts.computedTotal += total - amounts.sentTotal;
@@ -3301,7 +5730,7 @@ function prepareCreditNote(originals, input, now, kind) {
   );
   const [first, ...rest] = derived;
   if (first === void 0) {
-    invalid4("for must name at least one original");
+    invalid5("for must name at least one original");
   }
   for (const other of rest) {
     assertInheritedHeader(first.header, other.header);
@@ -3324,7 +5753,7 @@ function assertInheritedHeader(first, other) {
     const left = first[field];
     const right = other[field];
     if (JSON.stringify(left) !== JSON.stringify(right)) {
-      invalid4(
+      invalid5(
         `the originals disagree on ${field}, which the note inherits from them`
       );
     }
@@ -3335,14 +5764,14 @@ function resolveReceiverCondition(original, input) {
   const reported = original.receiverVatConditionId;
   if (reported === void 0) {
     if (supplied === void 0) {
-      invalid4(
+      invalid5(
         "original is missing receiverVatConditionId; pass to.condition with the receiver's condition"
       );
     }
     return supplied;
   }
   if (supplied !== void 0 && supplied !== reported) {
-    invalid4(
+    invalid5(
       `to.condition (${supplied}) does not match the original's receiver condition (${reported})`
     );
   }
@@ -3352,14 +5781,14 @@ function prepareOneCreditNote(original, input, now, kind) {
   assertOriginalExtensions(original);
   const family = voucherFamily(original.voucherType ?? 0);
   if (family.types[2] === original.voucherType) {
-    invalid4("original must be an invoice or debit note");
+    invalid5("original must be an invoice or debit note");
   }
   const note = {
     voucherClass: family.voucherClass,
     voucherType: family.types[kind === "creditNote" ? 2 : 1]
   };
   if (!(["A", "O"].includes(original.result ?? "") && original.cae?.trim() && original.caeExpiry?.trim())) {
-    invalid4("original is not authorized");
+    invalid5("original is not authorized");
   }
   const voucherDate = normalizeWsfeDateInput(
     input.date ?? buenosAiresDate(now),
@@ -3370,7 +5799,7 @@ function prepareOneCreditNote(original, input, now, kind) {
     "original.voucherDate"
   );
   if (originalDate > voucherDate && originalDate.slice(0, 6) !== voucherDate.slice(0, 6)) {
-    invalid4(
+    invalid5(
       "original date is later than the note and outside its month (10210)"
     );
   }
@@ -3447,7 +5876,7 @@ function assertNoteReceiver(to) {
   try {
     receiverConditionId(to.condition, "to.condition");
   } catch {
-    invalid4("to.condition must be a supported receiver condition");
+    invalid5("to.condition must be a supported receiver condition");
   }
 }
 function assertCreditNoteInput(input) {
@@ -3480,7 +5909,7 @@ function assertCreditNoteInput(input) {
     ...input.to === void 0 ? {} : { to: { condition: input.to.condition } }
   };
   if (input.items !== void 0 && input.amounts !== void 0) {
-    invalid4("use items or amounts, never both");
+    invalid5("use items or amounts, never both");
   }
   if ((input.items === void 0 && input.amounts === void 0) === (input.all === void 0)) {
     throw new ArcaInputError(
@@ -3617,7 +6046,7 @@ function assertOriginalExtensions(original) {
     ["associatedPeriod", "PeriodoAsoc"]
   ]) {
     if (original.raw[rawField] && original[field] === void 0) {
-      invalid4(`original ${field} could not be decoded`);
+      invalid5(`original ${field} could not be decoded`);
     }
   }
   try {
@@ -3648,7 +6077,7 @@ function assertOriginalExtensions(original) {
       );
     }
   } catch {
-    invalid4("original extension fields are incomplete or malformed");
+    invalid5("original extension fields are incomplete or malformed");
   }
 }
 function assertFullMode(input) {
@@ -3685,7 +6114,7 @@ function assertFullMode(input) {
 }
 
 // src/services/vouchers.ts
-function createVouchersService(wsfe, context, wsmtxca) {
+function createVouchersService(wsfe, context, wsmtxca, wsfex) {
   const select = (options = {}) => {
     validateOptions(options);
     if (options.service !== "wsmtxca") {
@@ -3696,63 +6125,192 @@ function createVouchersService(wsfe, context, wsmtxca) {
     }
     return createWsmtxcaIssuanceService(wsmtxca);
   };
-  return {
-    lookup: async (voucher, options) => lookupVoucher(select(options), voucher, options ?? {}),
-    lastAuthorized: async (sequence, options) => lastAuthorizedNumber(select(options), sequence, options ?? {}),
-    recover: async (key, options) => recoverOperation(
-      select,
-      key,
-      options === void 0 ? {} : options,
-      context
-    ),
-    issueDebitNote: async (input, options) => issueCreditNote(
+  const exportIssuance = wsfex && context ? createExportIssuance(wsfex, context) : void 0;
+  const exporting = () => {
+    if (!exportIssuance) {
+      throw new ArcaConfigurationError("WSFEX service is not configured");
+    }
+    return exportIssuance;
+  };
+  const exportOptions = (options) => {
+    const cloned = cloneOptions(options ?? {});
+    validateOptions(cloned);
+    validateKeyStore(cloned, context);
+    return cloned;
+  };
+  async function prepareExportNote(input, options, kind) {
+    assertIssueObject(input, "input");
+    assertIssueObject(input.for, "for");
+    assertIssueKeys(input.for, ["salesPoint", "voucherType", "number"], "for");
+    for (const [field, max] of [
+      ["salesPoint", 99998],
+      ["number", 99999999]
+    ]) {
+      const value = input.for[field];
+      if (!(Number.isSafeInteger(value) && value >= 1 && value <= max)) {
+        throw new ArcaInputError(
+          `for.${field} must be an integer from 1 through ${max}.`,
+          {
+            code: "ARCA_INPUT_INVALID_VALUE",
+            field: `for.${field}`
+          }
+        );
+      }
+    }
+    const original = await exporting().original(input.for, options);
+    if (original === null) {
+      throw new ArcaInputError("ARCA has no voucher at for.", {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field: "for",
+        expected: "an authorized export voucher"
+      });
+    }
+    return { original, prepared: deriveExportNote(original, input, kind) };
+  }
+  async function issueExportNote(input, inputOptions, kind) {
+    const options = exportOptions(inputOptions);
+    const snapshot = structuredClone(input);
+    return await exporting().issue(
+      async () => (await prepareExportNote(snapshot, options, kind)).prepared,
+      kind,
+      snapshot,
+      options
+    );
+  }
+  async function previewExportNote(input, inputOptions, kind) {
+    const options = cloneOptions(inputOptions ?? {});
+    assertIssueObject(options, "options");
+    assertIssueKeys(
+      options,
+      ["representedTaxId", "forceRefresh", "abortSignal"],
+      "options",
+      kind === "creditNote" ? "previewCreditNote()" : "previewDebitNote()"
+    );
+    validateOptions(options);
+    const { original, prepared } = await prepareExportNote(
+      structuredClone(input),
+      options,
+      kind
+    );
+    assertExportWindow(prepared.data);
+    return exportPreview(prepared, [exportSummary(original)]);
+  }
+  async function readReservation(key, inputOptions) {
+    const store = context?.store;
+    if (exportIssuance === void 0 || store === void 0 || !context) {
+      return;
+    }
+    const options = cloneOptions(inputOptions ?? {});
+    assertIssueObject(options, "options");
+    assertIssueKeys(
+      options,
+      ["representedTaxId", "forceRefresh", "include", "abortSignal"],
+      "options"
+    );
+    validateOptions(options);
+    validateKeyStore({ ...options, idempotencyKey: key }, context);
+    const json = await storeCall(
+      () => store.get(attemptKey(context.environment, context.taxId, key))
+    );
+    return { json, options };
+  }
+  const service = {
+    lookup: (async (voucher, options) => {
+      if (!isExportVoucherType(voucher?.voucherType)) {
+        return await lookupVoucher(select(options), voucher, options ?? {});
+      }
+      const checked = cloneOptions(options ?? {});
+      assertLookup(voucher, checked);
+      return await exporting().lookup(voucher, checked);
+    }),
+    lastAuthorized: (async (sequence, options) => {
+      if (!isExportVoucherType(sequence?.voucherType)) {
+        return await lastAuthorizedNumber(
+          select(options),
+          sequence,
+          options ?? {}
+        );
+      }
+      const checked = cloneOptions(options ?? {});
+      assertSequence(sequence, checked);
+      return await exporting().lastAuthorized(sequence, checked);
+    }),
+    recover: (async (key, options) => {
+      const read = await readReservation(key, options);
+      if (typeof read?.json === "string" && isExportRecord(read.json)) {
+        return await exporting().recover(key, read.json, read.options);
+      }
+      return await recoverOperation(
+        select,
+        key,
+        options === void 0 ? {} : options,
+        context,
+        read?.json
+      );
+    }),
+    issueDebitNote: (async (input, options) => isExportNoteInput(input) ? issueExportNote(input, options, "debitNote") : issueCreditNote(
       select(options),
       input,
       options ?? {},
       context,
       "debitNote",
       select
-    ),
-    previewCreditNote: async (input, options) => previewNote(
+    )),
+    previewCreditNote: (async (input, options) => isExportNoteInput(input) ? previewExportNote(input, options, "creditNote") : previewNote(
       select(options),
       input,
       options ?? {},
       context,
       "creditNote"
-    ),
-    previewDebitNote: async (input, options) => previewNote(
+    )),
+    previewDebitNote: (async (input, options) => isExportNoteInput(input) ? previewExportNote(input, options, "debitNote") : previewNote(
       select(options),
       input,
       options ?? {},
       context,
       "debitNote"
-    ),
-    issueCreditNote: async (input, options) => {
-      const result = await issueCreditNote(
-        select(options),
-        input,
-        options === void 0 ? {} : options,
-        context,
-        "creditNote",
-        select
-      );
-      return result;
-    },
-    issue: async (input, options) => {
-      const result = await issueInvoice(
+    )),
+    issueCreditNote: (async (input, options) => isExportNoteInput(input) ? issueExportNote(input, options, "creditNote") : issueCreditNote(
+      select(options),
+      input,
+      options === void 0 ? {} : options,
+      context,
+      "creditNote",
+      select
+    )),
+    issue: (async (input, options) => {
+      if (isExportInput(input)) {
+        const checked = exportOptions(options);
+        const snapshot = structuredClone(input);
+        return await exporting().issue(
+          () => deriveExportInvoice(snapshot),
+          "issue",
+          snapshot,
+          checked
+        );
+      }
+      return await issueInvoice(
         select(options),
         input,
         options === void 0 ? {} : options,
         context,
         select
       );
-      return result;
-    },
-    preview: (input, options) => previewInvoice(
-      input,
-      options === void 0 ? {} : options
-    )
+    }),
+    preview: ((input, options) => {
+      if (isExportInput(input)) {
+        const checked = options ?? {};
+        assertIssueObject(checked, "options");
+        assertIssueKeys(checked, ["representedTaxId"], "options");
+        validateOptions(checked);
+        const prepared = deriveExportInvoice(input);
+        assertExportWindow(prepared.data);
+        return exportPreview(prepared);
+      }
+      return previewInvoice(input, options === void 0 ? {} : options);
+    })
   };
+  return service;
 }
 function previewInvoice(input, options) {
   assertIssueObject(options, "options");
@@ -3831,15 +6389,14 @@ async function issueInvoice(wsfe, input, inputOptions, context, select) {
   const options = cloneOptions(inputOptions);
   validateOptions(options);
   validateKeyStore(options, context);
-  const prepared = prepareInvoice(input, options);
+  const snapshot = structuredClone(input);
   return await runOperation(
     wsfe,
     "issue",
-    input,
-    () => Promise.resolve(prepared),
+    snapshot,
+    async () => prepareInvoice(snapshot, options),
     options,
     context,
-    prepared.amounts,
     select
   );
 }
@@ -3850,7 +6407,7 @@ function withIssuerName(input) {
   const name = issuerConditionName(input.issuer);
   return name === void 0 ? input : { ...input, issuer: name };
 }
-async function runOperation(wsfe, operation, input, prepare, options, context, replayAmounts, select) {
+async function runOperation(wsfe, operation, input, prepare, options, context, select) {
   const issuer = issuerTaxId(options, context);
   if (options.idempotencyKey === void 0 || !context?.store) {
     return runAuthorization(
@@ -3871,7 +6428,7 @@ async function runOperation(wsfe, operation, input, prepare, options, context, r
     ...options.service === "wsmtxca" ? { service: "wsmtxca" } : {},
     ...options.number === void 0 ? {} : { number: options.number }
   });
-  const settled = settledKey(environment, taxId, idempotencyKey);
+  const settled2 = settledKey(environment, taxId, idempotencyKey);
   const existing = await storeCall(() => store.get(key));
   if (existing !== null) {
     return await replay(existing);
@@ -3994,10 +6551,7 @@ async function runOperation(wsfe, operation, input, prepare, options, context, r
       current,
       runAuthorization(
         wsfe,
-        {
-          ...preparedFromRecord(current),
-          ...replayAmounts ? { amounts: replayAmounts } : {}
-        },
+        preparedFromRecord(current),
         options,
         issuer,
         current.number,
@@ -4015,7 +6569,7 @@ async function runOperation(wsfe, operation, input, prepare, options, context, r
     const uncoordinated = !store.withLock;
     const outcome = await recordConflict(
       store,
-      settled,
+      settled2,
       await running,
       !(presumed && uncoordinated)
     );
@@ -4039,7 +6593,7 @@ async function runOperation(wsfe, operation, input, prepare, options, context, r
   async function clearRejection(record) {
     const checked = await settle2(
       record,
-      consultReservation(select ?? (() => wsfe), record, options, taxId, true),
+      consultReservation2(select ?? (() => wsfe), record, options, taxId, true),
       { presumed: true }
     );
     if (checked.kind !== "indeterminate" || checked.lookup.kind !== "not_found") {
@@ -4155,11 +6709,11 @@ function readSettledRecord(json) {
     );
   }
 }
-async function settledOutcome(select, reservation, settled, options, taxId, settledFor) {
-  if (settled.kind === "conflict") {
-    return settledConflict(settled, reservation, options);
+async function settledOutcome(select, reservation, settled2, options, taxId, settledFor) {
+  if (settled2.kind === "conflict") {
+    return settledConflict(settled2, reservation, options);
   }
-  const outcome = await consultReservation(
+  const outcome = await consultReservation2(
     select,
     reservation,
     options,
@@ -4167,14 +6721,14 @@ async function settledOutcome(select, reservation, settled, options, taxId, sett
     true
   );
   const empty = outcome.kind === "indeterminate" && outcome.lookup.kind === "not_found";
-  if (!empty && (outcome.kind !== "conflict" || await successionDisputed(settled, taxId, settledFor))) {
+  if (!empty && (outcome.kind !== "conflict" || await successionDisputed(settled2, taxId, settledFor))) {
     return outcome;
   }
   return withheld(
     reservation,
-    { kind: "superseded", by: settled.by, byTaxId: settled.byTaxId ?? taxId },
+    { kind: "superseded", by: settled2.by, byTaxId: settled2.byTaxId ?? taxId },
     options,
-    settled.number
+    settled2.number
   );
 }
 function withheld(reservation, lookup, options, number = reservation.number) {
@@ -4214,16 +6768,16 @@ async function successionDisputed(superseded, taxId, settledFor) {
   }
   return true;
 }
-function settledConflict(settled, reservation, options) {
+function settledConflict(settled2, reservation, options) {
   return {
     kind: "conflict",
     attempted: {
       salesPoint: reservation.salesPoint,
       voucherType: reservation.voucherType,
-      number: settled.number
+      number: settled2.number
     },
     attempt: replayEvidence(reservation.service),
-    found: settled.found,
+    found: settled2.found,
     reason: "This key already recorded another voucher at the reserved number. Reconcile before issuing under a new key.",
     ...reservationEvidence(reservation, options)
   };
@@ -4245,6 +6799,15 @@ function validateKeyStore(options, context) {
   }
 }
 function readRecord(json) {
+  if (isExportRecord(json)) {
+    throw new ArcaInputError(
+      "The idempotency key was already used for an export voucher.",
+      {
+        code: "ARCA_INPUT_IDEMPOTENCY_MISMATCH",
+        field: "options.idempotencyKey"
+      }
+    );
+  }
   try {
     const record = JSON.parse(json);
     if (!record || record.v !== 1 && record.v !== 2 || record.v === 2 && record.service === void 0 || !["issue", "creditNote", "debitNote"].includes(record.operation) || typeof record.inputHash !== "string" || !record.sent || record.rejectedAt !== void 0 && typeof record.rejectedAt !== "string" || !Number.isSafeInteger(record.number) || record.number < 1 || record.number > 99999999 || record.sent.salesPoint !== record.salesPoint || record.sent.voucherType !== record.voucherType) {
@@ -4265,6 +6828,13 @@ function readRecord(json) {
     );
   }
 }
+function isExportRecord(json) {
+  try {
+    return JSON.parse(json)?.service === "wsfex";
+  } catch {
+    return false;
+  }
+}
 function preparedFromRecord(record) {
   const sentTotal = Number(
     normalizeArcaAmountToMinorUnits(record.sent.totalAmount, "totalAmount")
@@ -4298,7 +6868,7 @@ async function nextNumber(wsfe, data, options) {
   return number;
 }
 async function runAuthorization(wsfe, { data, voucherClass, amounts }, options, taxId, reservedNumber, { lookupFirst = false, strangerAtNumber = false } = {}) {
-  const auth = {
+  const auth2 = {
     representedTaxId: options.representedTaxId,
     forceRefresh: options.forceRefresh,
     ...options.abortSignal === void 0 ? {} : { abortSignal: options.abortSignal }
@@ -4311,7 +6881,7 @@ async function runAuthorization(wsfe, { data, voucherClass, amounts }, options,
     number
   };
   const includedRequest = requestEvidence(data, number, options);
-  const voucher = (cae, caeExpiry, lookup) => issuedVoucher(
+  const voucher = (cae, caeExpiry, lookup) => issuedVoucher2(
     { attempted, voucherClass, data, amounts, taxId },
     cae,
     caeExpiry,
@@ -4319,7 +6889,7 @@ async function runAuthorization(wsfe, { data, voucherClass, amounts }, options,
   );
   const recovery = {
     wsfe,
-    auth,
+    auth: auth2,
     data,
     attempted,
     includeRawResponse,
@@ -4331,7 +6901,7 @@ async function runAuthorization(wsfe, { data, voucherClass, amounts }, options,
     const attempt2 = replayEvidence(options.service);
     let lookup;
     try {
-      lookup = await wsfe.lookupVoucher({ ...auth, ...attempted });
+      lookup = await wsfe.lookupVoucher({ ...auth2, ...attempted });
     } catch (error) {
       return {
         kind: "indeterminate",
@@ -4346,13 +6916,13 @@ async function runAuthorization(wsfe, { data, voucherClass, amounts }, options,
     }
   }
   let authorization = await wsfe.issue({
-    ...auth,
+    ...auth2,
     data,
     voucherNumber: number
   });
-  if (authorization.kind === "indeterminate" && authorization.reason === "authentication_rejected" && auth.forceRefresh !== true) {
+  if (authorization.kind === "indeterminate" && authorization.reason === "authentication_rejected" && auth2.forceRefresh !== true) {
     authorization = await wsfe.issue({
-      ...auth,
+      ...auth2,
       forceRefresh: true,
       data,
       voucherNumber: number
@@ -4385,7 +6955,7 @@ async function runAuthorization(wsfe, { data, voucherClass, amounts }, options,
   return recoverInvoice({
     wsfe,
     service: options.service,
-    auth,
+    auth: auth2,
     data,
     attempted,
     attempt,
@@ -4427,7 +6997,7 @@ function mayHoldNumber(issues, service = "wsfe") {
 }
 async function recoverInvoice({
   wsfe,
-  auth,
+  auth: auth2,
   data,
   attempted,
   attempt,
@@ -4438,7 +7008,7 @@ async function recoverInvoice({
   service,
   strangerAtNumber = false
 }) {
-  if (suppliedLookup === void 0 && auth.abortSignal?.aborted) {
+  if (suppliedLookup === void 0 && auth2.abortSignal?.aborted) {
     return {
       kind: "indeterminate",
       attempted,
@@ -4449,13 +7019,13 @@ async function recoverInvoice({
   }
   let lookup;
   try {
-    lookup = suppliedLookup ?? await wsfe.lookupVoucher({ ...auth, ...attempted });
+    lookup = suppliedLookup ?? await wsfe.lookupVoucher({ ...auth2, ...attempted });
   } catch (error) {
     return {
       kind: "indeterminate",
       attempted,
       attempt,
-      lookup: auth.abortSignal?.aborted ? { kind: "aborted" } : { kind: "failed", error: toArcaSafeErrorMetadata(error) },
+      lookup: auth2.abortSignal?.aborted ? { kind: "aborted" } : { kind: "failed", error: toArcaSafeErrorMetadata(error) },
       ...includedRequest
     };
   }
@@ -4675,7 +7245,6 @@ async function issueCreditNote(wsfe, input, inputOptions, context, kind = "credi
     () => prepareNote(wsfe, note, options, context, kind),
     options,
     context,
-    void 0,
     select
   );
 }
@@ -4792,8 +7361,7 @@ function assertBounds(value, bounds, field, method) {
     }
   }
 }
-async function lookupVoucher(wsfe, voucher, inputOptions) {
-  const options = cloneOptions(inputOptions);
+function assertLookup(voucher, options) {
   assertIssueKeys(
     options,
     ["representedTaxId", "service", "forceRefresh", "abortSignal"],
@@ -4808,6 +7376,26 @@ async function lookupVoucher(wsfe, voucher, inputOptions) {
     "lookup()"
   );
   assertBounds(voucher, LOOKUP_BOUNDS, "voucher", "lookup()");
+}
+function assertSequence(sequence, options) {
+  assertIssueKeys(
+    options,
+    ["representedTaxId", "service", "forceRefresh", "abortSignal"],
+    "options",
+    "lastAuthorized()"
+  );
+  assertIssueObject(sequence, "sequence");
+  assertIssueKeys(
+    sequence,
+    ["salesPoint", "voucherType"],
+    "sequence",
+    "lastAuthorized()"
+  );
+  assertBounds(sequence, SEQUENCE_BOUNDS, "sequence", "lastAuthorized()");
+}
+async function lookupVoucher(wsfe, voucher, inputOptions) {
+  const options = cloneOptions(inputOptions);
+  assertLookup(voucher, options);
   const found = await wsfe.lookupVoucher({
     representedTaxId: options.representedTaxId,
     forceRefresh: options.forceRefresh,
@@ -4829,20 +7417,7 @@ async function lookupVoucher(wsfe, voucher, inputOptions) {
 }
 async function lastAuthorizedNumber(wsfe, sequence, inputOptions) {
   const options = cloneOptions(inputOptions);
-  assertIssueKeys(
-    options,
-    ["representedTaxId", "service", "forceRefresh", "abortSignal"],
-    "options",
-    "lastAuthorized()"
-  );
-  assertIssueObject(sequence, "sequence");
-  assertIssueKeys(
-    sequence,
-    ["salesPoint", "voucherType"],
-    "sequence",
-    "lastAuthorized()"
-  );
-  assertBounds(sequence, SEQUENCE_BOUNDS, "sequence", "lastAuthorized()");
+  assertSequence(sequence, options);
   const next = await wsfe.getNextVoucherNumber({
     representedTaxId: options.representedTaxId,
     forceRefresh: options.forceRefresh,
@@ -4905,7 +7480,7 @@ function requestEvidence(data, number, options) {
     request: options.service === "wsmtxca" ? wsmtxcaRequest(data, number) : data
   } : {};
 }
-async function recoverOperation(select, key, inputOptions, context) {
+async function recoverOperation(select, key, inputOptions, context, read) {
   const options = cloneOptions(inputOptions);
   assertIssueObject(options, "options");
   assertIssueKeys(
@@ -4917,9 +7492,7 @@ async function recoverOperation(select, key, inputOptions, context) {
   validateKeyStore({ ...options, idempotencyKey: key }, context);
   const scope = keyScope(context, key);
   const { store, environment, taxId } = scope;
-  const json = await storeCall(
-    () => store.get(attemptKey(environment, taxId, key))
-  );
+  const json = read === void 0 ? await storeCall(() => store.get(attemptKey(environment, taxId, key))) : read;
   if (json === null) {
     throw new ArcaInputError("No reservation exists for this idempotency key", {
       code: "ARCA_INPUT_RESERVATION_NOT_FOUND",
@@ -4944,7 +7517,7 @@ async function recoverOperation(select, key, inputOptions, context) {
       return await recordConflict(
         store,
         settledKey(environment, taxId, key),
-        await consultReservation(select, current, options, taxId, rejected),
+        await consultReservation2(select, current, options, taxId, rejected),
         !rejected || store.withLock !== void 0
       );
     }
@@ -4961,7 +7534,7 @@ function keyScope(context, idempotencyKey) {
     idempotencyKey
   };
 }
-function consultReservation(select, record, options, taxId, strangerAtNumber = false) {
+function consultReservation2(select, record, options, taxId, strangerAtNumber = false) {
   const storedOptions = {
     ...options,
     service: record.service ?? "wsfe",
@@ -4987,7 +7560,7 @@ function consultReservation(select, record, options, taxId, strangerAtNumber = f
       record.number,
       storedOptions
     ),
-    voucher: (cae, caeExpiry, lookup) => issuedVoucher(
+    voucher: (cae, caeExpiry, lookup) => issuedVoucher2(
       {
         attempted,
         voucherClass: prepared.voucherClass,
@@ -5004,7 +7577,7 @@ function consultReservation(select, record, options, taxId, strangerAtNumber = f
 function issuerTaxId(options, context) {
   return options.representedTaxId === void 0 ? context?.taxId : String(options.representedTaxId);
 }
-function issuedVoucher({
+function issuedVoucher2({
   attempted,
   voucherClass,
   data,
@@ -5100,8 +7673,8 @@ async function runSequenceBarrier({
     return {};
   }
   const owner = claimed.issuerTaxId ?? taxId;
-  const settled = settledKey(environment, owner, claimed.key);
-  if (await storeCall(() => store.get(settled)) !== null) {
+  const settled2 = settledKey(environment, owner, claimed.key);
+  if (await storeCall(() => store.get(settled2)) !== null) {
     return {};
   }
   const reservation = await storeCall(
@@ -5123,8 +7696,8 @@ async function runSequenceBarrier({
   };
   const outcome = await recordConflict(
     store,
-    settled,
-    await consultReservation(
+    settled2,
+    await consultReservation2(
       select,
       // This call's certificate may not be the one that claimed. Without a
       // represented CUIT, it would read its own numbering instead of the one
@@ -5155,7 +7728,7 @@ async function runSequenceBarrier({
   }
   await storeCall(
     () => store.add(
-      settled,
+      settled2,
       JSON.stringify({
         v: 1,
         kind: "superseded",
@@ -5385,7 +7958,7 @@ function createArcaClient(config = {}) {
     );
   }
   const logger = createArcaLogger(normalizedConfig.logger);
-  const auth = createWsaaAuthModule({ config: normalizedConfig, logger });
+  const auth2 = createWsaaAuthModule({ config: normalizedConfig, logger });
   const soap = createSoapTransport({ config: normalizedConfig, logger });
   const publicConfig = Object.freeze({
     taxId: normalizedConfig.taxId,
@@ -5394,13 +7967,19 @@ function createArcaClient(config = {}) {
     retries: normalizedConfig.retries,
     retryDelay: normalizedConfig.retryDelay
   });
-  const wsfe = createWsfeService({ config: normalizedConfig, auth, soap });
+  const wsfe = createWsfeService({ config: normalizedConfig, auth: auth2, soap });
   const wsmtxca = createWsmtxcaService({
     config: normalizedConfig,
-    auth,
+    auth: auth2,
     soap
   });
-  const vouchers = createVouchersService(wsfe, normalizedConfig, wsmtxca);
+  const wsfex = createWsfexService({ config: normalizedConfig, auth: auth2, soap });
+  const vouchers = createVouchersService(
+    wsfe,
+    normalizedConfig,
+    wsmtxca,
+    wsfex
+  );
   return {
     config: publicConfig,
     issue: vouchers.issue,
@@ -5413,8 +7992,9 @@ function createArcaClient(config = {}) {
     lookup: vouchers.lookup,
     lastAuthorized: vouchers.lastAuthorized,
     wsfe,
+    wsfex,
     wsmtxca,
-    padron: createPadronService({ config: normalizedConfig, auth, soap })
+    padron: createPadronService({ config: normalizedConfig, auth: auth2, soap })
   };
 }
 
@@ -5432,71 +8012,6 @@ import {
   writeFile
 } from "fs/promises";
 import { join } from "path";
-
-// src/store/lock.ts
-import { randomUUID } from "crypto";
-var ARCA_LEASE_MS = 6e4;
-var RENEW_MS = 2e4;
-var POLL_MS = 50;
-var MAX_WAIT_MS = 2 * ARCA_LEASE_MS;
-async function withLease(key, driver, fn, { signal } = {}) {
-  const owner = randomUUID();
-  const deadline = Date.now() + MAX_WAIT_MS;
-  throwIfAborted(key, signal);
-  let held = await driver.acquire(owner);
-  while (!held) {
-    if (Date.now() >= deadline) {
-      throw new ArcaLockTimeoutError(
-        `ARCA store lock ${key} stayed held; no work was attempted.`,
-        { reason: "held" }
-      );
-    }
-    await delay2(POLL_MS + Math.floor(Math.random() * POLL_MS), signal);
-    throwIfAborted(key, signal);
-    held = await driver.acquire(owner);
-  }
-  if (signal?.aborted) {
-    await driver.release(owner).catch(() => void 0);
-    throwIfAborted(key, signal);
-  }
-  const renewal = setInterval(() => {
-    driver.renew(owner).catch(() => void 0);
-  }, RENEW_MS);
-  renewal.unref?.();
-  try {
-    return await fn();
-  } finally {
-    clearInterval(renewal);
-    await driver.release(owner).catch(() => void 0);
-  }
-}
-function throwIfAborted(key, signal) {
-  if (signal?.aborted) {
-    throw new ArcaLockTimeoutError(
-      `Stopped waiting for ARCA store lock ${key}: the caller's signal aborted; no work was attempted.`,
-      { reason: "aborted", cause: signal.reason }
-    );
-  }
-}
-function delay2(ms, signal) {
-  if (signal?.aborted) {
-    return Promise.resolve();
-  }
-  return new Promise((resolve) => {
-    const wake = () => {
-      clearTimeout(timer);
-      resolve();
-    };
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", wake);
-      resolve();
-    }, ms);
-    timer.unref?.();
-    signal?.addEventListener("abort", wake, { once: true });
-  });
-}
-
-// src/store/file.ts
 function createFileStore(directory) {
   const path = (key) => join(directory, createHash3("sha256").update(key).digest("hex"));
   const ensure = () => mkdir(directory, { recursive: true, mode: 448 });
@@ -5545,7 +8060,7 @@ function createFileStore(directory) {
     withLock: (key, fn, options) => (
       // A lock directory: mkdir is the atomic claim on every POSIX filesystem
       // and on Windows, and the holder file inside carries the lease.
-      withLease(key, fileLease(`${path(key)}.lock`, ensure), fn, options)
+      withLease(fileLease(`${path(key)}.lock`, ensure), fn, options)
     )
   };
 }
@@ -5716,19 +8231,20 @@ export {
   discoverArcaClientConfig,
   storeCall,
   describeVoucherType,
+  ARCA_LEASE_MS,
+  withLease,
+  throwIfAborted,
   ARCA_QR_URL,
   arcaQrUrl,
   arcaQrPayload,
   voucherDateWindow,
+  createWsfexService,
   matchWsfeVoucherIdentity,
   abortable,
   createMemoryWsaaSessionStore,
   createWsaaAuthModule,
   createWsaaStoreAdapter,
   createArcaClient,
-  ARCA_LEASE_MS,
-  withLease,
-  throwIfAborted,
   createFileStore
 };
-//# sourceMappingURL=chunk-WEEV76IC.mjs.map
+//# sourceMappingURL=chunk-R4MOVPYT.mjs.map