@dynamicore/jumio-sdk 1.0.1 → 1.0.2

package/dist/index.js

@@ -7,86 +7,81 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var axios__default = /*#__PURE__*/_interopDefault(axios);
 
-// src/core/errors.ts
-var JumioError = class extends Error {
-  isJumioError = true;
-  statusCode;
-  rawData;
-  code;
-  constructor(message, options) {
-    super(message);
-    this.name = "JumioError";
-    this.statusCode = options?.statusCode;
-    this.rawData = options?.rawData;
-    this.code = options?.code;
-    if (options?.cause) {
-      this.cause = options.cause;
-    }
-  }
-};
-var JumioTimeoutError = class extends JumioError {
-  constructor(message = "El servicio de verificaci\xF3n de Jumio excedi\xF3 el tiempo l\xEDmite de espera.", rawData) {
-    super(message, { code: "TIMEOUT", rawData });
-    this.name = "JumioTimeoutError";
-  }
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var JumioNetworkError = class extends JumioError {
-  constructor(message = "No fue posible comunicarse con los servidores de validaci\xF3n de identidad.", cause) {
-    super(message, { code: "NETWORK_ERROR", cause });
-    this.name = "JumioNetworkError";
-  }
-};
-var JumioValidationError = class extends JumioError {
-  constructor(message = "El documento no pudo ser validado o fue rechazado por Jumio.", rawData) {
-    super(message, { code: "VALIDATION_FAILED", rawData });
-    this.name = "JumioValidationError";
-  }
-};
-var JumioImageProcessingError = class extends JumioError {
-  constructor(message, cause) {
-    super(message, { code: "IMAGE_PROCESSING_ERROR", cause });
-    this.name = "JumioImageProcessingError";
-  }
-};
-var JumioPollingTimeoutError = class extends JumioError {
-  attempts;
-  constructor(attempts, message = "La validaci\xF3n sigue en proceso. Por favor verifica nuevamente m\xE1s tarde.", rawData) {
-    super(message, { code: "POLLING_TIMEOUT", rawData });
-    this.name = "JumioPollingTimeoutError";
-    this.attempts = attempts;
-  }
-};
-var JumioAbortError = class extends JumioError {
-  constructor(message = "La operaci\xF3n de validaci\xF3n de Jumio fue cancelada.") {
-    super(message, { code: "ABORTED" });
-    this.name = "JumioAbortError";
-  }
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
+
+// src/core/errors.ts
 function isJumioError(error) {
-  return error instanceof JumioError || typeof error === "object" && error !== null && "isJumioError" in error && error.isJumioError === true;
+  return error instanceof exports.JumioError || typeof error === "object" && error !== null && "isJumioError" in error && error.isJumioError === true;
 }
+exports.JumioError = void 0; exports.JumioTimeoutError = void 0; exports.JumioNetworkError = void 0; exports.JumioValidationError = void 0; exports.JumioImageProcessingError = void 0; exports.JumioPollingTimeoutError = void 0; exports.JumioAbortError = void 0;
+var init_errors = __esm({
+  "src/core/errors.ts"() {
+    exports.JumioError = class extends Error {
+      isJumioError = true;
+      statusCode;
+      rawData;
+      code;
+      constructor(message, options) {
+        super(message);
+        this.name = "JumioError";
+        this.statusCode = options?.statusCode;
+        this.rawData = options?.rawData;
+        this.code = options?.code;
+        if (options?.cause) {
+          this.cause = options.cause;
+        }
+      }
+    };
+    exports.JumioTimeoutError = class extends exports.JumioError {
+      constructor(message = "El servicio de verificaci\xF3n de Jumio excedi\xF3 el tiempo l\xEDmite de espera.", rawData) {
+        super(message, { code: "TIMEOUT", rawData });
+        this.name = "JumioTimeoutError";
+      }
+    };
+    exports.JumioNetworkError = class extends exports.JumioError {
+      constructor(message = "No fue posible comunicarse con los servidores de validaci\xF3n de identidad.", cause) {
+        super(message, { code: "NETWORK_ERROR", cause });
+        this.name = "JumioNetworkError";
+      }
+    };
+    exports.JumioValidationError = class extends exports.JumioError {
+      constructor(message = "El documento no pudo ser validado o fue rechazado por Jumio.", rawData) {
+        super(message, { code: "VALIDATION_FAILED", rawData });
+        this.name = "JumioValidationError";
+      }
+    };
+    exports.JumioImageProcessingError = class extends exports.JumioError {
+      constructor(message, cause) {
+        super(message, { code: "IMAGE_PROCESSING_ERROR", cause });
+        this.name = "JumioImageProcessingError";
+      }
+    };
+    exports.JumioPollingTimeoutError = class extends exports.JumioError {
+      attempts;
+      constructor(attempts, message = "La validaci\xF3n sigue en proceso. Por favor verifica nuevamente m\xE1s tarde.", rawData) {
+        super(message, { code: "POLLING_TIMEOUT", rawData });
+        this.name = "JumioPollingTimeoutError";
+        this.attempts = attempts;
+      }
+    };
+    exports.JumioAbortError = class extends exports.JumioError {
+      constructor(message = "La operaci\xF3n de validaci\xF3n de Jumio fue cancelada.") {
+        super(message, { code: "ABORTED" });
+        this.name = "JumioAbortError";
+      }
+    };
+  }
+});
 
 // src/core/envelope.ts
-var FINAL_JUMIO_STATUSES = [
-  "PROCESSED",
-  "APPROVED_VERIFIED",
-  "REJECTED",
-  "FAILED",
-  "ERROR",
-  "DENIED",
-  "EXPIRED",
-  "ABANDONED",
-  "DONE",
-  "COMPLETED",
-  "NOT_READABLE",
-  "FRAUD",
-  "UNSUPPORTED_ID_TYPE"
-];
-var APPROVED_JUMIO_STATUSES = [
-  "APPROVED_VERIFIED",
-  "DONE",
-  "COMPLETED"
-];
 function toLowerText(value) {
   return String(value ?? "").trim().toLowerCase();
 }
@@ -94,10 +89,13 @@ function toUpperText(value) {
   return String(value ?? "").trim().toUpperCase();
 }
 function extractEnvelopeData(responseData) {
-  if (responseData && typeof responseData === "object" && "data" in responseData) {
-    const candidate = responseData.data;
-    if (candidate !== void 0) {
-      return candidate;
+  if (responseData && typeof responseData === "object") {
+    const obj = responseData;
+    if ("data" in obj && obj.data !== void 0) {
+      return obj.data;
+    }
+    if ("values" in obj && obj.values !== void 0) {
+      return obj.values;
     }
   }
   return responseData;
@@ -149,7 +147,7 @@ function extractJumioMessage(source) {
 function isFinalJumioStatus(status) {
   const upperStatus = toUpperText(status);
   if (!upperStatus) return false;
-  return FINAL_JUMIO_STATUSES.some((s) => s === upperStatus);
+  return exports.FINAL_JUMIO_STATUSES.some((s) => s === upperStatus);
 }
 function isApprovedJumioStatus(status) {
   const upperStatus = toUpperText(status);
@@ -168,12 +166,54 @@ function resolveVerificationValidity(data, fallbackStatus) {
   }
   return isApprovedJumioStatus(fallbackStatus);
 }
+function encodeUrlToBase64UrlSafe(url) {
+  try {
+    let base64;
+    if (typeof Buffer !== "undefined") {
+      base64 = Buffer.from(url, "utf-8").toString("base64");
+    } else if (typeof TextEncoder !== "undefined") {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(url);
+      base64 = btoa(String.fromCharCode(...new Uint8Array(data)));
+    } else {
+      base64 = btoa(url);
+    }
+    return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  } catch {
+    return null;
+  }
+}
+exports.FINAL_JUMIO_STATUSES = void 0; exports.APPROVED_JUMIO_STATUSES = void 0;
+var init_envelope = __esm({
+  "src/core/envelope.ts"() {
+    exports.FINAL_JUMIO_STATUSES = [
+      "PROCESSED",
+      "APPROVED_VERIFIED",
+      "REJECTED",
+      "FAILED",
+      "ERROR",
+      "DENIED",
+      "EXPIRED",
+      "ABANDONED",
+      "DONE",
+      "COMPLETED",
+      "NOT_READABLE",
+      "FRAUD",
+      "UNSUPPORTED_ID_TYPE"
+    ];
+    exports.APPROVED_JUMIO_STATUSES = [
+      "APPROVED_VERIFIED",
+      "DONE",
+      "COMPLETED"
+    ];
+  }
+});
 
 // src/core/retry.ts
 function delay(ms, signal) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
-      return reject(new JumioAbortError());
+      return reject(new exports.JumioAbortError());
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", abortHandler);
@@ -181,7 +221,7 @@ function delay(ms, signal) {
     }, ms);
     const abortHandler = () => {
       clearTimeout(timer);
-      reject(new JumioAbortError());
+      reject(new exports.JumioAbortError());
     };
     signal?.addEventListener("abort", abortHandler, { once: true });
   });
@@ -215,14 +255,14 @@ async function withRetry(operation, options = {}) {
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt += 1) {
     if (signal?.aborted) {
-      throw new JumioAbortError();
+      throw new exports.JumioAbortError();
     }
     try {
       return await operation(attempt);
     } catch (error) {
       lastError = error;
       if (signal?.aborted) {
-        throw new JumioAbortError();
+        throw new exports.JumioAbortError();
       }
       const isLastAttempt = attempt >= maxRetries;
       const isRetryable = shouldRetry(error);
@@ -239,8 +279,268 @@ async function withRetry(operation, options = {}) {
   }
   throw lastError;
 }
+var init_retry = __esm({
+  "src/core/retry.ts"() {
+    init_envelope();
+    init_errors();
+  }
+});
+
+// src/core/webflow.ts
+var webflow_exports = {};
+__export(webflow_exports, {
+  buildRedirectUrl: () => buildRedirectUrl,
+  parseWebflowReturnParams: () => parseWebflowReturnParams,
+  pollWebflowStatus: () => pollWebflowStatus,
+  resolveWebflowResult: () => resolveWebflowResult,
+  startWebflowSession: () => startWebflowSession
+});
+function buildRedirectUrl(returnUrl, proxyUrl) {
+  if (!proxyUrl) {
+    return returnUrl;
+  }
+  const encoded = encodeUrlToBase64UrlSafe(returnUrl);
+  if (!encoded) {
+    throw new exports.JumioValidationError(
+      `No fue posible codificar la URL de retorno: "${returnUrl}"`
+    );
+  }
+  const normalizedProxy = proxyUrl.endsWith("/") ? proxyUrl : `${proxyUrl}/`;
+  return `${normalizedProxy}${encoded}`;
+}
+function parseWebflowReturnParams(source) {
+  let searchString;
+  if (!source) {
+    if (typeof window !== "undefined" && window.location) {
+      searchString = window.location.search;
+    } else {
+      return { allParams: {} };
+    }
+  } else if (typeof source === "string") {
+    const questionIdx = source.indexOf("?");
+    searchString = questionIdx >= 0 ? source.slice(questionIdx) : "";
+  } else if (source instanceof URLSearchParams) {
+    searchString = `?${source.toString()}`;
+  } else {
+    const hrefSearch = source.href ? (() => {
+      try {
+        return new URL(source.href).search;
+      } catch {
+        return "";
+      }
+    })() : "";
+    searchString = source.search ?? hrefSearch;
+  }
+  const params = new URLSearchParams(searchString);
+  const allParams = {};
+  params.forEach((value, key) => {
+    allParams[key] = value;
+  });
+  const accountId = params.get("accountId") ?? void 0;
+  let workflowId = params.get("workflowExecutionId") ?? params.get("workflowId") ?? void 0;
+  const rawStatus = params.get("status") ?? void 0;
+  if (rawStatus && (!accountId || !workflowId)) {
+    const statusParts = rawStatus.split("?");
+    const nestedSearch = statusParts.length > 1 ? `?${statusParts.slice(1).join("?")}` : "";
+    if (nestedSearch && nestedSearch !== "?") {
+      const nestedParams = new URLSearchParams(nestedSearch);
+      nestedParams.forEach((value, key) => {
+        if (!allParams[key]) allParams[key] = value;
+      });
+      if (!workflowId) {
+        workflowId = nestedParams.get("workflowExecutionId") ?? nestedParams.get("workflowId") ?? workflowId;
+      }
+    }
+  }
+  return {
+    accountId: accountId || void 0,
+    workflowId: workflowId || void 0,
+    rawStatus,
+    allParams
+  };
+}
+function resolveWebflowResult(rawData, accountId, workflowId) {
+  if (!rawData || typeof rawData !== "object") return null;
+  const data = rawData;
+  if (data.valid === true) {
+    return {
+      valid: true,
+      status: String(data.workflowStatus ?? data.status ?? "APPROVED_VERIFIED"),
+      decision: data.decision,
+      extraction: data.extraction,
+      accountId,
+      workflowId,
+      data: rawData
+    };
+  }
+  if (data.valid === false) {
+    return {
+      valid: false,
+      status: String(data.workflowStatus ?? data.status ?? "REJECTED"),
+      decision: data.decision,
+      accountId,
+      workflowId,
+      data: rawData,
+      errorMessage: extractJumioMessage(rawData) || "El documento fue rechazado durante la verificacion."
+    };
+  }
+  const capData = data;
+  const decisionType = capData?.decision?.type;
+  const extractionArr = capData?.capabilities?.extraction ?? [];
+  const extraction = extractionArr[0];
+  const isExtractionEmpty = extraction !== void 0 && Object.keys(extraction).length === 0;
+  if (decisionType === "REJECTED") {
+    return {
+      valid: false,
+      status: "REJECTED",
+      decision: decisionType,
+      accountId,
+      workflowId,
+      data: rawData,
+      errorMessage: extractJumioMessage(rawData) || "El documento fue rechazado por Jumio."
+    };
+  }
+  if (extraction && !isExtractionEmpty) {
+    const isApproved = decisionType === "PASSED" || decisionType === "WARNING";
+    return {
+      valid: isApproved,
+      status: isApproved ? decisionType ?? "PASSED" : decisionType ?? "REJECTED",
+      decision: decisionType,
+      extraction,
+      accountId,
+      workflowId,
+      data: rawData,
+      ...!isApproved ? {
+        errorMessage: extractJumioMessage(rawData) || "La verificacion no fue aprobada."
+      } : {}
+    };
+  }
+  return null;
+}
+async function pollWebflowStatus(http, params, options = {}) {
+  const config = http.getConfig();
+  const maxAttempts = options.maxAttempts ?? config.maxPollingAttempts ?? 20;
+  const intervalMs = options.pollingIntervalMs ?? config.pollingIntervalMs ?? 1e4;
+  const signal = options.signal;
+  let lastRawData = {};
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (signal?.aborted) {
+      throw new exports.JumioAbortError();
+    }
+    const responseData = await withRetry(
+      () => http.getVerificationStatus(params.accountId, params.workflowId, {
+        signal,
+        timeout: config.statusTimeout,
+        clientId: params.clientId
+      }),
+      {
+        maxRetries: config.maxRetries ?? 3,
+        initialDelayMs: config.retryDelayMs ?? 800,
+        signal
+      }
+    );
+    const firstLevel = extractEnvelopeData(responseData);
+    const statusData = extractNestedData(firstLevel) ?? {};
+    lastRawData = statusData;
+    options.onAttempt?.(attempt, maxAttempts, statusData);
+    const result = resolveWebflowResult(
+      statusData,
+      params.accountId,
+      params.workflowId
+    );
+    if (result !== null) {
+      return result;
+    }
+    if (attempt < maxAttempts) {
+      await delay(intervalMs, signal);
+    }
+  }
+  const lastMessage = extractJumioMessage(lastRawData) || "La verificacion Jumio sigue en proceso. Intenta nuevamente en unos momentos.";
+  throw new exports.JumioPollingTimeoutError(maxAttempts, lastMessage, lastRawData);
+}
+async function startWebflowSession(http, config, input) {
+  const {
+    clientId,
+    successUrl,
+    errorUrl,
+    useRedirectProxy = false,
+    autoRedirect = false,
+    openInNewTab = false,
+    signal
+  } = input;
+  if (!clientId?.trim()) {
+    throw new exports.JumioValidationError(
+      "Se requiere un identificador de cliente valido (clientId)."
+    );
+  }
+  if (!successUrl?.trim()) {
+    throw new exports.JumioValidationError("Se requiere la URL de exito (successUrl).");
+  }
+  if (!errorUrl?.trim()) {
+    throw new exports.JumioValidationError("Se requiere la URL de error (errorUrl).");
+  }
+  if (signal?.aborted) {
+    throw new exports.JumioAbortError();
+  }
+  const proxyUrl = useRedirectProxy ? config.redirectProxyUrl ?? void 0 : void 0;
+  const finalSuccessUrl = buildRedirectUrl(successUrl, proxyUrl);
+  const finalErrorUrl = buildRedirectUrl(errorUrl, proxyUrl);
+  try {
+    const responseData = await withRetry(
+      () => http.postVerification(
+        {
+          client: clientId.trim(),
+          successUrl: finalSuccessUrl,
+          errorUrl: finalErrorUrl
+        },
+        { signal, timeout: config.requestTimeout }
+      ),
+      {
+        maxRetries: config.maxRetries ?? 3,
+        initialDelayMs: config.retryDelayMs ?? 800,
+        signal
+      }
+    );
+    const firstLevel = extractEnvelopeData(responseData);
+    const payload = extractNestedData(firstLevel) ?? {};
+    const href = payload?.href;
+    if (!href) {
+      throw new exports.JumioError(
+        extractJumioMessage(payload) || "El backend no devolvio la URL de verificacion de Jumio (href).",
+        { rawData: payload }
+      );
+    }
+    const result = {
+      href,
+      accountId: payload?.accountId,
+      workflowId: payload?.workflowId,
+      data: payload
+    };
+    if (typeof window !== "undefined") {
+      if (openInNewTab) {
+        const win = window.open(href, "_blank");
+        if (!win || win.closed || typeof win.closed === "undefined") {
+          window.location.href = href;
+        }
+      } else if (autoRedirect) {
+        window.location.href = href;
+      }
+    }
+    return result;
+  } catch (err) {
+    throw err;
+  }
+}
+var init_webflow = __esm({
+  "src/core/webflow.ts"() {
+    init_envelope();
+    init_errors();
+    init_retry();
+  }
+});
 
 // src/core/image.ts
+init_errors();
 function stripDataUrlPrefix(dataUrl) {
   if (!dataUrl) return "";
   const commaIndex = dataUrl.indexOf(",");
@@ -278,7 +578,7 @@ function blobToBase64(blob) {
       blob.arrayBuffer().then((buffer) => {
         resolve(arrayBufferToBase64(buffer));
       }).catch(
-        (err) => reject(new JumioImageProcessingError("No se pudo leer el archivo binario.", err))
+        (err) => reject(new exports.JumioImageProcessingError("No se pudo leer el archivo binario.", err))
       );
       return;
     }
@@ -287,7 +587,7 @@ function blobToBase64(blob) {
       const dataUrl = String(reader.result ?? "");
       resolve(stripDataUrlPrefix(dataUrl));
     };
-    reader.onerror = () => reject(new JumioImageProcessingError("No se pudo convertir la imagen a base64.", reader.error));
+    reader.onerror = () => reject(new exports.JumioImageProcessingError("No se pudo convertir la imagen a base64.", reader.error));
     reader.readAsDataURL(blob);
   });
 }
@@ -306,7 +606,7 @@ function arrayBufferToBase64(buffer) {
 }
 async function fetchUrlAsBase64(url, signal) {
   if (signal?.aborted) {
-    throw new JumioAbortError();
+    throw new exports.JumioAbortError();
   }
   const trimmed = url.trim();
   if (trimmed.startsWith("data:")) {
@@ -315,7 +615,7 @@ async function fetchUrlAsBase64(url, signal) {
   try {
     const response = await fetch(trimmed, { signal });
     if (!response.ok) {
-      throw new JumioImageProcessingError(
+      throw new exports.JumioImageProcessingError(
         `No se pudo descargar la imagen desde la URL remota (HTTP ${response.status}).`
       );
     }
@@ -323,12 +623,12 @@ async function fetchUrlAsBase64(url, signal) {
     return await blobToBase64(blob);
   } catch (error) {
     if (signal?.aborted || error instanceof Error && error.name === "AbortError") {
-      throw new JumioAbortError();
+      throw new exports.JumioAbortError();
     }
-    if (error instanceof JumioImageProcessingError) {
+    if (error instanceof exports.JumioImageProcessingError) {
       throw error;
     }
-    throw new JumioImageProcessingError(
+    throw new exports.JumioImageProcessingError(
       `Error al descargar o procesar la imagen desde la URL: ${url}`,
       error
     );
@@ -336,10 +636,10 @@ async function fetchUrlAsBase64(url, signal) {
 }
 async function resolveImageSourceToBase64(source, s3Signer, signal) {
   if (signal?.aborted) {
-    throw new JumioAbortError();
+    throw new exports.JumioAbortError();
   }
   if (!source) {
-    throw new JumioImageProcessingError("No se proporcion\xF3 una imagen v\xE1lida para la verificaci\xF3n.");
+    throw new exports.JumioImageProcessingError("No se proporcion\xF3 una imagen v\xE1lida para la verificaci\xF3n.");
   }
   if (typeof Blob !== "undefined" && source instanceof Blob) {
     return blobToBase64(source);
@@ -356,7 +656,7 @@ async function resolveImageSourceToBase64(source, s3Signer, signal) {
   if (typeof source === "string") {
     const text = source.trim();
     if (!text) {
-      throw new JumioImageProcessingError("La ruta o contenido de la imagen est\xE1 vac\xEDo.");
+      throw new exports.JumioImageProcessingError("La ruta o contenido de la imagen est\xE1 vac\xEDo.");
     }
     if (text.startsWith("data:")) {
       return stripDataUrlPrefix(text);
@@ -381,7 +681,7 @@ async function resolveImageSourceToBase64(source, s3Signer, signal) {
           return await fetchUrlAsBase64(signedUrl, signal);
         }
       } catch (err) {
-        throw new JumioImageProcessingError(
+        throw new exports.JumioImageProcessingError(
           `No se pudo firmar la ruta de almacenamiento S3: ${text}`,
           err
         );
@@ -390,12 +690,16 @@ async function resolveImageSourceToBase64(source, s3Signer, signal) {
     if (isBase64String(text)) {
       return stripDataUrlPrefix(text);
     }
-    throw new JumioImageProcessingError(
+    throw new exports.JumioImageProcessingError(
       `Formato de imagen no reconocido o ruta inv\xE1lida: ${text.slice(0, 50)}...`
     );
   }
-  throw new JumioImageProcessingError("Tipo de dato de imagen no soportado.");
+  throw new exports.JumioImageProcessingError("Tipo de dato de imagen no soportado.");
 }
+
+// src/core/http.ts
+init_errors();
+init_envelope();
 var JumioHttpClient = class {
   client;
   config;
@@ -453,7 +757,7 @@ var JumioHttpClient = class {
    * Normaliza cualquier error de Axios a una excepción tipada JumioError.
    */
   normalizeError(error) {
-    if (error instanceof JumioError) {
+    if (error instanceof exports.JumioError) {
       return error;
     }
     if (axios__default.default.isAxiosError(error)) {
@@ -462,18 +766,18 @@ var JumioHttpClient = class {
       const responseData = axiosErr.response?.data;
       const serverMessage = extractJumioMessage(responseData) || extractJumioMessage(axiosErr);
       if (axiosErr.code === "ECONNABORTED" || axiosErr.code === "ETIMEDOUT") {
-        return new JumioTimeoutError(
+        return new exports.JumioTimeoutError(
           serverMessage || "La solicitud al servicio de Jumio excedi\xF3 el tiempo l\xEDmite.",
           responseData
         );
       }
       if (!axiosErr.response) {
-        return new JumioNetworkError(
+        return new exports.JumioNetworkError(
           serverMessage || "No fue posible comunicarse con el servicio de Jumio.",
           axiosErr
         );
       }
-      return new JumioError(serverMessage || `Error en la solicitud HTTP (${status}).`, {
+      return new exports.JumioError(serverMessage || `Error en la solicitud HTTP (${status}).`, {
         statusCode: status,
         rawData: responseData,
         code: axiosErr.code,
@@ -482,18 +786,18 @@ var JumioHttpClient = class {
     }
     if (error instanceof Error) {
       if (error.name === "AbortError") {
-        return new JumioAbortError();
+        return new exports.JumioAbortError();
       }
-      return new JumioError(error.message, { cause: error });
+      return new exports.JumioError(error.message, { cause: error });
     }
-    return new JumioError("Ocurri\xF3 un error inesperado al contactar a Jumio.");
+    return new exports.JumioError("Ocurri\xF3 un error inesperado al contactar a Jumio.");
   }
   /**
    * Ejecuta una petición POST al endpoint de Jumio para iniciar o procesar la verificación.
    */
   async postVerification(payload, options) {
     if (options?.signal?.aborted) {
-      throw new JumioAbortError();
+      throw new exports.JumioAbortError();
     }
     try {
       const dynamicHeaders = await this.resolveHeaders();
@@ -511,21 +815,26 @@ var JumioHttpClient = class {
   }
   /**
    * Ejecuta una petición GET para consultar el estado actual de una verificación de INE.
+   * Soporta un `clientId` opcional requerido por algunos endpoints de DynamiCore (p. ej. Hosted Webflow).
    */
   async getVerificationStatus(accountId, workflowId, options) {
     if (options?.signal?.aborted) {
-      throw new JumioAbortError();
+      throw new exports.JumioAbortError();
     }
     try {
       const dynamicHeaders = await this.resolveHeaders();
       const endpoint = this.config.endpoint || "/marketplace/apps/jumio";
       const timeout = options?.timeout ?? this.config.statusTimeout ?? 12e4;
+      const queryParams = {
+        type: "ine",
+        accountId,
+        workflowId
+      };
+      if (options?.clientId) {
+        queryParams.clientId = options.clientId;
+      }
       const response = await this.client.get(endpoint, {
-        params: {
-          type: "ine",
-          accountId,
-          workflowId
-        },
+        params: queryParams,
         headers: dynamicHeaders,
         timeout,
         signal: options?.signal
@@ -541,6 +850,9 @@ var JumioHttpClient = class {
 };
 
 // src/core/polling.ts
+init_envelope();
+init_errors();
+init_retry();
 async function pollJumioStatus(http, accountId, workflowId, options = {}) {
   const config = http.getConfig();
   const maxAttempts = options.maxAttempts ?? config.maxPollingAttempts ?? 20;
@@ -549,7 +861,7 @@ async function pollJumioStatus(http, accountId, workflowId, options = {}) {
   let lastData = {};
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     if (signal?.aborted) {
-      throw new JumioAbortError();
+      throw new exports.JumioAbortError();
     }
     const responseData = await withRetry(
       () => http.getVerificationStatus(accountId, workflowId, {
@@ -593,10 +905,14 @@ async function pollJumioStatus(http, accountId, workflowId, options = {}) {
     }
   }
   const lastMessage = extractJumioMessage(lastData) || "La validaci\xF3n de INE sigue en proceso. Intenta nuevamente en unos momentos.";
-  throw new JumioPollingTimeoutError(maxAttempts, lastMessage, lastData);
+  throw new exports.JumioPollingTimeoutError(maxAttempts, lastMessage, lastData);
 }
 
 // src/core/client.ts
+init_envelope();
+init_errors();
+init_retry();
+init_webflow();
 var JumioClient = class {
   http;
   config;
@@ -610,10 +926,10 @@ var JumioClient = class {
   async startIneVerification(params) {
     const { clientId, frontImage, backImage, signal, onProgress } = params;
     if (!clientId || !clientId.trim()) {
-      throw new JumioValidationError("Se requiere un identificador de cliente v\xE1lido (clientId).");
+      throw new exports.JumioValidationError("Se requiere un identificador de cliente v\xE1lido (clientId).");
     }
     if (signal?.aborted) {
-      throw new JumioAbortError();
+      throw new exports.JumioAbortError();
     }
     onProgress?.("RESOLVING_IMAGES", 10);
     const [frontBase64, backBase64] = await Promise.all([
@@ -621,7 +937,7 @@ var JumioClient = class {
       resolveImageSourceToBase64(backImage, this.config.s3Signer, signal)
     ]);
     if (signal?.aborted) {
-      throw new JumioAbortError();
+      throw new exports.JumioAbortError();
     }
     onProgress?.("SENDING_PAYLOAD", 40);
     const payload = {
@@ -709,7 +1025,7 @@ var JumioClient = class {
     const workflowId = String(startData?.workflowId ?? "").trim();
     if (!accountId || !workflowId) {
       const errorMessage = extractJumioMessage(startData) || "No fue posible obtener los identificadores de seguimiento de la validaci\xF3n.";
-      const error = new JumioError(errorMessage, { rawData: startData });
+      const error = new exports.JumioError(errorMessage, { rawData: startData });
       onStatusError?.(error);
       throw error;
     }
@@ -736,10 +1052,110 @@ var JumioClient = class {
     onStatusResolved?.(finalResult);
     return finalResult;
   }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Hosted Webflow (Redirección)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Construye la URL de redirección de retorno para el flujo Hosted Webflow.
+   *
+   * Si el cliente está configurado con un `redirectProxyUrl` y `useProxy` es `true`,
+   * la URL de retorno se codifica en Base64 URL-safe y se adjunta al proxy.
+   *
+   * @param returnUrl URL de la aplicación a la que Jumio redirigirá tras la verificación.
+   * @param useProxy Si es `true` y hay `redirectProxyUrl` configurado, usa el proxy.
+   * @returns URL de redirección construida.
+   */
+  buildRedirectUrl(returnUrl, useProxy = false) {
+    const proxyUrl = useProxy ? this.config.redirectProxyUrl ?? void 0 : void 0;
+    return buildRedirectUrl(returnUrl, proxyUrl);
+  }
+  /**
+   * Inicia el flujo Hosted Webflow solicitando al backend de DynamiCore la URL
+   * de verificación de Jumio (`href`).
+   *
+   * El usuario debe ser redirigido a esa URL para completar la verificación en la
+   * página oficial de Jumio. Al terminar, Jumio redirige de vuelta a la aplicación
+   * con `accountId` y `workflowExecutionId` como query params.
+   *
+   * @param input Parámetros del flujo: `clientId`, `successUrl`, `errorUrl`, opciones de proxy y redirección.
+   * @returns `StartWebflowResult` con la URL de Jumio (`href`) y datos adicionales.
+   *
+   * @example
+   * ```ts
+   * const { href } = await client.startWebflow({
+   *   clientId: "usr_123",
+   *   successUrl: "https://app.example.com/verify/success",
+   *   errorUrl: "https://app.example.com/verify/error",
+   * });
+   * window.location.href = href;
+   * ```
+   */
+  async startWebflow(input) {
+    return startWebflowSession(this.http, this.config, input);
+  }
+  /**
+   * Extrae los parámetros de seguimiento de Jumio de la URL de retorno.
+   *
+   * Jumio añade `accountId` y `workflowExecutionId` (o `workflowId`) como query
+   * params al redirigir de vuelta a la aplicación tras la verificación.
+   *
+   * @param source URL completa, `URLSearchParams`, objeto con `search`/`href`, o nada para leer `window.location`.
+   * @returns `WebflowReturnParams` con `accountId`, `workflowId`, `rawStatus` y todos los params.
+   *
+   * @example En React, en el componente de retorno:
+   * ```ts
+   * const { accountId, workflowId } = client.parseWebflowReturnParams(window.location.href);
+   * ```
+   */
+  parseWebflowReturnParams(source) {
+    return parseWebflowReturnParams(source);
+  }
+  /**
+   * Consulta una única vez el estado actual de la verificación del flujo Hosted Webflow.
+   *
+   * @param input Parámetros de consulta: `accountId`, `workflowId`, y `clientId` opcional.
+   * @returns `WebflowResult | null` — `null` si la verificación aún está pendiente.
+   */
+  async getWebflowStatus(input) {
+    const { accountId, workflowId, clientId, signal } = input;
+    const responseData = await this.http.getVerificationStatus(accountId, workflowId, {
+      signal,
+      timeout: this.config.statusTimeout,
+      clientId
+    });
+    const firstLevel = extractEnvelopeData(responseData);
+    const statusData = extractNestedData(firstLevel) ?? {};
+    const { resolveWebflowResult: resolveWebflowResult2 } = await Promise.resolve().then(() => (init_webflow(), webflow_exports));
+    return resolveWebflowResult2(statusData, accountId, workflowId);
+  }
+  /**
+   * Sondea periódicamente el estado de verificación de un flujo Hosted Webflow de Jumio.
+   *
+   * Continúa consultando hasta obtener un resultado definitivo o agotar los intentos.
+   *
+   * @param params `accountId`, `workflowId` y `clientId` opcional.
+   * @param options Opciones de sondeo (`maxAttempts`, `pollingIntervalMs`, `signal`, `onAttempt`).
+   * @returns `WebflowResult` con el resultado definitivo.
+   *
+   * @example
+   * ```ts
+   * // En el componente de retorno, tras leer los params de la URL:
+   * const result = await client.pollWebflowStatus({ accountId, workflowId, clientId });
+   * if (result.valid) {
+   *   console.log("Verificación aprobada:", result.extraction);
+   * } else {
+   *   console.warn("Rechazado:", result.errorMessage);
+   * }
+   * ```
+   */
+  async pollWebflowStatus(params, options) {
+    return pollWebflowStatus(this.http, params, options);
+  }
 };
 function createJumioClient(config) {
   return new JumioClient(config);
 }
+init_errors();
 var INITIAL_STATE = {
   isSubmitting: false,
   isPolling: false,
@@ -890,7 +1306,14 @@ function useJumioVerification(options = {}) {
         callbacksRef.current.onStatusResolved?.(res);
       };
       const handleError = (err) => {
-        if (err instanceof JumioAbortError) {
+        if (err instanceof exports.JumioAbortError) {
+          setState((prev) => ({
+            ...prev,
+            isSubmitting: false,
+            isPolling: false,
+            isLoading: false,
+            stage: "CANCELLED"
+          }));
           return;
         }
         setState((prev) => ({
@@ -954,22 +1377,215 @@ function useJumioVerification(options = {}) {
     client
   };
 }
+init_errors();
+var INITIAL_STATE2 = {
+  isStarting: false,
+  isChecking: false,
+  isLoading: false,
+  result: null,
+  error: null,
+  isValid: false,
+  isRejected: false
+};
+function useJumioWebflow(options = {}) {
+  const {
+    client: customClient,
+    baseUrl,
+    endpoint,
+    context,
+    authToken,
+    authTokenPrefix,
+    requestTimeout,
+    statusTimeout,
+    maxRetries,
+    retryDelayMs,
+    pollingIntervalMs,
+    maxPollingAttempts,
+    redirectProxyUrl,
+    s3Signer,
+    customHeaders,
+    axiosInstance,
+    onResult: globalOnResult,
+    onError: globalOnError
+  } = options;
+  const client = react.useMemo(() => {
+    if (customClient) return customClient;
+    return new JumioClient({
+      baseUrl,
+      endpoint,
+      context,
+      authToken,
+      authTokenPrefix,
+      requestTimeout,
+      statusTimeout,
+      maxRetries,
+      retryDelayMs,
+      pollingIntervalMs,
+      maxPollingAttempts,
+      redirectProxyUrl,
+      s3Signer,
+      customHeaders,
+      axiosInstance
+    });
+  }, [
+    customClient,
+    baseUrl,
+    endpoint,
+    context,
+    authToken,
+    authTokenPrefix,
+    requestTimeout,
+    statusTimeout,
+    maxRetries,
+    retryDelayMs,
+    pollingIntervalMs,
+    maxPollingAttempts,
+    redirectProxyUrl,
+    s3Signer,
+    customHeaders,
+    axiosInstance
+  ]);
+  const [state, setState] = react.useState(INITIAL_STATE2);
+  const abortControllerRef = react.useRef(null);
+  const callbacksRef = react.useRef({ onResult: globalOnResult, onError: globalOnError });
+  react.useEffect(() => {
+    callbacksRef.current = { onResult: globalOnResult, onError: globalOnError };
+  }, [globalOnResult, globalOnError]);
+  react.useEffect(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+  const cancel = react.useCallback(() => {
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+    setState((prev) => ({
+      ...prev,
+      isStarting: false,
+      isChecking: false,
+      isLoading: false
+    }));
+  }, []);
+  const reset = react.useCallback(() => {
+    cancel();
+    setState(INITIAL_STATE2);
+  }, [cancel]);
+  const handleError = react.useCallback((err) => {
+    if (err instanceof exports.JumioAbortError) {
+      setState((prev) => ({
+        ...prev,
+        isStarting: false,
+        isChecking: false,
+        isLoading: false
+      }));
+      return;
+    }
+    setState((prev) => ({
+      ...prev,
+      isStarting: false,
+      isChecking: false,
+      isLoading: false,
+      error: err,
+      isRejected: true
+    }));
+    callbacksRef.current.onError?.(err);
+  }, []);
+  const handleResult = react.useCallback((result) => {
+    setState((prev) => ({
+      ...prev,
+      isChecking: false,
+      isLoading: false,
+      result,
+      isValid: result.valid,
+      isRejected: !result.valid,
+      error: result.valid ? null : new Error(result.errorMessage ?? "Verificacion de identidad rechazada")
+    }));
+    callbacksRef.current.onResult?.(result);
+  }, []);
+  const startWebflow = react.useCallback(
+    async (input) => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      setState({
+        ...INITIAL_STATE2,
+        isStarting: true,
+        isLoading: true
+      });
+      try {
+        const result = await client.startWebflow({
+          ...input,
+          signal: input.signal ?? controller.signal
+        });
+        setState((prev) => ({
+          ...prev,
+          isStarting: false,
+          isLoading: false
+        }));
+        return result;
+      } catch (err) {
+        const normalizedError = err instanceof Error ? err : new Error(String(err));
+        handleError(normalizedError);
+        throw normalizedError;
+      }
+    },
+    [client, handleError]
+  );
+  const checkResult = react.useCallback(
+    async (params, pollOptions) => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      setState((prev) => ({
+        ...prev,
+        isChecking: true,
+        isLoading: true,
+        error: null
+      }));
+      try {
+        const result = await client.pollWebflowStatus(params, {
+          ...pollOptions,
+          signal: pollOptions?.signal ?? controller.signal
+        });
+        handleResult(result);
+        return result;
+      } catch (err) {
+        const normalizedError = err instanceof Error ? err : new Error(String(err));
+        handleError(normalizedError);
+        throw normalizedError;
+      }
+    },
+    [client, handleResult, handleError]
+  );
+  const parseReturnParams = react.useCallback(
+    (source) => {
+      return client.parseWebflowReturnParams(source);
+    },
+    [client]
+  );
+  return {
+    ...state,
+    startWebflow,
+    checkResult,
+    parseReturnParams,
+    cancel,
+    reset,
+    client
+  };
+}
 
-exports.APPROVED_JUMIO_STATUSES = APPROVED_JUMIO_STATUSES;
-exports.FINAL_JUMIO_STATUSES = FINAL_JUMIO_STATUSES;
-exports.JumioAbortError = JumioAbortError;
 exports.JumioClient = JumioClient;
-exports.JumioError = JumioError;
 exports.JumioHttpClient = JumioHttpClient;
-exports.JumioImageProcessingError = JumioImageProcessingError;
-exports.JumioNetworkError = JumioNetworkError;
-exports.JumioPollingTimeoutError = JumioPollingTimeoutError;
-exports.JumioTimeoutError = JumioTimeoutError;
-exports.JumioValidationError = JumioValidationError;
 exports.arrayBufferToBase64 = arrayBufferToBase64;
 exports.blobToBase64 = blobToBase64;
+exports.buildRedirectUrl = buildRedirectUrl;
 exports.createJumioClient = createJumioClient;
 exports.delay = delay;
+exports.encodeUrlToBase64UrlSafe = encodeUrlToBase64UrlSafe;
 exports.extractEnvelopeData = extractEnvelopeData;
 exports.extractJumioMessage = extractJumioMessage;
 exports.extractNestedData = extractNestedData;
@@ -980,14 +1596,19 @@ exports.isFinalJumioStatus = isFinalJumioStatus;
 exports.isJumioError = isJumioError;
 exports.isPassedJumioDecision = isPassedJumioDecision;
 exports.normalizeSignedUrl = normalizeSignedUrl;
+exports.parseWebflowReturnParams = parseWebflowReturnParams;
 exports.pollJumioStatus = pollJumioStatus;
+exports.pollWebflowStatus = pollWebflowStatus;
 exports.resolveImageSourceToBase64 = resolveImageSourceToBase64;
 exports.resolveVerificationValidity = resolveVerificationValidity;
+exports.resolveWebflowResult = resolveWebflowResult;
 exports.shouldRetryJumio = shouldRetryJumio;
+exports.startWebflowSession = startWebflowSession;
 exports.stripDataUrlPrefix = stripDataUrlPrefix;
 exports.toLowerText = toLowerText;
 exports.toUpperText = toUpperText;
 exports.useJumioVerification = useJumioVerification;
+exports.useJumioWebflow = useJumioWebflow;
 exports.withRetry = withRetry;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map