facturas 0.9.0 → 0.11.0

package/dist/chunk-LOWV7IF6.mjs

@@ -0,0 +1,3758 @@
+import {
+  createPadronService
+} from "./chunk-7LEKQ4P7.mjs";
+import {
+  arcaMinorUnitsToNumber,
+  assertArcaMinorUnits,
+  calculateWsfeAmounts,
+  createWsfeService,
+  isWithinArcaTolerance,
+  normalizeArcaAmountToMinorUnits,
+  normalizeWsfeDateInput,
+  normalizeWsfeVoucherInput,
+  serializeArcaExchangeRate
+} from "./chunk-5KCTRQJX.mjs";
+import {
+  ARCA_CURRENCY_IDS,
+  ARCA_DOCUMENT_TYPES,
+  ARCA_FINAL_CONSUMER_IDENTIFICATION_THRESHOLD_MINOR_UNITS,
+  ARCA_INVOICE_CLASS_BY_ISSUER,
+  ARCA_ISSUER_CONDITION_IDS,
+  ARCA_RECEIVER_CONDITION_IDS,
+  ARCA_VOUCHER_TYPES
+} from "./chunk-GX5ERXT6.mjs";
+import {
+  createWsmtxcaService
+} from "./chunk-ALH5IPSY.mjs";
+import {
+  ArcaConfigurationError,
+  ArcaError,
+  ArcaInputError,
+  ArcaInvalidSoapResponseError,
+  ArcaServiceError,
+  ArcaSoapFaultError,
+  ArcaTransportError,
+  createResponseBodyDiagnostic,
+  createSafeErrorDiagnostic,
+  toArcaSafeErrorMetadata
+} from "./chunk-ZOSNASXB.mjs";
+
+// src/config.ts
+var ARCA_ENVIRONMENTS = ["production", "test"];
+var ARCA_ENV_VARIABLES = {
+  taxId: "ARCA_TAX_ID",
+  certificatePem: "ARCA_CERTIFICATE_PEM",
+  privateKeyPem: "ARCA_PRIVATE_KEY_PEM",
+  environment: "ARCA_ENVIRONMENT"
+};
+var PRIVATE_KEY_PEM_PREFIXES = [
+  "-----BEGIN PRIVATE KEY-----",
+  "-----BEGIN RSA PRIVATE KEY-----"
+];
+var ENCRYPTED_PRIVATE_KEY_PEM_PREFIX = "-----BEGIN ENCRYPTED PRIVATE KEY-----";
+var LEGACY_ENCRYPTED_RSA_PRIVATE_KEY_PATTERN = /^-----BEGIN RSA PRIVATE KEY-----[\s\S]*^Proc-Type:\s*4,\s*ENCRYPTED\s*$/m;
+var VALID_ARCA_LOG_LEVELS = ["debug", "info", "warn", "error"];
+var DEFAULT_ARCA_TIMEOUT_MS = 3e4;
+var DEFAULT_ARCA_RETRIES = 0;
+var DEFAULT_ARCA_RETRY_DELAY_MS = 500;
+function resolveArcaEnvironment(production) {
+  return production ? "production" : "test";
+}
+function createArcaClientConfigFromEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const variableNames = {
+    ...ARCA_ENV_VARIABLES,
+    ...options.variableNames
+  };
+  const environmentInput = readEnv(env, variableNames.environment);
+  const environmentValue = normalizeEnvironmentValue(environmentInput);
+  const config = {
+    taxId: readEnv(env, variableNames.taxId) ?? "",
+    certificatePem: readEnv(env, variableNames.certificatePem) ?? "",
+    privateKeyPem: readEnv(env, variableNames.privateKeyPem) ?? "",
+    environment: environmentValue ?? environmentInput ?? options.defaultEnvironment ?? "test"
+  };
+  assertArcaClientConfig(config);
+  return normalizeArcaClientConfig(config);
+}
+function assertArcaClientConfig(config) {
+  const invalidFields = [];
+  const normalized = normalizeArcaClientConfig(config);
+  const timeout = normalized.timeout ?? DEFAULT_ARCA_TIMEOUT_MS;
+  const retries = normalized.retries ?? DEFAULT_ARCA_RETRIES;
+  const retryDelay = normalized.retryDelay ?? DEFAULT_ARCA_RETRY_DELAY_MS;
+  if (normalized.privateKeyPem.startsWith(ENCRYPTED_PRIVATE_KEY_PEM_PREFIX) || LEGACY_ENCRYPTED_RSA_PRIVATE_KEY_PATTERN.test(normalized.privateKeyPem)) {
+    throw new ArcaConfigurationError(
+      "Encrypted private keys are not supported. Provide an unencrypted PKCS#8 or RSA private key PEM."
+    );
+  }
+  invalidFields.push(...invalidCredentialFields(normalized));
+  if (!ARCA_ENVIRONMENTS.includes(normalized.environment)) {
+    invalidFields.push("environment");
+  }
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    invalidFields.push("timeout");
+  }
+  if (!Number.isInteger(retries) || retries < 0) {
+    invalidFields.push("retries");
+  }
+  if (!Number.isFinite(retryDelay) || retryDelay < 0) {
+    invalidFields.push("retryDelay");
+  }
+  const loggerLevel = normalized.logger?.level;
+  if (loggerLevel !== void 0 && !VALID_ARCA_LOG_LEVELS.includes(loggerLevel)) {
+    invalidFields.push("logger.level");
+  }
+  if (normalized.logger?.log !== void 0 && typeof normalized.logger.log !== "function") {
+    invalidFields.push("logger.log");
+  }
+  invalidFields.push(...getInvalidWsaaSessionStoreFields(normalized));
+  if (invalidFields.length > 0) {
+    throw new ArcaConfigurationError(
+      `Missing or invalid ARCA client config fields: ${invalidFields.join(", ")}`
+    );
+  }
+}
+function getInvalidWsaaSessionStoreFields(config) {
+  const store = config.wsaaSessionStore;
+  if (store === void 0) {
+    return [];
+  }
+  const invalidFields = [];
+  if (typeof store.get !== "function") {
+    invalidFields.push("wsaaSessionStore.get");
+  }
+  if (typeof store.set !== "function") {
+    invalidFields.push("wsaaSessionStore.set");
+  }
+  if (store.delete !== void 0 && typeof store.delete !== "function") {
+    invalidFields.push("wsaaSessionStore.delete");
+  }
+  if (store.withLock !== void 0 && typeof store.withLock !== "function") {
+    invalidFields.push("wsaaSessionStore.withLock");
+  }
+  return invalidFields;
+}
+var ARCA_WSAA_CONFIG = {
+  namespace: "http://wsaa.view.sua.dvadac.desein.afip.gov",
+  endpoint: {
+    production: "https://wsaa.afip.gov.ar/ws/services/LoginCms",
+    test: "https://wsaahomo.afip.gov.ar/ws/services/LoginCms"
+  },
+  soapVersion: "1.1",
+  soapActionBase: "",
+  usesEmptySoapAction: true
+};
+var ARCA_SERVICE_CONFIG = {
+  wsaa: ARCA_WSAA_CONFIG,
+  wsfe: {
+    namespace: "http://ar.gov.afip.dif.FEV1/",
+    endpoint: {
+      production: "https://servicios1.afip.gov.ar/wsfev1/service.asmx",
+      test: "https://wswhomo.afip.gov.ar/wsfev1/service.asmx"
+    },
+    soapVersion: "1.2",
+    soapActionBase: "http://ar.gov.afip.dif.FEV1/",
+    useLegacyTlsSecurityLevel0: true
+  },
+  wsmtxca: {
+    namespace: "http://impl.service.wsmtxca.afip.gov.ar/service/",
+    endpoint: {
+      production: "https://serviciosjava.afip.gov.ar/wsmtxca/services/MTXCAService",
+      test: "https://fwshomo.afip.gov.ar/wsmtxca/services/MTXCAService"
+    },
+    soapVersion: "1.1",
+    soapActionBase: "http://impl.service.wsmtxca.afip.gov.ar/service/"
+  },
+  "padron-a5": {
+    namespace: "http://a5.soap.ws.server.puc.sr/",
+    endpoint: {
+      production: "https://aws.afip.gov.ar/sr-padron/webservices/personaServiceA5",
+      test: "https://awshomo.afip.gov.ar/sr-padron/webservices/personaServiceA5"
+    },
+    soapVersion: "1.1",
+    soapActionBase: "",
+    usesEmptySoapAction: true
+  },
+  "padron-a13": {
+    namespace: "http://a13.soap.ws.server.puc.sr/",
+    endpoint: {
+      production: "https://aws.afip.gov.ar/sr-padron/webservices/personaServiceA13",
+      test: "https://awshomo.afip.gov.ar/sr-padron/webservices/personaServiceA13"
+    },
+    soapVersion: "1.1",
+    soapActionBase: "",
+    usesEmptySoapAction: true
+  }
+};
+function getArcaServiceConfig(service) {
+  const serviceConfig = ARCA_SERVICE_CONFIG[service];
+  if (!serviceConfig) {
+    throw new ArcaConfigurationError(
+      `Unsupported ARCA service configuration: ${service}`
+    );
+  }
+  return serviceConfig;
+}
+function normalizeArcaClientConfig(config) {
+  const normalizedEnvironment = normalizeEnvironmentValue(String(config.environment)) ?? config.environment;
+  const normalizedLoggerLevel = normalizeLogLevelValue(config.logger?.level);
+  return {
+    taxId: config.taxId?.trim() ?? "",
+    certificatePem: config.certificatePem?.trim() ?? "",
+    privateKeyPem: config.privateKeyPem?.trim() ?? "",
+    environment: normalizedEnvironment ?? "test",
+    ...config.store === void 0 ? {} : { store: config.store },
+    timeout: config.timeout ?? DEFAULT_ARCA_TIMEOUT_MS,
+    retries: config.retries ?? DEFAULT_ARCA_RETRIES,
+    retryDelay: config.retryDelay ?? DEFAULT_ARCA_RETRY_DELAY_MS,
+    ...config.logger === void 0 ? {} : {
+      logger: {
+        ...config.logger,
+        ...normalizedLoggerLevel === void 0 ? {} : { level: normalizedLoggerLevel }
+      }
+    },
+    ...config.wsaaSessionStore === void 0 ? {} : { wsaaSessionStore: config.wsaaSessionStore }
+  };
+}
+function normalizeEnvironmentValue(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (ARCA_ENVIRONMENTS.includes(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+function readEnv(env, variableName) {
+  return env[variableName]?.trim() || void 0;
+}
+function normalizeLogLevelValue(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (VALID_ARCA_LOG_LEVELS.includes(normalized)) {
+    return normalized;
+  }
+  return value;
+}
+function discoverArcaClientConfig(config) {
+  const environment = config.environment ?? readEnv(process.env, ARCA_ENV_VARIABLES.environment);
+  if (environment === void 0) {
+    throw new ArcaConfigurationError(
+      `environment is required: pass environment or set ${ARCA_ENV_VARIABLES.environment} to "test" or "production".`
+    );
+  }
+  return {
+    ...config,
+    taxId: config.taxId ?? readEnv(process.env, ARCA_ENV_VARIABLES.taxId) ?? "",
+    certificatePem: config.certificatePem ?? readEnv(process.env, ARCA_ENV_VARIABLES.certificatePem) ?? "",
+    privateKeyPem: config.privateKeyPem ?? readEnv(process.env, ARCA_ENV_VARIABLES.privateKeyPem) ?? "",
+    environment
+  };
+}
+function invalidCredentialFields(normalized) {
+  const invalidFields = [];
+  if (!/^\d{11}$/.test(normalized.taxId)) {
+    invalidFields.push(normalized.taxId ? "taxId" : "taxId (ARCA_TAX_ID)");
+  }
+  if (!normalized.certificatePem.startsWith("-----BEGIN CERTIFICATE-----")) {
+    invalidFields.push(
+      normalized.certificatePem ? "certificatePem" : "certificatePem (ARCA_CERTIFICATE_PEM)"
+    );
+  }
+  if (!PRIVATE_KEY_PEM_PREFIXES.some(
+    (prefix) => normalized.privateKeyPem.startsWith(prefix)
+  )) {
+    invalidFields.push(
+      normalized.privateKeyPem ? "privateKeyPem" : "privateKeyPem (ARCA_PRIVATE_KEY_PEM)"
+    );
+  }
+  return invalidFields;
+}
+
+// src/store/types.ts
+import { createHash } from "crypto";
+function attemptKey(environment, taxId, key) {
+  return `arca:v1:attempt:${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")
+    ],
+    ["concept", sent.concept, found.concept],
+    ["documentType", sent.documentType, found.documentType],
+    [
+      "documentNumber",
+      sent.documentNumber,
+      found.documentNumber,
+      normalizeDocument
+    ],
+    [
+      "receiverVatConditionId",
+      sent.receiverVatConditionId,
+      found.receiverVatConditionId
+    ],
+    ["currencyId", sent.currencyId, found.currencyId],
+    [
+      "exchangeRate",
+      sent.exchangeRate ?? (sent.currencyId === "PES" ? 1 : void 0),
+      found.exchangeRate,
+      (value) => serializeArcaExchangeRate(value, "exchangeRate")
+    ]
+  ];
+  for (const field of [
+    "totalAmount",
+    "netAmount",
+    "vatAmount",
+    "exemptAmount",
+    "nonTaxableAmount",
+    "taxAmount"
+  ]) {
+    checks.push([
+      field,
+      sent[field],
+      found[field],
+      (value) => normalizeArcaAmountToMinorUnits(value, field)
+    ]);
+  }
+  if (sent.concept === 2 || sent.concept === 3) {
+    for (const field of [
+      "serviceStartDate",
+      "serviceEndDate",
+      "paymentDueDate"
+    ]) {
+      checks.push([
+        field,
+        sent[field],
+        found[field],
+        (value) => normalizeWsfeDateInput(value, field)
+      ]);
+    }
+  }
+  if (sent.concept === 1 && sent.paymentDueDate) {
+    checks.push([
+      "paymentDueDate",
+      sent.paymentDueDate,
+      found.paymentDueDate,
+      (value) => normalizeWsfeDateInput(value, "paymentDueDate")
+    ]);
+  }
+  for (const check of checks) {
+    const result = compare(...check);
+    if (result) {
+      return result;
+    }
+  }
+  const detailMatch = compareDetails(sent, found);
+  if (!detailMatch.matches) {
+    if (detailMatch.evidence === "conflict") {
+      return detailMatch;
+    }
+    missing ??= detailMatch.reason;
+  }
+  missing ??= incompleteAuthorization(sent, found);
+  return missing ? {
+    matches: false,
+    evidence: "incomplete",
+    reason: `Cannot verify ${missing}`
+  } : { matches: true };
+}
+function incompleteAuthorization(sent, found) {
+  let missing;
+  if (sent.concept !== 1 && sent.concept !== 2 && sent.concept !== 3) {
+    missing ??= "unsupported concept";
+  }
+  if (!(found.result === "A" || found.result === "O")) {
+    missing ??= "authorized result";
+  }
+  if (!found.cae?.trim()) {
+    missing ??= "cae";
+  }
+  if (!found.caeExpiry?.trim()) {
+    missing ??= "caeExpiry";
+  }
+  return missing;
+}
+function normalizeVoucherNumber(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > 99999999) {
+    throw new Error("Invalid voucher number");
+  }
+  return value;
+}
+function normalizeDocument(value) {
+  const text = String(value);
+  if (!/^\d+$/.test(text)) {
+    throw new Error("Invalid document number");
+  }
+  return BigInt(text);
+}
+function compareVatRates(expected, actual) {
+  if (actual === void 0) {
+    return expected.length === 0 ? { matches: true } : { matches: false, evidence: "incomplete", reason: "vatRates" };
+  }
+  if (actual.length !== expected.length || new Set(actual.map((rate) => rate.id)).size !== actual.length) {
+    return {
+      matches: false,
+      evidence: "conflict",
+      reason: "vatRates ids differ from the sent input"
+    };
+  }
+  for (const rate of expected) {
+    const found = actual.find((item) => item.id === rate.id);
+    if (!found) {
+      return {
+        matches: false,
+        evidence: "conflict",
+        reason: `vatRates id ${rate.id} differs from the sent input`
+      };
+    }
+    for (const field of ["baseAmount", "amount"]) {
+      try {
+        if (normalizeArcaAmountToMinorUnits(rate[field], field) !== normalizeArcaAmountToMinorUnits(found[field], field)) {
+          return {
+            matches: false,
+            evidence: "conflict",
+            reason: `vatRates[${rate.id}].${field} differs from the sent input`
+          };
+        }
+      } catch {
+        return {
+          matches: false,
+          evidence: "incomplete",
+          reason: `vatRates[${rate.id}].${field}`
+        };
+      }
+    }
+  }
+  return { matches: true };
+}
+function toVoucherSummary(found) {
+  const summary = { number: found.voucherNumber };
+  for (const field of [
+    "salesPoint",
+    "voucherType",
+    "concept",
+    "documentType",
+    "documentNumber",
+    "receiverVatConditionId",
+    "currencyId",
+    "exchangeRate",
+    "totalAmount",
+    "netAmount",
+    "vatAmount",
+    "exemptAmount",
+    "nonTaxableAmount",
+    "taxAmount",
+    "serviceStartDate",
+    "serviceEndDate",
+    "paymentDueDate",
+    "result",
+    "cae",
+    "caeExpiry"
+  ]) {
+    if (found[field] !== void 0) {
+      Object.assign(summary, { [field]: found[field] });
+    }
+  }
+  if (found.voucherDate !== void 0) {
+    summary.date = found.voucherDate;
+  }
+  if (found.vatRates !== void 0) {
+    summary.vatRates = found.vatRates.map(({ id, baseAmount, amount }) => ({
+      id,
+      baseAmount,
+      amount
+    }));
+  }
+  return summary;
+}
+function compareAssociations(sent, found) {
+  const expected = sent.associatedVouchers ?? [];
+  const actual = found.associatedVouchers;
+  if (!actual) {
+    return expected.length ? { matches: false, evidence: "incomplete", reason: "associatedVouchers" } : { matches: true };
+  }
+  if (expected.length !== actual.length) {
+    return {
+      matches: false,
+      evidence: "conflict",
+      reason: "associatedVouchers count differs"
+    };
+  }
+  for (const association of expected) {
+    const match = actual.find(
+      (v) => v.type === association.type && v.salesPoint === association.salesPoint && v.number === association.number
+    );
+    if (!match) {
+      return {
+        matches: false,
+        evidence: "conflict",
+        reason: "associatedVouchers differ from the sent input"
+      };
+    }
+    const metadata = compareAssociationMetadata(association, match);
+    if (!metadata.matches) {
+      return metadata;
+    }
+  }
+  return { matches: true };
+}
+function compareDetails(sent, found) {
+  let incomplete;
+  for (const result of [
+    compareVatRates(sent.vatRates ?? [], found.vatRates),
+    compareAssociations(sent, found),
+    compareExtensions(sent, found)
+  ]) {
+    if (result.matches) {
+      continue;
+    }
+    if (result.evidence === "conflict") {
+      return result;
+    }
+    incomplete ??= result;
+  }
+  return incomplete ?? { matches: true };
+}
+function extensionIdentity(field, value) {
+  if (Array.isArray(value)) {
+    return canonicalHash(
+      value.map((item) => {
+        if (field === "taxes") {
+          const tax = item;
+          return {
+            id: tax.id,
+            base: String(
+              normalizeArcaAmountToMinorUnits(tax.baseAmount, "base")
+            ),
+            amount: String(
+              normalizeArcaAmountToMinorUnits(tax.amount, "amount")
+            ),
+            rate: Number(tax.rate)
+          };
+        }
+        return item;
+      }).sort((a, b) => canonicalHash(a).localeCompare(canonicalHash(b)))
+    );
+  }
+  if (field === "associatedPeriod" && value) {
+    const period = value;
+    return canonicalHash({
+      start: normalizeWsfeDateInput(period.startDate, "start"),
+      end: normalizeWsfeDateInput(period.endDate, "end")
+    });
+  }
+  return canonicalHash(value ?? null);
+}
+function compareExtensions(sent, found) {
+  let missing;
+  for (const field of [
+    "taxes",
+    "optionalFields",
+    "buyers",
+    "activities",
+    "associatedPeriod",
+    "sameCurrencyForeignCancellation"
+  ]) {
+    const expected = sent[field];
+    const actual = found[field];
+    const empty = (value) => value === void 0 || Array.isArray(value) && value.length === 0;
+    if (empty(expected) && empty(actual)) {
+      continue;
+    }
+    if (actual === void 0) {
+      missing ??= field;
+      continue;
+    }
+    try {
+      if (extensionIdentity(field, expected) !== extensionIdentity(field, actual)) {
+        return {
+          matches: false,
+          evidence: "conflict",
+          reason: `${field} differs from the sent input`
+        };
+      }
+    } catch {
+      missing ??= field;
+    }
+  }
+  return missing ? { matches: false, evidence: "incomplete", reason: missing } : { matches: true };
+}
+function compareAssociationMetadata(association, match) {
+  for (const field of ["taxId", "voucherDate"]) {
+    if (association[field] === void 0) {
+      continue;
+    }
+    if (match[field] === void 0) {
+      return {
+        matches: false,
+        evidence: "incomplete",
+        reason: `associatedVouchers.${field}`
+      };
+    }
+    const normalize = (value) => field === "taxId" ? String(BigInt(value)) : normalizeWsfeDateInput(
+      value,
+      "association.date"
+    );
+    try {
+      if (normalize(association[field]) !== normalize(match[field])) {
+        return {
+          matches: false,
+          evidence: "conflict",
+          reason: `associatedVouchers.${field} differs`
+        };
+      }
+    } catch {
+      return {
+        matches: false,
+        evidence: "incomplete",
+        reason: `associatedVouchers.${field}`
+      };
+    }
+  }
+  return { matches: true };
+}
+
+// src/wsaa/session-store.ts
+var CREDENTIAL_EXPIRY_SAFETY_MARGIN_MS = 6e4;
+function createMemoryWsaaSessionStore() {
+  const sessions = /* @__PURE__ */ new Map();
+  const locks = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const credentials = sessions.get(serializeWsaaSessionKey(key));
+      if (!(credentials && isWsaaCredentialValid(credentials))) {
+        return Promise.resolve(null);
+      }
+      return Promise.resolve({ ...credentials });
+    },
+    set(key, credentials) {
+      sessions.set(serializeWsaaSessionKey(key), { ...credentials });
+      return Promise.resolve();
+    },
+    delete(key) {
+      sessions.delete(serializeWsaaSessionKey(key));
+      return Promise.resolve();
+    },
+    async withLock(key, fn) {
+      const lockKey = serializeWsaaSessionKey(key);
+      const previous = locks.get(lockKey) ?? Promise.resolve();
+      let release = () => void 0;
+      const current = new Promise((resolve) => {
+        release = resolve;
+      });
+      const queued = previous.catch(() => void 0).then(() => current);
+      locks.set(lockKey, queued);
+      await previous.catch(() => void 0);
+      try {
+        return await fn();
+      } finally {
+        release();
+        if (locks.get(lockKey) === queued) {
+          locks.delete(lockKey);
+        }
+      }
+    }
+  };
+}
+function serializeWsaaSessionKey(key) {
+  return [key.environment, key.service, key.certificateFingerprint].join(":");
+}
+function isWsaaCredentialValid(credentials) {
+  return new Date(credentials.expiresAt).getTime() - Date.now() > CREDENTIAL_EXPIRY_SAFETY_MARGIN_MS;
+}
+
+// src/wsaa/index.ts
+import { createHash as createHash2 } from "crypto";
+import forge from "node-forge";
+
+// src/internal/http.ts
+import https from "https";
+var defaultAgent = new https.Agent({
+  keepAlive: true
+});
+var legacyTlsAgent = new https.Agent({
+  keepAlive: true,
+  ciphers: "DEFAULT@SECLEVEL=0"
+});
+async function postXmlWithMetadata({
+  url,
+  body,
+  contentType,
+  soapAction,
+  useLegacyTlsSecurityLevel0 = false,
+  timeout = 3e4,
+  retries = 0,
+  retryDelay = 500,
+  logger,
+  service,
+  operation
+}) {
+  const totalAttempts = retries + 1;
+  for (let attempt = 1; attempt <= totalAttempts; attempt += 1) {
+    try {
+      return await postXmlOnce({
+        url,
+        body,
+        contentType,
+        soapAction,
+        useLegacyTlsSecurityLevel0,
+        timeout
+      });
+    } catch (error) {
+      if (!(error instanceof ArcaTransportError)) {
+        throw error;
+      }
+      if (attempt >= totalAttempts) {
+        logger?.error("ARCA transport request failed", {
+          service,
+          operation,
+          url,
+          attempt,
+          attempts: totalAttempts,
+          ...createSafeErrorDiagnostic(error)
+        });
+        throw error;
+      }
+      const nextAttempt = attempt + 1;
+      logger?.warn(
+        `Retrying ARCA request after transport failure (attempt ${nextAttempt}/${totalAttempts})`,
+        {
+          service,
+          operation,
+          url,
+          attempt: nextAttempt,
+          attempts: totalAttempts,
+          ...createSafeErrorDiagnostic(error)
+        }
+      );
+      await delay(retryDelay);
+    }
+  }
+  throw new ArcaTransportError("ARCA HTTP request exhausted retries");
+}
+async function postXmlOnce({
+  url,
+  body,
+  contentType,
+  soapAction,
+  useLegacyTlsSecurityLevel0,
+  timeout
+}) {
+  const endpoint = new URL(url);
+  const requestBody = Buffer.from(body, "utf8");
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const settleResolve = (response) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(response);
+    };
+    const settleReject = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(error);
+    };
+    const request = https.request(
+      {
+        protocol: endpoint.protocol,
+        hostname: endpoint.hostname,
+        port: endpoint.port || void 0,
+        path: `${endpoint.pathname}${endpoint.search}`,
+        method: "POST",
+        agent: useLegacyTlsSecurityLevel0 ? legacyTlsAgent : defaultAgent,
+        headers: {
+          Accept: "text/xml, application/soap+xml",
+          "Content-Length": requestBody.byteLength,
+          "Content-Type": contentType,
+          ...soapAction === void 0 ? {} : { SOAPAction: `"${soapAction}"` }
+        }
+      },
+      (response) => {
+        const chunks = [];
+        const getResponseBody = () => Buffer.concat(chunks).toString("utf8");
+        response.on("data", (chunk) => {
+          chunks.push(
+            typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk
+          );
+        });
+        response.on("error", (error) => {
+          settleReject(
+            new ArcaTransportError("ARCA HTTP response stream failed", {
+              cause: error,
+              statusCode: response.statusCode,
+              ...createResponseBodyDiagnostic(getResponseBody())
+            })
+          );
+        });
+        response.on("aborted", () => {
+          settleReject(
+            new ArcaTransportError("ARCA HTTP response was aborted", {
+              statusCode: response.statusCode,
+              ...createResponseBodyDiagnostic(getResponseBody())
+            })
+          );
+        });
+        response.on("end", () => {
+          const responseBody = getResponseBody();
+          const statusCode = response.statusCode ?? 500;
+          const responseContentType = Array.isArray(
+            response.headers["content-type"]
+          ) ? response.headers["content-type"].join("; ") : response.headers["content-type"];
+          if (statusCode >= 200 && statusCode < 300) {
+            settleResolve({
+              body: responseBody,
+              statusCode,
+              contentType: responseContentType
+            });
+            return;
+          }
+          if (isXmlLikeResponse(responseBody, responseContentType)) {
+            settleResolve({
+              body: responseBody,
+              statusCode,
+              contentType: responseContentType
+            });
+            return;
+          }
+          settleReject(
+            new ArcaTransportError(
+              `ARCA HTTP request failed with status ${statusCode}`,
+              {
+                statusCode,
+                contentType: responseContentType,
+                ...createResponseBodyDiagnostic(responseBody)
+              }
+            )
+          );
+        });
+      }
+    );
+    request.setTimeout(timeout, () => {
+      const timeoutCause = new Error(
+        `ARCA HTTP request timed out after ${timeout}ms`
+      );
+      settleReject(
+        new ArcaTransportError(
+          `ARCA HTTP request timed out after ${timeout}ms`,
+          { cause: timeoutCause }
+        )
+      );
+      request.destroy(timeoutCause);
+    });
+    request.on("error", (error) => {
+      settleReject(
+        new ArcaTransportError("ARCA HTTP request failed", {
+          cause: error
+        })
+      );
+    });
+    request.write(requestBody);
+    request.end();
+  });
+}
+function isXmlLikeResponse(body, contentType) {
+  const normalizedContentType = contentType?.toLowerCase() ?? "";
+  if (normalizedContentType.includes("xml") || normalizedContentType.includes("soap")) {
+    return true;
+  }
+  return body.trimStart().startsWith("<");
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// src/internal/xml.ts
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+var xmlBuilder = new XMLBuilder({
+  attributeNamePrefix: "@_",
+  format: false,
+  ignoreAttributes: false,
+  suppressBooleanAttributes: false,
+  suppressEmptyNode: true
+});
+var xmlParser = new XMLParser({
+  attributeNamePrefix: "@_",
+  ignoreAttributes: false,
+  parseAttributeValue: false,
+  parseTagValue: false,
+  removeNSPrefix: true,
+  trimValues: true
+});
+function buildSoapEnvelope(soapVersion, operation, namespace, body, options) {
+  const prefix = soapVersion === "1.2" ? "soap12" : "soap";
+  const envelopeNamespace = soapVersion === "1.2" ? "http://www.w3.org/2003/05/soap-envelope" : "http://schemas.xmlsoap.org/soap/envelope/";
+  const namespaceMode = options?.namespaceMode ?? "default";
+  const operationElementName = namespaceMode === "prefix" ? `tns:${operation}` : operation;
+  const operationNamespaceAttributes = namespaceMode === "prefix" ? { "@_xmlns:tns": namespace } : { "@_xmlns": namespace };
+  const payload = {
+    [`${prefix}:Envelope`]: {
+      "@_xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+      "@_xmlns:xsd": "http://www.w3.org/2001/XMLSchema",
+      [`@_xmlns:${prefix}`]: envelopeNamespace,
+      [`${prefix}:Body`]: {
+        [operationElementName]: {
+          ...operationNamespaceAttributes,
+          ...pruneUndefinedDeep(body)
+        }
+      }
+    }
+  };
+  return `<?xml version="1.0" encoding="utf-8"?>${xmlBuilder.build(payload)}`;
+}
+function parseSoapBody(xml, context = {}) {
+  let parsed;
+  try {
+    parsed = xmlParser.parse(xml);
+  } catch (error) {
+    throw createInvalidSoapResponseError(
+      "Invalid SOAP response: XML parse failed",
+      context,
+      error instanceof Error ? error : void 0
+    );
+  }
+  const envelope = parsed.Envelope;
+  const body = envelope?.Body;
+  if (!body) {
+    throw createInvalidSoapResponseError(
+      "Invalid SOAP response: missing body",
+      context
+    );
+  }
+  const fault = body.Fault;
+  if (fault) {
+    throw createSoapFaultError(fault);
+  }
+  return body;
+}
+function getSingleBodyEntry(body, context = {}) {
+  const entries = Object.entries(body).filter(([key]) => key !== "@_xmlns");
+  if (entries.length !== 1) {
+    throw createInvalidSoapResponseError(
+      `Invalid SOAP response: expected a single body entry, got ${entries.length}`,
+      context
+    );
+  }
+  return entries[0];
+}
+function createInvalidSoapResponseError(message, context, cause) {
+  const responseBody = context.responseBody ?? "";
+  return new ArcaInvalidSoapResponseError(message, {
+    cause,
+    service: context.service,
+    operation: context.operation,
+    endpointUrl: context.endpointUrl,
+    statusCode: context.statusCode,
+    contentType: context.contentType,
+    ...createResponseBodyDiagnostic(
+      responseBody,
+      context.responseBodyPreviewLength
+    )
+  });
+}
+function parseXmlDocument(xml) {
+  return xmlParser.parse(xml);
+}
+function pruneUndefinedDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => pruneUndefinedDeep(item)).filter((item) => item !== void 0);
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, nestedValue]) => nestedValue !== void 0).map(([key, nestedValue]) => [key, pruneUndefinedDeep(nestedValue)]);
+    return Object.fromEntries(entries);
+  }
+  return value;
+}
+function createSoapFaultError(fault) {
+  const faultCode = typeof fault.faultcode === "string" ? fault.faultcode : getNestedString(fault, ["Code", "Value"]);
+  const message = typeof fault.faultstring === "string" ? fault.faultstring : getNestedString(fault, ["Reason", "Text"]) ?? "ARCA SOAP fault response";
+  return new ArcaSoapFaultError(message, {
+    faultCode: faultCode ?? void 0
+  });
+}
+function getNestedString(value, path) {
+  let current = value;
+  for (const key of path) {
+    if (!current || typeof current !== "object") {
+      return null;
+    }
+    current = current[key];
+  }
+  return typeof current === "string" ? current : null;
+}
+
+// src/wsaa/index.ts
+function createWsaaAuthModule(options) {
+  const cache = /* @__PURE__ */ new Map();
+  const ordinaryInFlight = /* @__PURE__ */ new Map();
+  const forcedInFlight = /* @__PURE__ */ new Map();
+  function trackLogin(target, cacheKey, login) {
+    const promise = login();
+    target.set(cacheKey, promise);
+    const cleanup = () => {
+      if (target.get(cacheKey) === promise) {
+        target.delete(cacheKey);
+      }
+    };
+    promise.then(cleanup, cleanup);
+    return promise;
+  }
+  async function requestOrReuseWsaaCredentials(service, sessionKey, cacheKey, forceRefresh) {
+    const reuse = await getReusableCredentials({
+      config: options.config,
+      cache,
+      cacheKey,
+      sessionKey,
+      logger: options.logger,
+      service,
+      allowStore: !forceRefresh,
+      allowCache: !forceRefresh
+    });
+    if (reuse) {
+      return reuse;
+    }
+    const refresh = () => refreshWsaaCredentials({
+      config: options.config,
+      cache,
+      cacheKey,
+      sessionKey,
+      logger: options.logger,
+      service,
+      forceRefresh
+    });
+    if (options.config.wsaaSessionStore?.withLock) {
+      return await withWsaaSessionStoreLock(
+        options.config,
+        sessionKey,
+        service,
+        refresh
+      );
+    }
+    return await refresh();
+  }
+  async function performLogin(service, sessionKey, cacheKey, forceRefresh) {
+    try {
+      return await requestOrReuseWsaaCredentials(
+        service,
+        sessionKey,
+        cacheKey,
+        forceRefresh
+      );
+    } catch (error) {
+      if (error instanceof ArcaSoapFaultError && error.faultCode === "ns1:coe.alreadyAuthenticated") {
+        const recovered = await getReusableCredentials({
+          config: options.config,
+          cache,
+          cacheKey,
+          sessionKey,
+          logger: options.logger,
+          service,
+          allowStore: true,
+          allowCache: true
+        });
+        if (recovered) {
+          options.logger?.warn(
+            "Recovered WSAA coe.alreadyAuthenticated fault",
+            {
+              service,
+              faultCode: error.faultCode
+            }
+          );
+          return recovered;
+        }
+        if (!options.config.wsaaSessionStore) {
+          throw new ArcaConfigurationError(
+            "WSAA login failed because another process likely owns a valid TA. Configure a durable wsaaSessionStore for multi-process or serverless deployments.",
+            { cause: error }
+          );
+        }
+      }
+      if (error instanceof ArcaSoapFaultError) {
+        options.logger?.error("WSAA SOAP fault response", {
+          service,
+          operation: "loginCms",
+          url: ARCA_WSAA_CONFIG.endpoint[options.config.environment],
+          ...createSafeErrorDiagnostic(error)
+        });
+      }
+      throw error;
+    }
+  }
+  return {
+    login(service, authOptions = {}) {
+      const sessionKey = buildWsaaSessionKey(options.config, service);
+      const cacheKey = serializeWsaaSessionKey(sessionKey);
+      if (authOptions.forceRefresh) {
+        const runningForced2 = forcedInFlight.get(cacheKey);
+        if (runningForced2) {
+          return runningForced2;
+        }
+        const runningOrdinary2 = ordinaryInFlight.get(cacheKey);
+        return trackLogin(forcedInFlight, cacheKey, async () => {
+          await runningOrdinary2?.catch(() => void 0);
+          return await performLogin(service, sessionKey, cacheKey, true);
+        });
+      }
+      const runningOrdinary = ordinaryInFlight.get(cacheKey);
+      if (runningOrdinary) {
+        return runningOrdinary;
+      }
+      const runningForced = forcedInFlight.get(cacheKey);
+      if (runningForced) {
+        return runningForced;
+      }
+      return trackLogin(
+        ordinaryInFlight,
+        cacheKey,
+        () => performLogin(service, sessionKey, cacheKey, false)
+      );
+    }
+  };
+}
+async function requestCredentials(config, service, options) {
+  const loginTicketRequestXml = buildLoginTicketRequest(service);
+  const signedCms = signLoginTicketRequest(loginTicketRequestXml, {
+    certificatePem: config.certificatePem,
+    privateKeyPem: config.privateKeyPem
+  });
+  const requestXml = buildSoapEnvelope(
+    ARCA_WSAA_CONFIG.soapVersion,
+    "loginCms",
+    ARCA_WSAA_CONFIG.namespace,
+    { in0: signedCms }
+  );
+  const url = ARCA_WSAA_CONFIG.endpoint[config.environment];
+  const response = await postXmlWithMetadata({
+    url: ARCA_WSAA_CONFIG.endpoint[config.environment],
+    body: requestXml,
+    contentType: 'text/xml; charset="utf-8"',
+    soapAction: ARCA_WSAA_CONFIG.soapActionBase,
+    timeout: config.timeout,
+    retries: config.retries,
+    retryDelay: config.retryDelay,
+    logger: options?.logger,
+    service: "wsaa",
+    operation: "loginCms"
+  });
+  const parseContext = {
+    service: "wsaa",
+    operation: "loginCms",
+    endpointUrl: url,
+    statusCode: response.statusCode,
+    contentType: response.contentType,
+    responseBody: response.body
+  };
+  const soapBody = parseSoapBody(response.body, parseContext);
+  const [, responseBody] = getSingleBodyEntry(
+    soapBody,
+    parseContext
+  );
+  const loginCmsReturn = responseBody.loginCmsReturn;
+  if (typeof loginCmsReturn !== "string" || loginCmsReturn.trim().length < 1) {
+    throw new ArcaTransportError(
+      "WSAA response did not include loginCmsReturn XML"
+    );
+  }
+  return parseLoginTicketResponse(loginCmsReturn);
+}
+function buildWsaaSessionKey(config, service) {
+  return {
+    environment: config.environment,
+    service,
+    certificateFingerprint: getCertificateFingerprint(config)
+  };
+}
+function getCertificateFingerprint(config) {
+  return createHash2("sha256").update(config.certificatePem).digest("hex");
+}
+function getCachedCredentials(cache, cacheKey) {
+  const localCached = cache.get(cacheKey);
+  if (localCached && isWsaaCredentialValid(localCached)) {
+    return localCached;
+  }
+  return null;
+}
+async function getReusableCredentials(options) {
+  if (options.allowCache) {
+    const cached = getCachedCredentials(options.cache, options.cacheKey);
+    if (cached) {
+      options.logger?.debug("Attempting WSAA login", {
+        service: options.service,
+        source: "cached"
+      });
+      return cached;
+    }
+  }
+  if (!(options.allowStore && options.config.wsaaSessionStore)) {
+    return null;
+  }
+  const stored = await getStoredCredentials(
+    options.config,
+    options.sessionKey,
+    options.service
+  );
+  if (!stored) {
+    return null;
+  }
+  options.cache.set(options.cacheKey, stored);
+  options.logger?.debug("Attempting WSAA login", {
+    service: options.service,
+    source: "store"
+  });
+  return stored;
+}
+async function refreshWsaaCredentials(options) {
+  if (!options.forceRefresh) {
+    const reuse = await getReusableCredentials({
+      config: options.config,
+      cache: options.cache,
+      cacheKey: options.cacheKey,
+      sessionKey: options.sessionKey,
+      logger: options.logger,
+      service: options.service,
+      allowStore: true,
+      allowCache: true
+    });
+    if (reuse) {
+      return reuse;
+    }
+  }
+  options.logger?.debug("Attempting WSAA login", {
+    service: options.service,
+    source: "fresh"
+  });
+  const credentials = await requestCredentials(
+    options.config,
+    options.service,
+    {
+      logger: options.logger
+    }
+  );
+  options.logger?.info("WSAA login succeeded", {
+    service: options.service,
+    expiresAt: credentials.expiresAt
+  });
+  options.cache.set(options.cacheKey, credentials);
+  await setStoredCredentials(options.config, options.sessionKey, credentials);
+  return credentials;
+}
+async function getStoredCredentials(config, key, service) {
+  if (!config.wsaaSessionStore) {
+    return null;
+  }
+  try {
+    const credentials = await config.wsaaSessionStore.get(key);
+    if (!(credentials && isWsaaCredentialValid(credentials))) {
+      return null;
+    }
+    return credentials;
+  } catch (error) {
+    throw new ArcaConfigurationError(
+      `WSAA session store get failed for service ${service}`,
+      { cause: error instanceof Error ? error : void 0 }
+    );
+  }
+}
+async function setStoredCredentials(config, key, credentials) {
+  if (!config.wsaaSessionStore) {
+    return;
+  }
+  try {
+    await config.wsaaSessionStore.set(key, credentials);
+  } catch (error) {
+    throw new ArcaConfigurationError(
+      `WSAA session store set failed for service ${key.service}`,
+      { cause: error instanceof Error ? error : void 0 }
+    );
+  }
+}
+async function withWsaaSessionStoreLock(config, key, service, fn) {
+  const store = config.wsaaSessionStore;
+  if (!store?.withLock) {
+    return await fn();
+  }
+  let entered = false;
+  try {
+    return await store.withLock(key, async () => {
+      entered = true;
+      return await fn();
+    });
+  } catch (error) {
+    if (entered) {
+      throw error;
+    }
+    if (error instanceof ArcaConfigurationError) {
+      throw error;
+    }
+    throw new ArcaConfigurationError(
+      `WSAA session store lock failed for service ${service}`,
+      { cause: error instanceof Error ? error : void 0 }
+    );
+  }
+}
+function buildLoginTicketRequest(service) {
+  const uniqueId = Math.floor(Date.now() / 1e3);
+  const generationTime = new Date(Date.now() - 5 * 6e4).toISOString().replace(".000Z", "Z");
+  const expirationTime = new Date(Date.now() + 5 * 6e4).toISOString().replace(".000Z", "Z");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<loginTicketRequest version="1.0">
+  <header>
+    <uniqueId>${uniqueId}</uniqueId>
+    <generationTime>${generationTime}</generationTime>
+    <expirationTime>${expirationTime}</expirationTime>
+  </header>
+  <service>${service}</service>
+</loginTicketRequest>`;
+}
+function signLoginTicketRequest(loginTicketRequestXml, options) {
+  const certificate = forge.pki.certificateFromPem(options.certificatePem);
+  const privateKey = forge.pki.privateKeyFromPem(options.privateKeyPem);
+  const signedData = forge.pkcs7.createSignedData();
+  signedData.content = forge.util.createBuffer(loginTicketRequestXml, "utf8");
+  signedData.addCertificate(certificate);
+  const authenticatedAttributes = [
+    {
+      type: String(forge.pki.oids.contentType),
+      value: String(forge.pki.oids.data)
+    },
+    {
+      type: String(forge.pki.oids.messageDigest)
+    },
+    {
+      type: String(forge.pki.oids.signingTime),
+      value: /* @__PURE__ */ new Date()
+    }
+  ];
+  const signerOptions = {
+    key: privateKey,
+    certificate,
+    digestAlgorithm: String(forge.pki.oids.sha1),
+    authenticatedAttributes
+  };
+  signedData.addSigner(signerOptions);
+  signedData.sign();
+  const der = forge.asn1.toDer(signedData.toAsn1()).getBytes();
+  return Buffer.from(der, "binary").toString("base64");
+}
+function parseLoginTicketResponse(xml) {
+  const parsed = parseXmlDocument(xml);
+  const response = parsed.loginTicketResponse ?? parsed;
+  const header = response.header;
+  const credentials = response.credentials;
+  const token = credentials?.token;
+  const sign = credentials?.sign;
+  const expiresAt = header?.expirationTime;
+  if (typeof token !== "string" || typeof sign !== "string" || typeof expiresAt !== "string") {
+    throw new ArcaTransportError(
+      "Invalid WSAA login ticket response structure"
+    );
+  }
+  return {
+    token,
+    sign,
+    expiresAt
+  };
+}
+
+// src/internal/logger.ts
+var ARCA_LOG_LEVELS = ["debug", "info", "warn", "error"];
+function createArcaLogger(config) {
+  const disabled = config?.disabled ?? false;
+  const level = resolveArcaLogLevel(config?.level);
+  const sink = config?.log ?? defaultArcaLog;
+  const log = (messageLevel, message, ...args) => {
+    if (disabled || !shouldLog(level, messageLevel)) {
+      return;
+    }
+    sink(messageLevel, message, ...args);
+  };
+  return {
+    disabled,
+    level,
+    log,
+    debug(message, ...args) {
+      log("debug", message, ...args);
+    },
+    info(message, ...args) {
+      log("info", message, ...args);
+    },
+    warn(message, ...args) {
+      log("warn", message, ...args);
+    },
+    error(message, ...args) {
+      log("error", message, ...args);
+    }
+  };
+}
+function resolveArcaLogLevel(level) {
+  if (isArcaLogLevel(level)) {
+    return level;
+  }
+  const envLevel = process.env.ARCA_LOG_LEVEL?.trim().toLowerCase();
+  if (isArcaLogLevel(envLevel)) {
+    return envLevel;
+  }
+  return "warn";
+}
+function shouldLog(threshold, messageLevel) {
+  return ARCA_LOG_LEVELS.indexOf(messageLevel) >= ARCA_LOG_LEVELS.indexOf(threshold);
+}
+function isArcaLogLevel(value) {
+  return ARCA_LOG_LEVELS.includes(value);
+}
+function defaultArcaLog(level, message, ...args) {
+  const method = level === "debug" ? console.debug : level === "info" ? console.info : level === "warn" ? console.warn : console.error;
+  method(message, ...args);
+}
+
+// src/services/issuance-fields.ts
+var FAMILIES = {
+  ordinary: { A: [1, 2, 3], B: [6, 7, 8], C: [11, 12, 13] },
+  retention_legend: { A: [51, 52, 53] },
+  fce: { A: [201, 202, 203], B: [206, 207, 208], C: [211, 212, 213] }
+};
+function voucherFamily(type) {
+  for (const [family, classes] of Object.entries(FAMILIES)) {
+    for (const [voucherClass, types] of Object.entries(classes)) {
+      if (types.includes(type)) {
+        return {
+          family,
+          voucherClass,
+          types
+        };
+      }
+    }
+  }
+  throw new ArcaInputError("Unsupported invoice or note type.", {
+    code: "ARCA_INPUT_INVALID_VALUE",
+    field: "voucherType"
+  });
+}
+function invoiceType(family, voucherClass) {
+  const classes = FAMILIES[family];
+  const types = classes && classes[voucherClass];
+  if (!types) {
+    throw new ArcaInputError("Invoice family does not support this class.", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "family"
+    });
+  }
+  return types[0];
+}
+function minor(value, field) {
+  return arcaMinorUnitsToNumber(assertArcaMinorUnits(value, field), field);
+}
+function applyIssuanceFields(data, fields) {
+  if (fields.taxes !== void 0) {
+    if (!Array.isArray(fields.taxes)) {
+      throw new ArcaInputError("taxes must be an array", {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field: "taxes"
+      });
+    }
+    data.taxes = fields.taxes.map((tax) => ({
+      id: tax.id,
+      description: tax.description,
+      baseAmount: minor(tax.base, "taxes.base"),
+      rate: tax.rate,
+      amount: minor(tax.amount, "taxes.amount")
+    }));
+    data.taxAmount = minor(tributeTotal(fields.taxes), "taxes.total");
+  }
+  if (fields.amounts) {
+    Object.assign(data, reviewedHeaderAmounts(fields.amounts));
+  }
+  if (fields.concept) {
+    data.concept = { products: 1, services: 2, products_and_services: 3 }[fields.concept];
+  }
+  if (fields.dueDate) {
+    data.paymentDueDate = fields.dueDate;
+  }
+  if (fields.paidInForeignCurrency !== void 0) {
+    if (typeof fields.paidInForeignCurrency !== "boolean") {
+      throw new ArcaInputError("paidInForeignCurrency must be boolean", {
+        code: "ARCA_INPUT_INVALID_VALUE"
+      });
+    }
+    data.sameCurrencyForeignCancellation = fields.paidInForeignCurrency ? "S" : "N";
+  }
+  for (const key of ["optionalFields", "buyers", "activities"]) {
+    if (fields[key] !== void 0) {
+      Object.assign(data, { [key]: structuredClone(fields[key]) });
+    }
+  }
+  applyFceFields(data, fields.fce);
+}
+function tributeTotal(taxes) {
+  return taxes.reduce((sum, tax) => sum + tax.amount, 0);
+}
+function reviewedHeaderAmounts(amounts) {
+  return {
+    netAmount: minor(amounts.net, "amounts.net"),
+    vatAmount: minor(amounts.vat, "amounts.vat"),
+    exemptAmount: minor(amounts.exempt ?? 0, "amounts.exempt"),
+    nonTaxableAmount: minor(amounts.untaxed ?? 0, "amounts.untaxed"),
+    vatRates: amounts.vatRates?.map((rate) => ({
+      id: rate.id,
+      baseAmount: minor(rate.base, "amounts.vatRates.base"),
+      amount: minor(rate.amount, "amounts.vatRates.amount")
+    }))
+  };
+}
+var ISSUANCE_KEYS = [
+  "fce",
+  "taxes",
+  "amounts",
+  "concept",
+  "dueDate",
+  "paidInForeignCurrency",
+  "optionalFields",
+  "buyers",
+  "activities"
+];
+function validateIssuanceFields(fields) {
+  validateRows(
+    fields.taxes,
+    "taxes",
+    ["id", "description", "base", "rate", "amount"],
+    (row) => {
+      positiveId(row.id, "taxes.id");
+      if (row.description !== void 0 && typeof row.description !== "string") {
+        bad("taxes.description");
+      }
+      minor(row.base, "taxes.base");
+      minor(row.amount, "taxes.amount");
+      if (typeof row.rate !== "number" || !Number.isFinite(row.rate) || row.rate < 0) {
+        bad("taxes.rate");
+      }
+    }
+  );
+  if (fields.amounts !== void 0) {
+    objectKeys(fields.amounts, "amounts", [
+      "net",
+      "vat",
+      "exempt",
+      "untaxed",
+      "vatRates"
+    ]);
+    minor(fields.amounts.net, "amounts.net");
+    minor(fields.amounts.vat, "amounts.vat");
+    validateRows(
+      fields.amounts.vatRates,
+      "amounts.vatRates",
+      ["id", "base", "amount"],
+      (row) => {
+        if (![3, 4, 5, 6, 8, 9].includes(row.id)) {
+          bad("amounts.vatRates.id");
+        }
+        minor(row.base, "amounts.vatRates.base");
+        minor(row.amount, "amounts.vatRates.amount");
+      }
+    );
+    const ids = fields.amounts.vatRates?.map((r) => r.id) ?? [];
+    if (new Set(ids).size !== ids.length) {
+      bad("amounts.vatRates");
+    }
+  }
+  validateRows(
+    fields.optionalFields,
+    "optionalFields",
+    ["id", "value"],
+    (row) => {
+      if (typeof row.id !== "string" || !/^\d+$/.test(row.id) || typeof row.value !== "string") {
+        bad("optionalFields");
+      }
+    }
+  );
+  validateRows(
+    fields.buyers,
+    "buyers",
+    ["documentType", "documentNumber", "percentage"],
+    (row) => {
+      positiveId(row.documentType, "buyers.documentType");
+      positiveId(row.documentNumber, "buyers.documentNumber");
+      if (typeof row.percentage !== "number" || !Number.isFinite(row.percentage) || row.percentage <= 0 || row.percentage > 100) {
+        bad("buyers.percentage");
+      }
+    }
+  );
+  validateRows(
+    fields.activities,
+    "activities",
+    ["id"],
+    (row) => positiveId(row.id, "activities.id")
+  );
+  if (fields.concept !== void 0 && !["products", "services", "products_and_services"].includes(fields.concept)) {
+    bad("concept");
+  }
+}
+function positiveId(value, field) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    bad(field);
+  }
+}
+function bad(field) {
+  throw new ArcaInputError(`Invalid ${field}`, {
+    code: "ARCA_INPUT_INVALID_VALUE",
+    field
+  });
+}
+function objectKeys(value, field, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => !keys.includes(key))) {
+    bad(field);
+  }
+}
+function validateRows(value, field, keys, check) {
+  if (value === void 0) {
+    return;
+  }
+  if (!Array.isArray(value)) {
+    bad(field);
+  }
+  for (const row of value) {
+    objectKeys(row, field, keys);
+    check(row);
+  }
+}
+function validateFiscalHeader(data) {
+  const family = voucherFamily(data.voucherType);
+  validateFceHeader(data);
+  if (family.voucherClass === "C" && (data.vatAmount !== 0 || data.vatRates?.length || data.exemptAmount !== 0 || data.nonTaxableAmount !== 0)) {
+    bad("amounts");
+  }
+  if (![1, 2, 3].includes(data.concept)) {
+    bad("concept");
+  }
+  const date = normalizeWsfeDateInput(data.voucherDate, "date");
+  if (data.concept === 1 && (data.serviceStartDate || data.serviceEndDate)) {
+    bad("service");
+  }
+  if (data.concept === 2 || data.concept === 3) {
+    if (!(data.serviceStartDate && data.serviceEndDate && data.paymentDueDate)) {
+      bad("service");
+    }
+    const start = normalizeWsfeDateInput(data.serviceStartDate, "service.from");
+    const end = normalizeWsfeDateInput(data.serviceEndDate, "service.to");
+    if (start > end) {
+      bad("service.to");
+    }
+  }
+  if (data.paymentDueDate && normalizeWsfeDateInput(data.paymentDueDate, "dueDate") < date) {
+    bad("dueDate");
+  }
+  if (data.currencyId === "PES" && data.sameCurrencyForeignCancellation !== void 0) {
+    bad("paidInForeignCurrency");
+  }
+}
+function applyFceFields(data, fce) {
+  if (fce === void 0) {
+    return;
+  }
+  objectKeys(fce, "fce", [
+    "cbu",
+    "alias",
+    "transfer",
+    "annulment",
+    "reference"
+  ]);
+  if (voucherFamily(data.voucherType).family !== "fce") {
+    bad("fce");
+  }
+  validateFceOptions(fce);
+  const extra = [
+    ...fce.cbu === void 0 ? [] : [{ id: "2101", value: fce.cbu }],
+    ...fce.alias === void 0 ? [] : [{ id: "2102", value: fce.alias }],
+    ...fce.transfer === void 0 ? [] : [{ id: "27", value: fce.transfer }],
+    ...fce.annulment === void 0 ? [] : [{ id: "22", value: fce.annulment ? "S" : "N" }],
+    ...fce.reference === void 0 ? [] : [{ id: "23", value: fce.reference }]
+  ];
+  const options = [...data.optionalFields ?? [], ...extra];
+  if (new Set(options.map((o) => o.id)).size !== options.length) {
+    bad("fce");
+  }
+  data.optionalFields = options;
+}
+function validateFceHeader(data) {
+  const family = voucherFamily(data.voucherType);
+  if (family.family === "fce") {
+    const options = new Map(
+      (data.optionalFields ?? []).map((o) => [o.id, o.value])
+    );
+    if (family.types[0] === data.voucherType) {
+      if (!/^\d{22}$/.test(options.get("2101") ?? "") || options.has("22")) {
+        bad("fce.cbu");
+      }
+      if (!data.paymentDueDate) {
+        bad("dueDate");
+      }
+    } else if (!["S", "N"].includes(options.get("22") ?? "") || options.has("2101") || options.has("2102") || options.has("27")) {
+      bad("fce.annulment");
+    }
+  }
+}
+function validateFceOptions(fce) {
+  if (fce.cbu !== void 0 && (typeof fce.cbu !== "string" || !/^\d{22}$/.test(fce.cbu))) {
+    bad("fce.cbu");
+  }
+  if (fce.alias !== void 0 && (typeof fce.alias !== "string" || !/^[A-Za-z0-9.-]{6,20}$/.test(fce.alias))) {
+    bad("fce.alias");
+  }
+  if (fce.transfer !== void 0 && !["ADC", "SCA"].includes(fce.transfer)) {
+    bad("fce.transfer");
+  }
+  if (fce.annulment !== void 0 && typeof fce.annulment !== "boolean") {
+    bad("fce.annulment");
+  }
+  if (fce.reference !== void 0 && (typeof fce.reference !== "string" || !fce.reference.trim())) {
+    bad("fce.reference");
+  }
+}
+
+// src/services/issuance-wsmtxca.ts
+var iso = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  const date = normalizeWsfeDateInput(
+    value,
+    "date"
+  );
+  return `${date.slice(0, 4)}-${date.slice(4, 6)}-${date.slice(6, 8)}`;
+};
+function wsmtxcaRequest(data, number) {
+  if (!data.details?.length) {
+    invalid("details", "WSMTXCA requires detailed items");
+  }
+  const items = data.details.map((item, index) => {
+    if (!item || typeof item !== "object" || Object.keys(item).some(
+      (k) => ![
+        "description",
+        "quantity",
+        "unit",
+        "unitPrice",
+        "discount",
+        "vatCondition",
+        "vatAmount",
+        "amount",
+        "code",
+        "matrixCode",
+        "matrixUnits"
+      ].includes(k)
+    )) {
+      invalid(`details[${index}]`, "Invalid detailed item fields");
+    }
+    if (typeof item.description !== "string" || !(item.description.trim() && Number.isFinite(item.quantity)) || item.quantity <= 0 || !Number.isInteger(item.unit) || item.unit < 0 || typeof item.unitPrice !== "string" || !/^\d+(\.\d{1,6})?$/.test(item.unitPrice) || !Number.isInteger(item.vatCondition)) {
+      invalid(`details[${index}]`, "Invalid detailed item");
+    }
+    return {
+      unidadesMtx: item.matrixUnits,
+      codigoMtx: item.matrixCode,
+      codigo: item.code,
+      descripcion: item.description,
+      cantidad: item.quantity,
+      codigoUnidadMedida: item.unit,
+      precioUnitario: item.unitPrice,
+      importeBonificacion: minor(item.discount ?? 0, "details.discount"),
+      codigoCondicionIVA: item.vatCondition,
+      ...item.vatAmount === void 0 ? {} : { importeIVA: minor(item.vatAmount, "details.vatAmount") },
+      importeItem: minor(item.amount, "details.amount")
+    };
+  });
+  const itemTotal = data.details.reduce(
+    (sum, item) => sum + BigInt(item.amount),
+    0n
+  );
+  const expected = normalizeArcaAmountToMinorUnits(data.totalAmount, "total") - normalizeArcaAmountToMinorUnits(data.taxAmount, "taxes");
+  if (!isWithinArcaTolerance(itemTotal, expected, 1)) {
+    invalid(
+      "details",
+      "Item totals must equal the voucher total excluding tributes"
+    );
+  }
+  return {
+    comprobanteCAERequest: {
+      codigoTipoComprobante: data.voucherType,
+      numeroPuntoVenta: data.salesPoint,
+      ...number === void 0 ? {} : { numeroComprobante: number },
+      fechaEmision: iso(data.voucherDate),
+      codigoTipoDocumento: data.documentType,
+      numeroDocumento: data.documentNumber,
+      condicionIVAReceptor: data.receiverVatConditionId,
+      importeGravado: data.netAmount,
+      importeNoGravado: data.nonTaxableAmount,
+      importeExento: data.exemptAmount,
+      importeSubtotal: Number(
+        normalizeArcaAmountToMinorUnits(data.netAmount, "net") + normalizeArcaAmountToMinorUnits(data.nonTaxableAmount, "untaxed") + normalizeArcaAmountToMinorUnits(data.exemptAmount, "exempt")
+      ) / 100,
+      importeOtrosTributos: data.taxAmount,
+      importeTotal: data.totalAmount,
+      codigoMoneda: data.currencyId,
+      cotizacionMoneda: data.exchangeRate,
+      codigoConcepto: data.concept,
+      fechaServicioDesde: iso(data.serviceStartDate),
+      fechaServicioHasta: iso(data.serviceEndDate),
+      fechaVencimientoPago: iso(data.paymentDueDate),
+      ...data.sameCurrencyForeignCancellation === void 0 ? {} : {
+        cancelaEnMismaMonedaExtranjera: data.sameCurrencyForeignCancellation
+      },
+      arrayComprobantesAsociados: data.associatedVouchers?.length ? {
+        comprobanteAsociado: data.associatedVouchers.map((v) => ({
+          codigoTipoComprobante: v.type,
+          numeroPuntoVenta: v.salesPoint,
+          numeroComprobante: v.number,
+          cuit: v.taxId,
+          fechaEmision: iso(v.voucherDate)
+        }))
+      } : void 0,
+      periodoComprobantesAsociados: data.associatedPeriod ? {
+        fechaDesde: iso(data.associatedPeriod.startDate),
+        fechaHasta: iso(data.associatedPeriod.endDate)
+      } : void 0,
+      arrayCompradores: data.buyers?.length ? {
+        comprador: data.buyers.map((b) => ({
+          codigoTipoDocumento: b.documentType,
+          numeroDocumento: b.documentNumber,
+          porcentaje: b.percentage
+        }))
+      } : void 0,
+      arrayOtrosTributos: data.taxes?.length ? {
+        otroTributo: data.taxes.map((t) => ({
+          codigo: t.id,
+          descripcion: t.description,
+          baseImponible: t.baseAmount,
+          importe: t.amount
+        }))
+      } : void 0,
+      arrayItems: { item: items },
+      arraySubtotalesIVA: data.vatRates?.length ? {
+        subtotalIVA: data.vatRates.map((v) => ({
+          codigo: v.id,
+          importe: v.amount
+        }))
+      } : void 0,
+      arrayDatosAdicionales: wsmtxcaAdditionalData(data.optionalFields),
+      arrayActividades: data.activities?.length ? { actividad: data.activities.map((a) => ({ codigo: a.id })) } : void 0
+    }
+  };
+}
+function invalid(field, message) {
+  throw new ArcaInputError(message, {
+    code: "ARCA_INPUT_INVALID_VALUE",
+    field
+  });
+}
+function rows(value, key) {
+  const data = value && typeof value === "object" ? value[key] : void 0;
+  if (data === void 0) {
+    return void 0;
+  }
+  const list = Array.isArray(data) ? data : [data];
+  if (list.some((item) => !item || typeof item !== "object")) {
+    return void 0;
+  }
+  return list;
+}
+function wsmtxcaHeader(found) {
+  const raw = found.raw;
+  const items = rows(raw.arrayItems, "item");
+  const details = items?.map((i) => ({
+    description: String(i.descripcion ?? ""),
+    quantity: Number(i.cantidad),
+    unit: Number(i.codigoUnidadMedida),
+    unitPrice: String(i.precioUnitario),
+    discount: Number(
+      normalizeArcaAmountToMinorUnits(
+        Number(i.importeBonificacion ?? 0),
+        "discount"
+      )
+    ),
+    vatCondition: Number(i.codigoCondicionIVA),
+    vatAmount: i.importeIVA === void 0 ? void 0 : Number(normalizeArcaAmountToMinorUnits(Number(i.importeIVA), "vat")),
+    amount: Number(
+      normalizeArcaAmountToMinorUnits(Number(i.importeItem), "amount")
+    ),
+    code: i.codigo === void 0 ? void 0 : String(i.codigo),
+    matrixCode: i.codigoMtx === void 0 ? void 0 : String(i.codigoMtx),
+    matrixUnits: i.unidadesMtx === void 0 ? void 0 : Number(i.unidadesMtx)
+  }));
+  return {
+    ...found,
+    voucherNumber: found.voucherNumber ?? 0,
+    voucherDate: found.invoiceDate,
+    netAmount: found.taxableAmount,
+    // consultarComprobante is an authorized-voucher lookup. No result flag is returned.
+    result: found.cae ? "A" : void 0,
+    serviceStartDate: raw.fechaServicioDesde === void 0 ? void 0 : String(raw.fechaServicioDesde),
+    serviceEndDate: raw.fechaServicioHasta === void 0 ? void 0 : String(raw.fechaServicioHasta),
+    paymentDueDate: raw.fechaVencimientoPago === void 0 ? void 0 : String(raw.fechaVencimientoPago),
+    details,
+    vatRates: rows(raw.arraySubtotalesIVA, "subtotalIVA")?.map((v) => ({
+      id: Number(v.codigo),
+      amount: Number(v.importe),
+      baseAmount: Number(
+        (details ?? []).filter((i) => i.vatCondition === Number(v.codigo)).reduce((sum, i) => sum + BigInt(i.amount), 0n) - normalizeArcaAmountToMinorUnits(Number(v.importe), "vat")
+      ) / 100
+    })),
+    taxes: rows(raw.arrayOtrosTributos, "otroTributo")?.map((t) => ({
+      id: Number(t.codigo),
+      description: t.descripcion === void 0 ? void 0 : String(t.descripcion),
+      baseAmount: Number(t.baseImponible),
+      amount: Number(t.importe),
+      rate: 0
+    })),
+    sameCurrencyForeignCancellation: raw.cancelaEnMismaMonedaExtranjera,
+    optionalFields: rows(raw.arrayDatosAdicionales, "datoAdicional")?.map(
+      (v) => ({ id: String(v.t), value: String(v.c1) })
+    ),
+    activities: rows(raw.arrayActividades, "actividad")?.map((v) => ({
+      id: Number(v.codigo)
+    })),
+    buyers: rows(raw.arrayCompradores, "comprador")?.map((v) => ({
+      documentType: Number(v.codigoTipoDocumento),
+      documentNumber: Number(v.numeroDocumento),
+      percentage: Number(v.porcentaje)
+    })),
+    associatedVouchers: rows(
+      raw.arrayComprobantesAsociados,
+      "comprobanteAsociado"
+    )?.map((v) => ({
+      type: Number(v.codigoTipoComprobante),
+      salesPoint: Number(v.numeroPuntoVenta),
+      number: Number(v.numeroComprobante),
+      taxId: v.cuit === void 0 ? void 0 : String(v.cuit),
+      voucherDate: v.fechaEmision
+    }))
+  };
+}
+function matchWsmtxcaDetails(data, number, raw) {
+  const request = wsmtxcaRequest(
+    data,
+    number
+  ).comprobanteCAERequest;
+  let missing = false;
+  for (const key of Object.keys(request)) {
+    const expected = request[key];
+    const actual = raw[key];
+    if (expected === void 0) {
+      if (!emptyWire(actual)) {
+        return "conflict";
+      }
+      continue;
+    }
+    const result = compareWire(
+      normalizeWire(expected, key),
+      normalizeWire(actual, key)
+    );
+    if (result === "conflict") {
+      return "conflict";
+    }
+    missing ||= result === "incomplete";
+  }
+  return missing ? "incomplete" : "match";
+}
+function emptyWire(value) {
+  return value === void 0 || value === null || typeof value === "object" && Object.values(value).every(emptyWire);
+}
+function compareWire(expected, actual) {
+  if (actual === void 0 || actual === null) {
+    return "incomplete";
+  }
+  if (expected !== null && typeof expected === "object") {
+    if (typeof actual !== "object" || Array.isArray(expected) !== Array.isArray(actual)) {
+      return "conflict";
+    }
+    const left = expected;
+    const right = actual;
+    if (Object.keys(right).some((key) => !(key in left || emptyWire(right[key])))) {
+      return "conflict";
+    }
+    let missing = false;
+    for (const key of Object.keys(left)) {
+      const result = compareWire(left[key], right[key]);
+      if (result === "conflict") {
+        return result;
+      }
+      missing ||= result === "incomplete";
+    }
+    return missing ? "incomplete" : "match";
+  }
+  return expected === actual ? "match" : "conflict";
+}
+var LIST_KEYS = /* @__PURE__ */ new Set([
+  "item",
+  "comprobanteAsociado",
+  "otroTributo",
+  "subtotalIVA",
+  "datoAdicional",
+  "actividad",
+  "comprador"
+]);
+var TEXT_KEYS = /* @__PURE__ */ new Set([
+  "codigo",
+  "descripcion",
+  "codigoMtx",
+  "c1",
+  "c2",
+  "c3",
+  "c4",
+  "c5",
+  "c6",
+  "codigoMoneda",
+  "cancelaEnMismaMonedaExtranjera"
+]);
+function normalizeWire(value, key = "") {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  if (LIST_KEYS.has(key)) {
+    return (Array.isArray(value) ? value : [value]).map(
+      (v) => normalizeWire(v)
+    );
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => normalizeWire(v));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, v]) => v !== void 0).map(([k, v]) => [k, normalizeWire(v, k)])
+    );
+  }
+  if (TEXT_KEYS.has(key) && value !== void 0 && value !== null) {
+    return String(value);
+  }
+  if (!TEXT_KEYS.has(key) && typeof value === "string" && /^\d+(\.\d+)?$/.test(value)) {
+    return Number(value);
+  }
+  return value;
+}
+function createWsmtxcaIssuanceService(wsmtxca) {
+  return {
+    getNextVoucherNumber: async (input) => (await wsmtxca.getLastAuthorizedVoucher(input)).voucherNumber + 1,
+    issue: (input) => wsmtxca.issue({
+      representedTaxId: input.representedTaxId,
+      forceRefresh: input.forceRefresh,
+      data: wsmtxcaRequest(input.data, input.voucherNumber)
+    }),
+    lookupVoucher: async (input) => {
+      const result = await wsmtxca.lookupVoucher({
+        ...input,
+        voucherNumber: input.number
+      });
+      return result.kind === "found" ? { ...result, voucher: wsmtxcaHeader(result.voucher) } : result;
+    }
+  };
+}
+function wsmtxcaAdditionalData(fields) {
+  if (!fields?.length) {
+    return void 0;
+  }
+  const options = new Map(fields.map((f) => [f.id, f.value]));
+  return {
+    datoAdicional: [
+      ...options.has("2101") ? [{ t: 21, c1: options.get("2101"), c2: options.get("2102") }] : [],
+      ...fields.filter((f) => f.id !== "2101" && f.id !== "2102").map((f) => ({ t: Number(f.id), c1: f.value }))
+    ]
+  };
+}
+
+// src/services/wsfe-derive.ts
+var INVOICE_TYPES = {
+  A: ARCA_VOUCHER_TYPES.FACTURA_A,
+  B: ARCA_VOUCHER_TYPES.FACTURA_B,
+  C: ARCA_VOUCHER_TYPES.FACTURA_C
+};
+function deriveWsfeInvoice(input, now = /* @__PURE__ */ new Date()) {
+  assertIssueObject(input, "input");
+  assertIssueKeys(
+    input,
+    [
+      ...ISSUANCE_KEYS,
+      "family",
+      "details",
+      "issuer",
+      "items",
+      "salesPoint",
+      "to",
+      "total",
+      "date",
+      "currency",
+      "exchangeRate",
+      "service"
+    ],
+    "input"
+  );
+  validateIssuanceFields(input);
+  if (input.amounts !== void 0 && input.items !== void 0) {
+    invalid2("amounts", "used instead of items, never with items");
+  }
+  assertIssuerCondition(input.issuer);
+  assertSalesPoint(input.salesPoint);
+  const receiver = deriveReceiver(input.to);
+  const voucherClass = resolveInvoiceClass(input.issuer, input.to.condition);
+  const { data: amountsData, amounts } = input.amounts ? reviewedInvoiceAmounts(input.amounts, input.taxes) : calculateWsfeAmounts({
+    voucherClass,
+    items: input.items,
+    total: input.total === void 0 ? void 0 : input.total - tributeTotal(input.taxes ?? [])
+  });
+  const currency = deriveCurrency(input);
+  const voucherDate = normalizeWsfeDateInput(
+    input.date === void 0 ? buenosAiresDate(now) : input.date,
+    "date"
+  );
+  const data = {
+    salesPoint: input.salesPoint,
+    voucherType: input.family === void 0 ? INVOICE_TYPES[voucherClass] : invoiceType(input.family, voucherClass),
+    voucherDate,
+    ...receiver,
+    ...currency,
+    ...amountsData,
+    ...deriveService(input.service, voucherDate)
+  };
+  applyIssuanceFields(data, input);
+  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");
+  amounts.computedTotal += headerTotal - amounts.sentTotal;
+  amounts.sentTotal = reviewedTotal ?? 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"));
+    if (BigInt(amounts.sentTotal) * rate >= ARCA_FINAL_CONSUMER_IDENTIFICATION_THRESHOLD_MINOR_UNITS * 1000000n) {
+      throw new ArcaInputError(
+        "The final consumer must be identified for this amount.",
+        {
+          code: "ARCA_INPUT_MISSING_FIELD",
+          field: "to",
+          expected: "cuit or dni for operations at or above ARS 10,000,000 (RG 5866)"
+        }
+      );
+    }
+  }
+  validateFiscalHeader(data);
+  try {
+    normalizeWsfeVoucherInput(data);
+  } catch (cause) {
+    if (cause instanceof ArcaInputError) {
+      throw cause;
+    }
+    throw new ArcaError(
+      "The derived invoice failed exact WSFE validation. This is an SDK invariant failure.",
+      "ARCA_ISSUE_INVARIANT",
+      { cause }
+    );
+  }
+  return { data, voucherClass, amounts };
+}
+function reviewedInvoiceAmounts(amounts, taxes) {
+  const taxTotal = taxes === void 0 ? 0 : tributeTotal(taxes);
+  const total = amounts.net + amounts.vat + (amounts.exempt ?? 0) + (amounts.untaxed ?? 0) + taxTotal;
+  return {
+    data: {
+      totalAmount: minor(total, "total"),
+      taxAmount: minor(taxTotal, "taxes.total"),
+      ...reviewedHeaderAmounts(amounts)
+    },
+    amounts: { computedTotal: total, sentTotal: total, vatAdjustment: 0 }
+  };
+}
+function assertIssuerCondition(issuer) {
+  if (typeof issuer !== "string" || !Object.hasOwn(ARCA_ISSUER_CONDITION_IDS, issuer)) {
+    invalid2(
+      "issuer",
+      "responsable_inscripto, monotributo, exento, or no_alcanzado"
+    );
+  }
+}
+function assertSalesPoint(salesPoint) {
+  if (!Number.isSafeInteger(salesPoint) || salesPoint < 1 || salesPoint > 99999) {
+    invalid2("salesPoint", "an integer from 1 through 99999");
+  }
+}
+function resolveInvoiceClass(issuer, condition) {
+  if (typeof condition === "number") {
+    return issuer === "responsable_inscripto" ? [1, 6, 13, 16].includes(condition) ? "A" : "B" : "C";
+  }
+  return ARCA_INVOICE_CLASS_BY_ISSUER[issuer][condition];
+}
+function deriveReceiver(to) {
+  assertIssueObject(to, "to");
+  assertIssueKeys(to, ["condition", "cuit", "dni", "document"], "to");
+  if (typeof to.condition === "number") {
+    return deriveNumericReceiver(
+      to
+    );
+  }
+  if (typeof to.condition !== "string" || !Object.hasOwn(ARCA_RECEIVER_CONDITION_IDS, to.condition)) {
+    invalid2("to.condition", "one of the five supported receiver conditions");
+  }
+  if (to.cuit !== void 0 && to.dni !== void 0) {
+    invalid2("to", "either cuit or dni, never both");
+  }
+  if (to.condition !== "consumidor_final" && to.cuit === void 0) {
+    throw new ArcaInputError(
+      "to.cuit is required for this receiver (WSFE 10063 for class A).",
+      {
+        code: "ARCA_INPUT_MISSING_FIELD",
+        field: "to.cuit",
+        expected: "an 11-digit CUIT"
+      }
+    );
+  }
+  const documentType = to.cuit === void 0 ? to.dni === void 0 ? ARCA_DOCUMENT_TYPES.CONSUMIDOR_FINAL : ARCA_DOCUMENT_TYPES.DNI : ARCA_DOCUMENT_TYPES.CUIT;
+  const documentNumber = to.cuit === void 0 ? to.dni === void 0 ? 0 : issueDocumentNumber(to.dni, "to.dni", 1, 11) : issueDocumentNumber(to.cuit, "to.cuit", 11, 11);
+  return {
+    documentType,
+    documentNumber,
+    receiverVatConditionId: ARCA_RECEIVER_CONDITION_IDS[to.condition]
+  };
+}
+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) {
+    invalid2(field, `a positive document number with ${min} to ${max} digits`);
+  }
+  return Number(text);
+}
+function deriveCurrency(input) {
+  const currency = input.currency === void 0 ? "ARS" : input.currency;
+  if (typeof currency === "object" && currency !== null) {
+    assertIssueKeys(currency, ["id"], "currency");
+    if (!/^[A-Z0-9]{3}$/.test(currency.id)) {
+      invalid2("currency.id", "a three-character ARCA currency code");
+    }
+    if (input.exchangeRate === void 0) {
+      invalid2("exchangeRate", "an explicit rate for this currency");
+    }
+    return {
+      currencyId: currency.id,
+      exchangeRate: serializeArcaExchangeRate(
+        input.exchangeRate,
+        "exchangeRate"
+      )
+    };
+  }
+  if (currency !== "ARS" && currency !== "USD") {
+    invalid2("currency", "ARS or USD");
+  }
+  if (input.exchangeRate !== void 0 && typeof input.exchangeRate !== "string") {
+    invalid2("exchangeRate", "a decimal string");
+  }
+  if (currency === "USD" && input.exchangeRate === void 0) {
+    throw new ArcaInputError("exchangeRate is required for USD.", {
+      code: "ARCA_INPUT_MISSING_FIELD",
+      field: "exchangeRate",
+      expected: "a positive decimal string"
+    });
+  }
+  const exchangeRate = serializeArcaExchangeRate(
+    input.exchangeRate ?? "1",
+    "exchangeRate"
+  );
+  if (currency === "ARS" && exchangeRate !== "1") {
+    throw new ArcaInputError("exchangeRate must be 1 for ARS.", {
+      code: "ARCA_INPUT_INVALID_EXCHANGE_RATE",
+      field: "exchangeRate",
+      expected: "1 for ARS"
+    });
+  }
+  return { currencyId: ARCA_CURRENCY_IDS[currency], exchangeRate };
+}
+function deriveService(service, date) {
+  if (service === void 0) {
+    return { concept: 1 };
+  }
+  assertIssueObject(service, "service");
+  assertIssueKeys(service, ["from", "to", "dueDate"], "service");
+  for (const field of ["from", "to", "dueDate"]) {
+    if (service[field] === void 0) {
+      throw new ArcaInputError(`service.${field} is required.`, {
+        code: "ARCA_INPUT_MISSING_FIELD",
+        field: `service.${field}`,
+        expected: "a calendar date"
+      });
+    }
+  }
+  const serviceStartDate = normalizeWsfeDateInput(
+    service.from,
+    "service.from"
+  );
+  const serviceEndDate = normalizeWsfeDateInput(
+    service.to,
+    "service.to"
+  );
+  const paymentDueDate = normalizeWsfeDateInput(
+    service.dueDate,
+    "service.dueDate"
+  );
+  if (serviceEndDate < serviceStartDate) {
+    invalid2("service.to", "a date on or after service.from");
+  }
+  if (paymentDueDate < date) {
+    invalid2("service.dueDate", "a date on or after date");
+  }
+  return { concept: 2, serviceStartDate, serviceEndDate, paymentDueDate };
+}
+function buenosAiresDate(now) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "America/Argentina/Buenos_Aires",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(now);
+  return ["year", "month", "day"].map((part) => parts.find((entry) => entry.type === part)?.value).join("");
+}
+function assertIssueObject(value, field) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    invalid2(field, "an object");
+  }
+}
+function assertIssueKeys(value, keys, prefix, method = "issue()") {
+  for (const key of Object.keys(value)) {
+    if (!keys.includes(key)) {
+      const field = prefix === "input" ? key : `${prefix}.${key}`;
+      throw new ArcaInputError(`${field} is not supported by ${method}.`, {
+        code: "ARCA_INPUT_RESERVED_FIELD",
+        field,
+        expected: "a supported high-level API field; use the exact API for other fiscal fields"
+      });
+    }
+  }
+}
+function invalid2(field, expected) {
+  throw new ArcaInputError(`${field} must be ${expected}.`, {
+    code: "ARCA_INPUT_INVALID_VALUE",
+    field,
+    expected
+  });
+}
+function deriveNumericReceiver(to) {
+  if (![1, 4, 5, 6, 7, 8, 9, 10, 13, 15, 16].includes(to.condition)) {
+    invalid2("to.condition", "an ARCA receiver condition");
+  }
+  const document = "document" in to ? to.document : void 0;
+  if (document) {
+    assertIssueKeys(document, ["type", "number"], "to.document");
+    if (to.cuit !== void 0 || to.dni !== void 0) {
+      invalid2("to", "one document identity");
+    }
+    if (!Number.isInteger(document.type) || document.type < 0 || document.type > 99 || !/^\d{1,11}$/.test(String(document.number)) || !Number.isSafeInteger(Number(document.number))) {
+      invalid2("to.document", "a valid document type and number");
+    }
+    if (document.type === 80 && String(document.number).length !== 11) {
+      invalid2("to.document.number", "an 11-digit CUIT");
+    }
+    return {
+      documentType: document.type,
+      documentNumber: Number(document.number),
+      receiverVatConditionId: to.condition
+    };
+  }
+  if (to.cuit === void 0 && to.dni === void 0) {
+    invalid2("to", "an explicit document");
+  }
+  if (to.cuit !== void 0 && to.dni !== void 0) {
+    invalid2("to", "one document identity");
+  }
+  return {
+    documentType: to.cuit === void 0 ? 96 : 80,
+    documentNumber: issueDocumentNumber(
+      to.cuit ?? to.dni,
+      "to.document",
+      to.cuit === void 0 ? 1 : 11,
+      11
+    ),
+    receiverVatConditionId: to.condition
+  };
+}
+
+// src/services/wsfe-credit-note.ts
+function invalid3(reason) {
+  throw new ArcaInputError(
+    `issueCreditNote cannot proceed: ${reason}. Use the exact service API for manual control.`,
+    { code: "ARCA_INPUT_INVALID_VALUE" }
+  );
+}
+function required(value, field) {
+  if (value === void 0 || value === null) {
+    invalid3(`original is missing ${field}`);
+  }
+  return value;
+}
+function deriveWsfeFullCreditNote(original, input, now = /* @__PURE__ */ new Date(), kind = "creditNote") {
+  const { note, header } = prepareCreditNote(original, input, now, kind);
+  const data = {
+    ...header,
+    ...original.taxes ? { taxes: structuredClone(original.taxes) } : {},
+    totalAmount: required(original.totalAmount, "totalAmount"),
+    netAmount: required(original.netAmount, "netAmount"),
+    vatAmount: required(original.vatAmount, "vatAmount"),
+    exemptAmount: required(original.exemptAmount, "exemptAmount"),
+    nonTaxableAmount: required(original.nonTaxableAmount, "nonTaxableAmount"),
+    taxAmount: required(original.taxAmount, "taxAmount"),
+    ...original.vatRates === void 0 ? {} : { vatRates: original.vatRates.map((rate) => ({ ...rate })) }
+  };
+  normalizeWsfeVoucherInput(data);
+  const total = Number(
+    normalizeArcaAmountToMinorUnits(data.totalAmount, "totalAmount")
+  );
+  return {
+    data,
+    voucherClass: note.voucherClass,
+    amounts: { computedTotal: total, sentTotal: total, vatAdjustment: 0 }
+  };
+}
+function deriveWsfePartialCreditNote(original, input, now = /* @__PURE__ */ new Date(), kind = "creditNote") {
+  if (input.items === void 0 && input.amounts === void 0) {
+    invalid3("items is required to credit chosen lines");
+  }
+  const requestedTotal = input.total === void 0 ? void 0 : assertArcaMinorUnits(input.total, "total");
+  const { note, header } = prepareCreditNote(original, input, now, kind);
+  const { data: amountsData, amounts } = input.amounts ? reviewedInvoiceAmounts(input.amounts, input.taxes) : calculateWsfeAmounts({
+    voucherClass: note.voucherClass,
+    items: input.items,
+    total: input.total === void 0 ? void 0 : input.total - tributeTotal(input.taxes ?? [])
+  });
+  const originalTotal = normalizeArcaAmountToMinorUnits(
+    required(original.totalAmount, "totalAmount"),
+    "totalAmount"
+  );
+  if (kind === "creditNote" && (requestedTotal ?? BigInt(amounts.sentTotal)) > originalTotal) {
+    invalid3(
+      "the note total is greater than the original; the SDK does not track earlier notes against an original"
+    );
+  }
+  const data = { ...header, ...amountsData };
+  applyIssuanceFields(data, {
+    ...input,
+    fce: void 0,
+    optionalFields: void 0
+  });
+  const total = Number(
+    [
+      data.netAmount,
+      data.vatAmount,
+      data.exemptAmount,
+      data.nonTaxableAmount,
+      data.taxAmount
+    ].reduce(
+      (sum, amount) => sum + normalizeArcaAmountToMinorUnits(amount, "amount"),
+      0n
+    )
+  );
+  const sentTotal = input.amounts && requestedTotal !== void 0 ? Number(requestedTotal) : total;
+  if (kind === "creditNote" && BigInt(sentTotal) > originalTotal) {
+    invalid3("the note total is greater than the original");
+  }
+  data.totalAmount = minor(sentTotal, "total");
+  amounts.computedTotal += total - amounts.sentTotal;
+  amounts.sentTotal = sentTotal;
+  normalizeWsfeVoucherInput(data);
+  return { data, voucherClass: note.voucherClass, amounts };
+}
+function prepareCreditNote(original, input, now, kind) {
+  assertOriginalExtensions(original);
+  const family = voucherFamily(original.voucherType ?? 0);
+  if (family.types[2] === original.voucherType) {
+    invalid3("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())) {
+    invalid3("original is not authorized");
+  }
+  const voucherDate = normalizeWsfeDateInput(
+    input.date ?? buenosAiresDate(now),
+    "date"
+  );
+  const originalDate = normalizeWsfeDateInput(
+    required(original.voucherDate, "voucherDate"),
+    "original.voucherDate"
+  );
+  if (originalDate > voucherDate && originalDate.slice(0, 6) !== voucherDate.slice(0, 6)) {
+    invalid3(
+      "original date is later than the note and outside its month (10210)"
+    );
+  }
+  const header = {
+    salesPoint: input.salesPoint ?? required(original.salesPoint, "salesPoint"),
+    voucherType: note.voucherType,
+    concept: required(original.concept, "concept"),
+    documentType: required(original.documentType, "documentType"),
+    documentNumber: Number(required(original.documentNumber, "documentNumber")),
+    receiverVatConditionId: required(
+      original.receiverVatConditionId,
+      "receiverVatConditionId"
+    ),
+    currencyId: required(original.currencyId, "currencyId"),
+    ...original.sameCurrencyForeignCancellation === void 0 ? {} : {
+      sameCurrencyForeignCancellation: original.sameCurrencyForeignCancellation
+    },
+    ...original.buyers ? { buyers: structuredClone(original.buyers) } : {},
+    ...original.activities ? { activities: structuredClone(original.activities) } : {},
+    ...input.optionalFields ? { optionalFields: structuredClone(input.optionalFields) } : {},
+    exchangeRate: required(original.exchangeRate, "exchangeRate"),
+    voucherDate,
+    associatedVouchers: [
+      {
+        type: required(original.voucherType, "voucherType"),
+        salesPoint: required(original.salesPoint, "salesPoint"),
+        number: original.voucherNumber,
+        voucherDate: originalDate
+      }
+    ]
+  };
+  applyFceFields(header, input.fce);
+  copyServiceDates(original, header);
+  return { note, header };
+}
+function copyServiceDates(original, header) {
+  if (header.concept !== 2 && header.concept !== 3) {
+    return;
+  }
+  header.serviceStartDate = required(
+    original.serviceStartDate,
+    "serviceStartDate"
+  );
+  header.serviceEndDate = required(
+    original.serviceEndDate,
+    "serviceEndDate"
+  );
+  const due = normalizeWsfeDateInput(
+    required(original.paymentDueDate, "paymentDueDate"),
+    "original.paymentDueDate"
+  );
+  header.paymentDueDate = due < header.voucherDate ? header.voucherDate : due;
+}
+var CREDIT_NOTE_KEYS = [
+  "for",
+  "salesPoint",
+  "date",
+  "items",
+  "total",
+  "all",
+  "taxes",
+  "amounts",
+  "optionalFields",
+  "details",
+  "fce"
+];
+var TARGET_BOUNDS = [
+  ["salesPoint", 99999],
+  ["voucherType", 999],
+  ["number", 99999999]
+];
+function assertCreditNoteInput(input) {
+  assertIssueObject(input, "input");
+  validateIssuanceFields(input);
+  if ("associatedPeriod" in input) {
+    throw new ArcaInputError(
+      "issueCreditNote does not support associatedPeriod; a note against a period is exact-layer work. Use the exact service API for manual control.",
+      {
+        code: "ARCA_INPUT_RESERVED_FIELD",
+        field: "associatedPeriod",
+        expected: "an associated invoice through for"
+      }
+    );
+  }
+  assertIssueKeys(input, CREDIT_NOTE_KEYS, "input", "issueCreditNote()");
+  const target = assertCreditNoteTarget(input.for);
+  if (input.salesPoint !== void 0) {
+    assertCreditNoteBound(input.salesPoint, 99999, "salesPoint");
+  }
+  const date = input.date === void 0 ? void 0 : normalizeWsfeDateInput(input.date, "date");
+  const common = {
+    ...input.fce === void 0 ? {} : { fce: structuredClone(input.fce) },
+    ...input.taxes === void 0 ? {} : { taxes: structuredClone(input.taxes) },
+    ...input.details === void 0 ? {} : { details: structuredClone(input.details) },
+    ...input.optionalFields === void 0 ? {} : { optionalFields: structuredClone(input.optionalFields) },
+    for: target,
+    ...input.salesPoint === void 0 ? {} : { salesPoint: input.salesPoint },
+    ...date === void 0 ? {} : { date }
+  };
+  if (input.items !== void 0 && input.amounts !== void 0) {
+    invalid3("use items or amounts, never both");
+  }
+  if ((input.items === void 0 && input.amounts === void 0) === (input.all === void 0)) {
+    throw new ArcaInputError(
+      "issueCreditNote needs exactly one mode: items or amounts for a partial note, or all: true for the whole original.",
+      {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field: input.items === void 0 ? "input.items" : "input.all",
+        expected: "exactly one of items, amounts or all: true"
+      }
+    );
+  }
+  if (input.all !== void 0) {
+    assertFullMode(input);
+    return { ...common, all: true };
+  }
+  if (input.amounts !== void 0) {
+    return {
+      ...common,
+      amounts: structuredClone(input.amounts),
+      ...input.total === void 0 ? {} : { total: input.total }
+    };
+  }
+  return {
+    ...common,
+    amounts: void 0,
+    items: copyCreditNoteItems(input.items),
+    ...input.total === void 0 ? {} : { total: input.total }
+  };
+}
+function assertCreditNoteTarget(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new ArcaInputError(
+      "issueCreditNote requires for: the coordinates of the authorized invoice the note corrects.",
+      {
+        code: "ARCA_INPUT_MISSING_FIELD",
+        field: "input.for",
+        expected: "{ salesPoint, voucherType, number }"
+      }
+    );
+  }
+  assertIssueKeys(
+    value,
+    ["salesPoint", "voucherType", "number"],
+    "input.for",
+    "issueCreditNote()"
+  );
+  for (const [field, max] of TARGET_BOUNDS) {
+    assertCreditNoteBound(value[field], max, `for.${field}`);
+  }
+  if (![1, 2, 6, 7, 11, 12, 51, 52, 201, 202, 206, 207, 211, 212].includes(
+    value.voucherType
+  )) {
+    throw new ArcaInputError(
+      "issueCreditNote requires an authorized invoice or debit note in a supported family in for.voucherType. Use the exact service API for manual control.",
+      {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field: "input.for.voucherType",
+        expected: "1, 6 or 11"
+      }
+    );
+  }
+  return {
+    salesPoint: value.salesPoint,
+    voucherType: value.voucherType,
+    number: value.number
+  };
+}
+function assertCreditNoteBound(value, max, path) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > max) {
+    throw new ArcaInputError(
+      `issueCreditNote requires input.${path} to be an integer from 1 through ${max}.`,
+      { code: "ARCA_INPUT_INVALID_VALUE", field: `input.${path}` }
+    );
+  }
+}
+function copyCreditNoteItems(items) {
+  if (!Array.isArray(items)) {
+    throw new ArcaInputError(
+      "issueCreditNote requires items to be a non-empty array of items.",
+      {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field: "input.items",
+        expected: "a non-empty array of items"
+      }
+    );
+  }
+  return items.map(
+    (item) => item === null || typeof item !== "object" ? item : { ...item }
+  );
+}
+function assertOriginalExtensions(original) {
+  for (const [field, rawField] of [
+    ["taxes", "Tributos"],
+    ["optionalFields", "Opcionales"],
+    ["buyers", "Compradores"],
+    ["activities", "Actividades"],
+    ["associatedPeriod", "PeriodoAsoc"]
+  ]) {
+    if (original.raw[rawField] && original[field] === void 0) {
+      invalid3(`original ${field} could not be decoded`);
+    }
+  }
+  try {
+    validateIssuanceFields({
+      taxes: original.taxes?.map((t) => ({
+        id: t.id,
+        description: t.description,
+        base: Number(
+          normalizeArcaAmountToMinorUnits(t.baseAmount, "taxes.base")
+        ),
+        rate: t.rate,
+        amount: Number(
+          normalizeArcaAmountToMinorUnits(t.amount, "taxes.amount")
+        )
+      })),
+      optionalFields: original.optionalFields,
+      buyers: original.buyers,
+      activities: original.activities
+    });
+    if (original.associatedPeriod) {
+      normalizeWsfeDateInput(
+        original.associatedPeriod.startDate,
+        "associatedPeriod.startDate"
+      );
+      normalizeWsfeDateInput(
+        original.associatedPeriod.endDate,
+        "associatedPeriod.endDate"
+      );
+    }
+  } catch {
+    invalid3("original extension fields are incomplete or malformed");
+  }
+}
+function assertFullMode(input) {
+  if (input.all !== true) {
+    throw new ArcaInputError(
+      "issueCreditNote accepts only all: true; pass items to credit chosen lines.",
+      {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field: "input.all",
+        expected: "the literal true"
+      }
+    );
+  }
+  if (input.total !== void 0 || input.taxes !== void 0 || input.amounts !== void 0) {
+    throw new ArcaInputError(
+      "issueCreditNote takes total only with items; all: true credits the original's own total.",
+      {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field: "input.total",
+        expected: "no total when all is true"
+      }
+    );
+  }
+}
+
+// src/services/vouchers.ts
+function createVouchersService(wsfe, context, wsmtxca) {
+  const select = (options = {}) => {
+    validateOptions(options);
+    if (options.service !== "wsmtxca") {
+      return wsfe;
+    }
+    if (!wsmtxca) {
+      throw new ArcaConfigurationError("WSMTXCA service is not configured");
+    }
+    return createWsmtxcaIssuanceService(wsmtxca);
+  };
+  return {
+    recover: async (key, options) => recoverOperation(
+      select,
+      key,
+      options === void 0 ? {} : options,
+      context
+    ),
+    issueDebitNote: async (input, options) => issueCreditNote(
+      select(options),
+      input,
+      options ?? {},
+      context,
+      "debitNote"
+    ),
+    previewCreditNote: async (input, options) => previewNote(
+      select(options),
+      input,
+      options ?? {},
+      context,
+      "creditNote"
+    ),
+    previewDebitNote: async (input, options) => previewNote(
+      select(options),
+      input,
+      options ?? {},
+      context,
+      "debitNote"
+    ),
+    issueCreditNote: async (input, options) => {
+      const result = await issueCreditNote(
+        select(options),
+        input,
+        options === void 0 ? {} : options,
+        context
+      );
+      return result;
+    },
+    issue: async (input, options) => {
+      const result = await issueInvoice(
+        select(options),
+        input,
+        options === void 0 ? {} : options,
+        context
+      );
+      return result;
+    },
+    preview: (input, options) => previewInvoice(
+      input,
+      options === void 0 ? {} : options
+    )
+  };
+}
+function previewInvoice(input, options) {
+  assertIssueObject(options, "options");
+  assertIssueKeys(options, ["representedTaxId", "service"], "options");
+  validateOptions(options);
+  if (options.representedTaxId !== void 0) {
+    issueDocumentNumber(
+      options.representedTaxId,
+      "options.representedTaxId",
+      11,
+      11
+    );
+  }
+  return toPreview(prepareInvoice(input, options), options);
+}
+function prepareInvoice(input, options) {
+  const prepared = deriveWsfeInvoice(input);
+  if (input.details !== void 0) {
+    prepared.data.details = structuredClone(input.details);
+  }
+  validatePrepared(prepared, options);
+  return prepared;
+}
+function validatePrepared(prepared, options) {
+  validateFiscalHeader(prepared.data);
+  if (options.service === "wsmtxca") {
+    wsmtxcaRequest(prepared.data);
+  } else if (prepared.data.details !== void 0) {
+    throw new ArcaInputError("Detailed items require service: wsmtxca", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "details"
+    });
+  }
+}
+function toPreview(prepared, options) {
+  const { data, voucherClass, amounts } = prepared;
+  return {
+    voucherClass,
+    voucherType: data.voucherType,
+    amounts,
+    request: options.service === "wsmtxca" ? wsmtxcaRequest(data) : data,
+    ...options.service === "wsmtxca" ? { service: "wsmtxca" } : {}
+  };
+}
+async function issueInvoice(wsfe, input, inputOptions, context) {
+  const options = structuredClone(inputOptions);
+  validateOptions(options);
+  validateKeyStore(options, context);
+  const prepared = prepareInvoice(input, options);
+  return await runOperation(
+    wsfe,
+    "issue",
+    input,
+    () => Promise.resolve(prepared),
+    options,
+    context,
+    prepared.amounts
+  );
+}
+async function runOperation(wsfe, operation, input, prepare, options, context, replayAmounts) {
+  const store = context?.store;
+  if (options.idempotencyKey === void 0 || !store || !context) {
+    return runAuthorization(wsfe, await prepare(), options);
+  }
+  const key = attemptKey(
+    context.environment,
+    context.taxId,
+    options.idempotencyKey
+  );
+  const representedTaxId = options.representedTaxId === void 0 ? void 0 : String(options.representedTaxId);
+  const inputHash = canonicalHash({
+    input,
+    representedTaxId,
+    ...options.service === "wsmtxca" ? { service: "wsmtxca" } : {},
+    ...options.number === void 0 ? {} : { number: options.number }
+  });
+  const existing = await storeCall(() => store.get(key));
+  if (existing !== null) {
+    return replay(existing);
+  }
+  const prepared = await prepare();
+  const number = await nextNumber(wsfe, prepared.data, options);
+  const service = options.service ?? "wsfe";
+  const versioned = service === "wsmtxca" || prepared.data.details !== void 0;
+  const record = {
+    v: versioned ? 2 : 1,
+    operation,
+    ...versioned ? { service } : {},
+    representedTaxId,
+    inputHash,
+    number,
+    salesPoint: prepared.data.salesPoint,
+    voucherType: prepared.data.voucherType,
+    sent: prepared.data,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (await storeCall(() => store.add(key, JSON.stringify(record)))) {
+    return runAuthorization(wsfe, prepared, options, number);
+  }
+  const winner = await storeCall(() => store.get(key));
+  if (winner === null) {
+    throw new ArcaConfigurationError(
+      "ARCA reservation disappeared after atomic creation lost."
+    );
+  }
+  return replay(winner);
+  function replay(json) {
+    const stored = readRecord(json);
+    if ((stored.service ?? "wsfe") !== (options.service ?? "wsfe") || 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 runAuthorization(
+      wsfe,
+      {
+        ...preparedFromRecord(stored),
+        ...replayAmounts ? { amounts: replayAmounts } : {}
+      },
+      options,
+      stored.number,
+      true
+    );
+  }
+}
+function validateKeyStore(options, context) {
+  if (options.idempotencyKey === void 0) {
+    return;
+  }
+  if (typeof options.idempotencyKey !== "string" || options.idempotencyKey.length < 1 || options.idempotencyKey.length > 255) {
+    throw new ArcaInputError(
+      "idempotencyKey must contain 1 to 255 characters.",
+      { code: "ARCA_INPUT_INVALID_VALUE", field: "options.idempotencyKey" }
+    );
+  }
+  if (!context?.store) {
+    throw new ArcaConfigurationError(
+      'idempotencyKey requires a store. Add import { createPostgresStore } from "facturas"; and store: createPostgresStore({ query }) to createArcaClient().'
+    );
+  }
+}
+function readRecord(json) {
+  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 || !Number.isSafeInteger(record.number) || record.number < 1 || record.number > 99999999 || record.sent.salesPoint !== record.salesPoint || record.sent.voucherType !== record.voucherType) {
+      throw new Error("Invalid reservation structure");
+    }
+    normalizeWsfeVoucherInput(record.sent);
+    if (record.service !== void 0 && record.service !== "wsfe" && record.service !== "wsmtxca") {
+      throw new Error("Invalid provider");
+    }
+    if (record.service === "wsmtxca") {
+      wsmtxcaRequest(record.sent, record.number);
+    }
+    return record;
+  } catch (cause) {
+    throw new ArcaConfigurationError(
+      "Invalid ARCA reservation record; preserve it for reconciliation.",
+      { cause }
+    );
+  }
+}
+function preparedFromRecord(record) {
+  const sentTotal = Number(
+    normalizeArcaAmountToMinorUnits(record.sent.totalAmount, "totalAmount")
+  );
+  return {
+    data: record.sent,
+    voucherClass: voucherFamily(record.voucherType).voucherClass,
+    amounts: { computedTotal: sentTotal, sentTotal, vatAdjustment: 0 }
+  };
+}
+async function nextNumber(wsfe, data, options) {
+  if (options.number !== void 0) {
+    return options.number;
+  }
+  const number = await wsfe.getNextVoucherNumber({
+    representedTaxId: options.representedTaxId,
+    forceRefresh: options.forceRefresh,
+    salesPoint: data.salesPoint,
+    voucherType: data.voucherType
+  });
+  if (!Number.isSafeInteger(number) || number < 1 || number > 99999999) {
+    throw new ArcaServiceError(
+      "ARCA returned an invalid next voucher number.",
+      {
+        service: options.service ?? "wsfe",
+        operation: options.service === "wsmtxca" ? "consultarUltimoComprobanteAutorizado" : "FECompUltimoAutorizado"
+      }
+    );
+  }
+  return number;
+}
+async function runAuthorization(wsfe, { data, voucherClass, amounts }, options, reservedNumber, replay = false) {
+  const auth = {
+    representedTaxId: options.representedTaxId,
+    forceRefresh: options.forceRefresh
+  };
+  const includeRaw = options.include?.raw === true;
+  const includeExact = options.include?.exactInput === true;
+  const number = reservedNumber ?? await nextNumber(wsfe, data, options);
+  const attempted = {
+    salesPoint: data.salesPoint,
+    voucherType: data.voucherType,
+    number
+  };
+  const exact = exactEvidence(data, number, options, includeExact);
+  const voucher = (cae, caeExpiry) => ({
+    ...attempted,
+    voucherClass,
+    date: data.voucherDate,
+    cae,
+    caeExpiry,
+    amounts
+  });
+  const recovery = {
+    wsfe,
+    auth,
+    data,
+    attempted,
+    includeRaw,
+    exact,
+    voucher,
+    service: options.service
+  };
+  if (replay) {
+    const attempt2 = replayEvidence(options.service);
+    let lookup;
+    try {
+      lookup = await wsfe.lookupVoucher({ ...auth, ...attempted });
+    } catch (error) {
+      return {
+        kind: "indeterminate",
+        attempted,
+        attempt: attempt2,
+        lookup: { kind: "failed", error: toArcaSafeErrorMetadata(error) }
+      };
+    }
+    if (lookup.kind === "found") {
+      return recoverInvoice({ ...recovery, attempt: attempt2, lookup });
+    }
+  }
+  const authorization = await wsfe.issue({
+    ...auth,
+    data,
+    voucherNumber: number
+  });
+  if (authorization.kind === "authorized" && authorization.caeExpiry && authorization.voucherNumber === number) {
+    return {
+      kind: "authorized",
+      recoveredByMatch: false,
+      voucher: voucher(authorization.cae, authorization.caeExpiry),
+      authorization: projectEvidence(authorization, includeRaw),
+      ...exact
+    };
+  }
+  if (authorization.kind === "rejected") {
+    if (options.idempotencyKey !== void 0 && (options.service === "wsmtxca" || [...authorization.errors, ...authorization.observations].some(
+      (issue) => issue.code === "10016"
+    ))) {
+      const recovered = await recoverInvoice({
+        ...recovery,
+        attempt: projectEvidence(
+          {
+            ...authorization,
+            kind: "indeterminate",
+            reason: "contradictory_response"
+          },
+          includeRaw
+        )
+      });
+      if (recovered.kind === "authorized" || recovered.kind === "conflict") {
+        return recovered;
+      }
+    }
+    return {
+      kind: "rejected",
+      attempted,
+      issues: [...authorization.errors, ...authorization.observations].map(
+        projectIssue
+      ),
+      authorization: projectEvidence(authorization, includeRaw)
+    };
+  }
+  const uncertain = authorization.kind === "indeterminate" ? authorization : {
+    ...authorization,
+    kind: "indeterminate",
+    reason: authorization.voucherNumber === number ? "incomplete_response" : "contradictory_response"
+  };
+  const attempt = projectEvidence(uncertain, includeRaw);
+  return recoverInvoice({
+    wsfe,
+    service: options.service,
+    auth,
+    data,
+    attempted,
+    attempt,
+    includeRaw,
+    exact,
+    voucher
+  });
+}
+async function recoverInvoice({
+  wsfe,
+  auth,
+  data,
+  attempted,
+  attempt,
+  includeRaw,
+  exact,
+  voucher,
+  lookup: suppliedLookup,
+  service
+}) {
+  let lookup;
+  try {
+    lookup = suppliedLookup ?? await wsfe.lookupVoucher({ ...auth, ...attempted });
+  } catch (error) {
+    return {
+      kind: "indeterminate",
+      attempted,
+      attempt,
+      lookup: { kind: "failed", error: toArcaSafeErrorMetadata(error) }
+    };
+  }
+  const raw = includeRaw ? { raw: lookup.raw } : {};
+  if (lookup.kind === "not_found") {
+    return {
+      kind: "indeterminate",
+      attempted,
+      attempt,
+      lookup: { kind: "not_found", ...raw }
+    };
+  }
+  const detailsMatch = service === "wsmtxca" ? matchWsmtxcaDetails(data, attempted.number, lookup.voucher.raw) : void 0;
+  const matched = detailsMatch === void 0 ? matchWsfeVoucherIdentity(data, attempted.number, lookup.voucher) : detailsMatch === "match" && lookup.voucher.cae && lookup.voucher.caeExpiry ? { matches: true } : {
+    matches: false,
+    evidence: detailsMatch === "conflict" ? "conflict" : "incomplete",
+    reason: "WSMTXCA consultation does not match the complete reserved request"
+  };
+  if (!matched.matches) {
+    if (matched.evidence === "conflict") {
+      return {
+        kind: "conflict",
+        attempted,
+        attempt,
+        found: { ...toVoucherSummary(lookup.voucher), ...raw },
+        reason: `${matched.reason}. Configure a store and pass idempotencyKey for retries.`
+      };
+    }
+    return {
+      kind: "indeterminate",
+      attempted,
+      attempt,
+      lookup: { kind: "incomplete", reason: matched.reason, ...raw }
+    };
+  }
+  return {
+    kind: "authorized",
+    recoveredByMatch: true,
+    voucher: voucher(
+      lookup.voucher.cae,
+      lookup.voucher.caeExpiry
+    ),
+    attempt,
+    lookup: { ...toVoucherSummary(lookup.voucher), ...raw },
+    ...exact
+  };
+}
+function projectIssue(issue) {
+  return {
+    service: issue.service,
+    operation: issue.operation,
+    source: issue.source,
+    category: issue.category,
+    message: issue.message,
+    ...issue.code === void 0 ? {} : { code: issue.code },
+    ...issue.resultLevel === void 0 ? {} : { resultLevel: issue.resultLevel }
+  };
+}
+function projectEvidence(evidence, includeRaw) {
+  const base = {
+    kind: evidence.kind,
+    service: evidence.service,
+    operation: evidence.operation,
+    results: {
+      ...evidence.results.header === void 0 ? {} : { header: evidence.results.header },
+      ...evidence.results.detail === void 0 ? {} : { detail: evidence.results.detail },
+      ...evidence.results.operation === void 0 ? {} : { operation: evidence.results.operation }
+    },
+    errors: evidence.errors.map(projectIssue),
+    observations: evidence.observations.map(projectIssue),
+    ...includeRaw && evidence.raw !== void 0 ? { raw: evidence.raw } : {}
+  };
+  const projected = { ...base };
+  for (const field of [
+    "result",
+    "resultLevel",
+    "cae",
+    "caeExpiry",
+    "voucherNumber",
+    "reason"
+  ]) {
+    if (field in evidence && evidence[field] !== void 0) {
+      projected[field] = evidence[field];
+    }
+  }
+  if (evidence.kind === "indeterminate" && evidence.authentication) {
+    const { code, reason, providerCode } = evidence.authentication;
+    projected.authentication = {
+      code,
+      reason,
+      ...providerCode === void 0 ? {} : { providerCode }
+    };
+  }
+  return projected;
+}
+function validateOptions(options) {
+  assertIssueObject(options, "options");
+  assertIssueKeys(
+    options,
+    [
+      "representedTaxId",
+      "forceRefresh",
+      "include",
+      "idempotencyKey",
+      "service",
+      "number"
+    ],
+    "options"
+  );
+  if (options.service !== void 0 && options.service !== "wsfe" && options.service !== "wsmtxca") {
+    throw new ArcaInputError("Unknown fiscal service", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "options.service"
+    });
+  }
+  if (options.number !== void 0 && (!Number.isSafeInteger(options.number) || options.number < 1 || options.number > 99999999)) {
+    throw new ArcaInputError("Invalid reserved number", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "options.number"
+    });
+  }
+  if (options.representedTaxId !== void 0) {
+    issueDocumentNumber(
+      options.representedTaxId,
+      "options.representedTaxId",
+      11,
+      11
+    );
+  }
+  if (options.forceRefresh !== void 0 && typeof options.forceRefresh !== "boolean") {
+    throw new ArcaInputError("options.forceRefresh must be a boolean.", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "options.forceRefresh"
+    });
+  }
+  if (options.include !== void 0) {
+    assertIssueObject(options.include, "options.include");
+    assertIssueKeys(options.include, ["raw", "exactInput"], "options.include");
+    for (const field of ["raw", "exactInput"]) {
+      if (options.include[field] !== void 0 && typeof options.include[field] !== "boolean") {
+        throw new ArcaInputError(
+          `options.include.${field} must be a boolean.`,
+          {
+            code: "ARCA_INPUT_INVALID_VALUE",
+            field: `options.include.${field}`
+          }
+        );
+      }
+    }
+  }
+}
+function replayEvidence(service = "wsfe") {
+  return {
+    kind: "indeterminate",
+    service,
+    operation: service === "wsfe" ? "FECAESolicitar" : "autorizarComprobante",
+    reason: "incomplete_response",
+    results: {},
+    errors: [],
+    observations: []
+  };
+}
+async function issueCreditNote(wsfe, input, inputOptions, context, kind = "creditNote") {
+  const options = structuredClone(inputOptions);
+  validateOptions(options);
+  validateKeyStore(options, context);
+  assertIssueObject(input, "input");
+  const note = "associatedPeriod" in input && !("for" in input) ? structuredClone(input) : assertCreditNoteInput(input);
+  if (kind === "debitNote" && "all" in note && note.all) {
+    throw new ArcaInputError("Debit notes require explicit items", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "items"
+    });
+  }
+  return await runOperation(
+    wsfe,
+    kind,
+    note,
+    () => prepareNote(wsfe, note, options, context, kind),
+    options,
+    context
+  );
+}
+async function previewNote(wsfe, input, inputOptions, context, kind) {
+  const options = structuredClone(inputOptions);
+  assertIssueKeys(
+    options,
+    ["representedTaxId", "service", "forceRefresh"],
+    "options"
+  );
+  return toPreview(
+    await prepareNote(wsfe, input, options, context, kind),
+    options
+  );
+}
+async function prepareNote(wsfe, input, options, context, kind) {
+  validateOptions(options);
+  assertIssueObject(input, "input");
+  if ("associatedPeriod" in input && !("for" in input)) {
+    return preparePeriodNote(input, options, kind);
+  }
+  const note = assertCreditNoteInput(input);
+  if (kind === "debitNote" && note.all) {
+    throw new ArcaInputError("Debit notes require explicit items", {
+      code: "ARCA_INPUT_INVALID_VALUE"
+    });
+  }
+  const target = note.for;
+  const original = await wsfe.lookupVoucher({
+    representedTaxId: options.representedTaxId,
+    forceRefresh: options.forceRefresh,
+    ...target
+  });
+  if (original.kind !== "found") {
+    throw new ArcaInputError(
+      "issueCreditNote failed: original voucher not found",
+      { code: "ARCA_INPUT_INVALID_VALUE", field: "input.for" }
+    );
+  }
+  if (original.voucher.salesPoint !== target.salesPoint || original.voucher.voucherType !== target.voucherType || original.voucher.voucherNumber !== target.number) {
+    throw new ArcaInputError(
+      "Original lookup coordinates do not match input.for",
+      { code: "ARCA_INPUT_INVALID_VALUE", field: "input.for" }
+    );
+  }
+  const prepared = note.all === true ? deriveWsfeFullCreditNote(original.voucher, note) : deriveWsfePartialCreditNote(original.voucher, note, /* @__PURE__ */ new Date(), kind);
+  if (note.details !== void 0) {
+    prepared.data.details = structuredClone(note.details);
+  } else if (note.all && "details" in original.voucher) {
+    prepared.data.details = structuredClone(
+      original.voucher.details
+    );
+  }
+  if (voucherFamily(prepared.data.voucherType).family === "fce") {
+    const taxId = options.representedTaxId ?? context?.taxId;
+    if (!taxId) {
+      throw new ArcaInputError("FCE association requires the issuer tax ID", {
+        code: "ARCA_INPUT_MISSING_FIELD",
+        field: "representedTaxId"
+      });
+    }
+    for (const associated of prepared.data.associatedVouchers ?? []) {
+      associated.taxId = String(taxId);
+    }
+  }
+  validatePrepared(prepared, options);
+  return prepared;
+}
+function preparePeriodNote(input, options, kind) {
+  const { associatedPeriod, ...invoice } = input;
+  assertIssueObject(associatedPeriod, "associatedPeriod");
+  assertIssueKeys(associatedPeriod, ["from", "to"], "associatedPeriod");
+  if (normalizeWsfeDateInput(associatedPeriod.from, "associatedPeriod.from") > normalizeWsfeDateInput(associatedPeriod.to, "associatedPeriod.to")) {
+    throw new ArcaInputError("Associated period starts after its end", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "associatedPeriod"
+    });
+  }
+  const prepared = prepareInvoice(invoice, options);
+  const family = voucherFamily(prepared.data.voucherType);
+  if (family.family === "fce") {
+    throw new ArcaInputError("FCE notes require an associated invoice", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "associatedPeriod"
+    });
+  }
+  prepared.data.voucherType = family.types[kind === "creditNote" ? 2 : 1];
+  prepared.data.associatedPeriod = {
+    startDate: associatedPeriod.from,
+    endDate: associatedPeriod.to
+  };
+  normalizeWsfeVoucherInput(prepared.data);
+  validatePrepared(prepared, options);
+  return prepared;
+}
+function exactEvidence(data, number, options, include) {
+  return include ? {
+    sent: options.service === "wsmtxca" ? wsmtxcaRequest(data, number) : data
+  } : {};
+}
+async function recoverOperation(select, key, inputOptions, context) {
+  const options = structuredClone(inputOptions);
+  assertIssueObject(options, "options");
+  assertIssueKeys(
+    options,
+    ["representedTaxId", "forceRefresh", "include"],
+    "options"
+  );
+  validateOptions(options);
+  validateKeyStore({ ...options, idempotencyKey: key }, context);
+  const json = await storeCall(
+    () => context.store.get(
+      attemptKey(
+        context.environment,
+        context.taxId,
+        key
+      )
+    )
+  );
+  if (json === null) {
+    throw new ArcaInputError("No reservation exists for this idempotency key", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "idempotencyKey"
+    });
+  }
+  const record = readRecord(json);
+  if (options.representedTaxId !== void 0 && String(options.representedTaxId) !== (record.representedTaxId ?? context?.taxId)) {
+    throw new ArcaInputError(
+      "Reservation belongs to another represented taxpayer",
+      { code: "ARCA_INPUT_IDEMPOTENCY_MISMATCH" }
+    );
+  }
+  const storedOptions = {
+    ...options,
+    service: record.service ?? "wsfe",
+    representedTaxId: record.representedTaxId
+  };
+  const prepared = preparedFromRecord(record);
+  return recoverInvoice({
+    wsfe: select(storedOptions),
+    service: storedOptions.service,
+    auth: storedOptions,
+    data: prepared.data,
+    attempted: {
+      salesPoint: record.salesPoint,
+      voucherType: record.voucherType,
+      number: record.number
+    },
+    attempt: replayEvidence(storedOptions.service),
+    includeRaw: options.include?.raw === true,
+    exact: exactEvidence(
+      prepared.data,
+      record.number,
+      storedOptions,
+      options.include?.exactInput === true
+    ),
+    voucher: (cae, caeExpiry) => ({
+      salesPoint: record.salesPoint,
+      voucherType: record.voucherType,
+      number: record.number,
+      voucherClass: prepared.voucherClass,
+      date: prepared.data.voucherDate,
+      amounts: prepared.amounts,
+      cae,
+      caeExpiry
+    })
+  });
+}
+
+// src/soap/index.ts
+function createSoapTransport(options) {
+  return {
+    async execute(request) {
+      const serviceConfig = getArcaServiceConfig(request.service);
+      const url = serviceConfig.endpoint[options.config.environment];
+      const soapActionOperation = request.operation;
+      const bodyElementName = request.bodyElementName ?? request.operation;
+      const soapAction = serviceConfig.usesEmptySoapAction ? "" : `${serviceConfig.soapActionBase}${soapActionOperation}`;
+      const contentType = serviceConfig.soapVersion === "1.2" ? `application/soap+xml; charset=utf-8; action="${soapAction}"` : 'text/xml; charset="utf-8"';
+      const xml = buildSoapEnvelope(
+        serviceConfig.soapVersion,
+        bodyElementName,
+        serviceConfig.namespace,
+        request.body,
+        {
+          namespaceMode: request.bodyElementNamespaceMode
+        }
+      );
+      const startedAt = Date.now();
+      options.logger?.debug("Sending ARCA SOAP request", {
+        service: request.service,
+        operation: request.operation,
+        url
+      });
+      try {
+        const response = await postXmlWithMetadata({
+          url,
+          body: xml,
+          contentType,
+          soapAction: serviceConfig.soapVersion === "1.1" ? soapAction : void 0,
+          useLegacyTlsSecurityLevel0: options.config.environment === "production" && serviceConfig.useLegacyTlsSecurityLevel0 === true,
+          timeout: options.config.timeout,
+          retries: request.retries ?? options.config.retries,
+          retryDelay: options.config.retryDelay,
+          logger: options.logger,
+          service: request.service,
+          operation: request.operation
+        });
+        options.logger?.debug("Received ARCA SOAP response", {
+          service: request.service,
+          operation: request.operation,
+          durationMs: Date.now() - startedAt
+        });
+        const parseContext = {
+          service: request.service,
+          operation: request.operation,
+          endpointUrl: url,
+          statusCode: response.statusCode,
+          contentType: response.contentType,
+          responseBody: response.body
+        };
+        const soapBody = parseSoapBody(response.body, parseContext);
+        const [, result] = getSingleBodyEntry(
+          soapBody,
+          parseContext
+        );
+        return {
+          service: request.service,
+          operation: request.operation,
+          raw: response.body,
+          result
+        };
+      } catch (error) {
+        if (error instanceof ArcaSoapFaultError) {
+          options.logger?.error("ARCA SOAP fault response", {
+            service: request.service,
+            operation: request.operation,
+            url,
+            ...createSafeErrorDiagnostic(error)
+          });
+        }
+        if (error instanceof ArcaInvalidSoapResponseError) {
+          options.logger?.error("ARCA invalid SOAP response", {
+            service: request.service,
+            operation: request.operation,
+            url,
+            ...createSafeErrorDiagnostic(error)
+          });
+        }
+        throw error;
+      }
+    }
+  };
+}
+
+// src/wsaa/store-adapter.ts
+function createWsaaStoreAdapter(store) {
+  const key = (value) => `arca:v1:wsaa:${serializeWsaaSessionKey(value)}`;
+  const remove = store.delete?.bind(store);
+  const lock = store.withLock?.bind(store);
+  return {
+    get: (value) => storeCall(async () => {
+      const json = await store.get(key(value));
+      if (json === null) {
+        return null;
+      }
+      const credentials = JSON.parse(json);
+      return credentials && typeof credentials.token === "string" && typeof credentials.sign === "string" && isWsaaCredentialValid(credentials) ? credentials : null;
+    }),
+    set: (value, credentials) => storeCall(() => store.set(key(value), JSON.stringify(credentials))),
+    ...remove ? {
+      delete: (value) => storeCall(() => remove(key(value)))
+    } : {},
+    ...lock ? {
+      withLock: (value, fn) => lock(key(value), fn)
+    } : {}
+  };
+}
+
+// src/client.ts
+function createArcaClient(config = {}) {
+  const discovered = discoverArcaClientConfig(config);
+  assertArcaClientConfig(discovered);
+  const normalizedConfig = normalizeArcaClientConfig(discovered);
+  if (normalizedConfig.store && !normalizedConfig.wsaaSessionStore) {
+    normalizedConfig.wsaaSessionStore = createWsaaStoreAdapter(
+      normalizedConfig.store
+    );
+  }
+  const logger = createArcaLogger(normalizedConfig.logger);
+  const auth = createWsaaAuthModule({ config: normalizedConfig, logger });
+  const soap = createSoapTransport({ config: normalizedConfig, logger });
+  const publicConfig = Object.freeze({
+    taxId: normalizedConfig.taxId,
+    environment: normalizedConfig.environment,
+    timeout: normalizedConfig.timeout,
+    retries: normalizedConfig.retries,
+    retryDelay: normalizedConfig.retryDelay
+  });
+  const wsfe = createWsfeService({ config: normalizedConfig, auth, soap });
+  const wsmtxca = createWsmtxcaService({
+    config: normalizedConfig,
+    auth,
+    soap
+  });
+  const vouchers = createVouchersService(wsfe, normalizedConfig, wsmtxca);
+  return {
+    config: publicConfig,
+    issue: vouchers.issue,
+    preview: vouchers.preview,
+    issueCreditNote: vouchers.issueCreditNote,
+    recover: vouchers.recover,
+    issueDebitNote: vouchers.issueDebitNote,
+    previewCreditNote: vouchers.previewCreditNote,
+    previewDebitNote: vouchers.previewDebitNote,
+    wsfe,
+    wsmtxca,
+    padron: createPadronService({ config: normalizedConfig, auth, soap })
+  };
+}
+
+// src/store/file.ts
+import { createHash as createHash3, randomUUID } from "crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import { join } from "path";
+function createFileStore(directory) {
+  const path = (key) => join(directory, createHash3("sha256").update(key).digest("hex"));
+  const ensure = () => mkdir(directory, { recursive: true, mode: 448 });
+  return {
+    get: (key) => storeCall(async () => {
+      try {
+        return await readFile(path(key), "utf8");
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return null;
+        }
+        throw error;
+      }
+    }),
+    set: (key, value) => storeCall(async () => {
+      await ensure();
+      const temporary = `${path(key)}.${randomUUID()}.tmp`;
+      try {
+        await writeFile(temporary, value, { mode: 384, flag: "wx" });
+        await rename(temporary, path(key));
+      } finally {
+        await unlink(temporary).catch(() => void 0);
+      }
+    }),
+    add: (key, value) => storeCall(async () => {
+      await ensure();
+      try {
+        await writeFile(path(key), value, { flag: "wx", mode: 384 });
+        return true;
+      } catch (error) {
+        if (error.code === "EEXIST") {
+          return false;
+        }
+        throw error;
+      }
+    }),
+    delete: (key) => storeCall(async () => {
+      try {
+        await unlink(path(key));
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
+    })
+  };
+}
+
+export {
+  ARCA_ENVIRONMENTS,
+  ARCA_ENV_VARIABLES,
+  resolveArcaEnvironment,
+  createArcaClientConfigFromEnv,
+  assertArcaClientConfig,
+  ARCA_WSAA_CONFIG,
+  discoverArcaClientConfig,
+  storeCall,
+  matchWsfeVoucherIdentity,
+  createMemoryWsaaSessionStore,
+  createWsaaAuthModule,
+  createWsaaStoreAdapter,
+  createArcaClient,
+  createFileStore
+};
+//# sourceMappingURL=chunk-LOWV7IF6.mjs.map