@signiphi/pdf-signer 0.1.1

package/dist/utils/index.js

@@ -0,0 +1,2501 @@
+'use strict';
+
+var pdfjsLib2 = require('pdfjs-dist');
+var dateFns = require('date-fns');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var pdfjsLib2__namespace = /*#__PURE__*/_interopNamespace(pdfjsLib2);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/utils/logger.ts
+function isProduction() {
+  return typeof process !== "undefined" && process.env.NODE_ENV === "production";
+}
+function createPrefix(level) {
+  return `[@signiphi/pdf-signer] [${level.toUpperCase()}]`;
+}
+function createLogger() {
+  const isProd = isProduction();
+  return {
+    debug(message, ...args) {
+      if (!isProd) {
+        console.log(createPrefix("debug"), message, ...args);
+      }
+    },
+    info(message, ...args) {
+      if (!isProd) {
+        console.log(createPrefix("info"), message, ...args);
+      }
+    },
+    warn(message, ...args) {
+      if (!isProd) {
+        console.warn(createPrefix("warn"), message, ...args);
+      }
+    },
+    error(message, ...args) {
+      console.error(createPrefix("error"), message, ...args);
+    }
+  };
+}
+var logger = createLogger();
+
+// src/utils/pdf-validators.ts
+function validatePdfBytes(pdfBytes) {
+  if (!pdfBytes || pdfBytes.length === 0) {
+    return {
+      valid: false,
+      error: "PDF bytes are empty"
+    };
+  }
+  const header = new TextDecoder().decode(pdfBytes.slice(0, 12));
+  if (!header.startsWith("%PDF-")) {
+    return {
+      valid: false,
+      error: "Invalid PDF format: Missing PDF header"
+    };
+  }
+  return { valid: true };
+}
+function isAutoGeneratedLabel(label) {
+  if (!label || !label.trim()) return true;
+  const autoLabels = [
+    "Signature",
+    "Initials",
+    "Date",
+    "Text",
+    "Checkbox",
+    "Dropdown",
+    "Option",
+    "Radio"
+  ];
+  return autoLabels.includes(label.trim());
+}
+function validateFieldValues(values) {
+  const errors = [];
+  if (!values || typeof values !== "object") {
+    errors.push("Field values must be an object");
+    return { valid: false, errors };
+  }
+  const valuesObj = values;
+  for (const [key, value] of Object.entries(valuesObj)) {
+    if (typeof value !== "string") {
+      errors.push(`Field value for "${key}" must be a string, got ${typeof value}`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateSignatures(signatures) {
+  const errors = [];
+  if (!signatures || typeof signatures !== "object") {
+    errors.push("Signatures must be an object");
+    return { valid: false, errors };
+  }
+  const sigsObj = signatures;
+  for (const [key, value] of Object.entries(sigsObj)) {
+    if (typeof value !== "string") {
+      errors.push(`Signature for "${key}" must be a string, got ${typeof value}`);
+      continue;
+    }
+    if (!value.startsWith("data:image/")) {
+      errors.push(`Signature for "${key}" must be a data URL starting with "data:image/"`);
+    }
+    const parts = value.split(",");
+    if (parts.length !== 2 || !parts[1]) {
+      errors.push(`Signature for "${key}" has invalid data URL format (missing base64 data)`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateFormField(field) {
+  const errors = [];
+  if (!field || typeof field !== "object") {
+    errors.push("Form field must be an object");
+    return { valid: false, errors };
+  }
+  const f = field;
+  if (!f.id || typeof f.id !== "string") {
+    errors.push('Field must have a valid "id" string');
+  }
+  if (!f.type || typeof f.type !== "string") {
+    errors.push('Field must have a valid "type" string');
+  }
+  if (!f.name || typeof f.name !== "string") {
+    errors.push('Field must have a valid "name" string');
+  }
+  if (!f.label || typeof f.label !== "string") {
+    errors.push('Field must have a valid "label" string');
+  }
+  if (!f.position || typeof f.position !== "object") {
+    errors.push('Field must have a valid "position" object');
+  } else {
+    const pos = f.position;
+    if (typeof pos.x !== "number") {
+      errors.push('Field position must have a numeric "x" coordinate');
+    }
+    if (typeof pos.y !== "number") {
+      errors.push('Field position must have a numeric "y" coordinate');
+    }
+    if (typeof pos.width !== "number" || pos.width <= 0) {
+      errors.push('Field position must have a positive "width"');
+    }
+    if (typeof pos.height !== "number" || pos.height <= 0) {
+      errors.push('Field position must have a positive "height"');
+    }
+    if (typeof pos.page !== "number" || pos.page < 1) {
+      errors.push('Field position must have a valid "page" number (1-indexed)');
+    }
+  }
+  if (typeof f.required !== "boolean") {
+    errors.push('Field must have a boolean "required" property');
+  }
+  if (f.fontSize !== void 0 && (typeof f.fontSize !== "number" || f.fontSize < 8 || f.fontSize > 72)) {
+    errors.push("Field fontSize must be a number between 8 and 72");
+  }
+  if (f.maxLength !== void 0 && (typeof f.maxLength !== "number" || f.maxLength <= 0)) {
+    errors.push("Field maxLength must be a positive number");
+  }
+  if (f.options !== void 0 && !Array.isArray(f.options)) {
+    errors.push("Field options must be an array");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validatePdfUrl(url) {
+  if (typeof url !== "string") {
+    return { valid: false, error: "URL must be a string" };
+  }
+  if (!url || url.trim().length === 0) {
+    return { valid: false, error: "URL cannot be empty" };
+  }
+  const trimmedUrl = url.trim();
+  const validPrefixes = ["http://", "https://", "blob:", "data:", "file://"];
+  const hasValidPrefix = validPrefixes.some((prefix) => trimmedUrl.startsWith(prefix));
+  if (hasValidPrefix) {
+    return { valid: true };
+  }
+  if (trimmedUrl.startsWith("/") || trimmedUrl.startsWith("./") || trimmedUrl.startsWith("../")) {
+    return { valid: true };
+  }
+  return {
+    valid: false,
+    error: "URL must be an absolute URL (http://, https://, blob:, data:, file://) or a relative path (/, ./, ../)"
+  };
+}
+
+// src/utils/pdf-helpers.ts
+function createPdfBlobUrl(pdfBytes) {
+  const blob = new Blob([pdfBytes], { type: "application/pdf" });
+  return URL.createObjectURL(blob);
+}
+function downloadPdf(pdfBytes, filename) {
+  const url = createPdfBlobUrl(pdfBytes);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+async function urlToPdfBytes(url) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch PDF: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const pdfBytes = new Uint8Array(arrayBuffer.byteLength);
+    pdfBytes.set(new Uint8Array(arrayBuffer));
+    const validation = validatePdfBytes(pdfBytes);
+    if (!validation.valid) {
+      throw new Error(validation.error || "Invalid PDF format");
+    }
+    return pdfBytes;
+  } catch (error) {
+    logger.error("Error fetching PDF from URL:", error);
+    throw error;
+  }
+}
+function isValidPdf(pdfBytes) {
+  const validation = validatePdfBytes(pdfBytes);
+  return validation.valid;
+}
+function dataUrlToBytes(dataUrl) {
+  const base64Data = dataUrl.split(",")[1];
+  if (!base64Data) {
+    throw new Error("Invalid data URL format: missing base64 data");
+  }
+  return Uint8Array.from(atob(base64Data), (c) => c.charCodeAt(0));
+}
+function formatFieldName(fieldName) {
+  return fieldName.replace(/[_-]/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()).replace("Signature", "").replace("Initials", "").trim();
+}
+function isSignatureField(fieldName) {
+  return fieldName.toLowerCase().includes("signature");
+}
+function isInitialsField(fieldName) {
+  return fieldName.toLowerCase().includes("initials");
+}
+
+// src/utils/pdf-lib-loader.ts
+var pdfLibPromise = null;
+async function loadPdfLib() {
+  if (!pdfLibPromise) {
+    pdfLibPromise = import('pdf-lib');
+  }
+  return pdfLibPromise;
+}
+
+// src/utils/field-visibility.ts
+function isFieldVisibleToSigner(field, multiSignerContext) {
+  if (!multiSignerContext.isMultiSigner) {
+    return true;
+  }
+  const { currentSignerEmail, isPrimarySigner, isFinalSigner } = multiSignerContext;
+  if (!field.assignedSignerEmail) {
+    return isFinalSigner;
+  }
+  if (field.assignedSignerEmail === currentSignerEmail) {
+    return true;
+  }
+  if (field.assignedSignerEmail.includes("recipients")) {
+    return isPrimarySigner;
+  }
+  if (field.assignedSignerEmail.includes("signers")) {
+    return isFinalSigner;
+  }
+  return false;
+}
+function filterFieldsBySigner(fields, multiSignerContext) {
+  if (!multiSignerContext.isMultiSigner) {
+    return fields;
+  }
+  return fields.filter((field) => isFieldVisibleToSigner(field, multiSignerContext));
+}
+function shouldFlattenField(field, multiSignerContext) {
+  if (!multiSignerContext.isMultiSigner) {
+    return true;
+  }
+  const { currentSignerEmail, isPrimarySigner, isFinalSigner } = multiSignerContext;
+  if (!field.assignedSignerEmail) {
+    return isFinalSigner;
+  }
+  if (field.assignedSignerEmail === currentSignerEmail) {
+    return true;
+  }
+  if (field.assignedSignerEmail.includes("recipients")) {
+    return isPrimarySigner;
+  }
+  if (field.assignedSignerEmail.includes("signers")) {
+    return isFinalSigner;
+  }
+  return false;
+}
+
+// src/utils/pdf-widget-helpers.ts
+function findPageIndexByRef(pages, pageRef) {
+  if (!pageRef) return -1;
+  for (let i = 0; i < pages.length; i++) {
+    const page = pages[i];
+    if (page.ref === pageRef) {
+      return i;
+    }
+  }
+  return -1;
+}
+function getWidgetRectangleAndPage(widget, pages) {
+  const rect = widget.getRectangle?.();
+  if (!rect) return null;
+  const pageRef = widget.P?.();
+  if (!pageRef) return null;
+  const pageIndex = findPageIndexByRef(pages, pageRef);
+  if (pageIndex === -1) return null;
+  const page = pages[pageIndex];
+  if (!page) return null;
+  return { rect, page, pageIndex };
+}
+function findPageIndexWithFallback(pages, pageRef) {
+  if (!pageRef) {
+    return pages.length === 1 ? 0 : -1;
+  }
+  const pageIndex = findPageIndexByRef(pages, pageRef);
+  if (pageIndex === -1 && pages.length === 1) {
+    return 0;
+  }
+  return pageIndex;
+}
+
+// src/utils/pdf-field-type-helpers.ts
+function detectFieldType(field) {
+  const typeName = field.constructor.name;
+  if (typeName === "PDFTextField") {
+    return "text";
+  } else if (typeName === "PDFCheckBox") {
+    return "checkbox";
+  } else if (typeName === "PDFDropdown") {
+    return "dropdown";
+  } else if (typeName === "PDFOptionList") {
+    return "optionlist";
+  } else if (typeName === "PDFRadioGroup") {
+    return "radiogroup";
+  } else if (typeName === "PDFSignature") {
+    return "signature";
+  }
+  return "unknown";
+}
+function extractFieldValue(field, fieldType) {
+  try {
+    switch (fieldType) {
+      case "text":
+        return field.getText?.() || "";
+      case "checkbox":
+        return field.isChecked?.() ? "true" : "false";
+      case "dropdown":
+      case "optionlist":
+      case "radiogroup":
+        return field.getSelected?.()?.[0] || "";
+      default:
+        return "";
+    }
+  } catch (error) {
+    return "";
+  }
+}
+function isRequiredField(field, fieldName, fieldType) {
+  if (fieldType === "signature") {
+    return true;
+  }
+  try {
+    if (field.isRequired?.()) {
+      return true;
+    }
+  } catch {
+  }
+  if (fieldName.includes("signature") || fieldName.includes("initials") || fieldName.includes("required")) {
+    return true;
+  }
+  return false;
+}
+
+// src/utils/pdf-manipulation.ts
+async function pdfToImages(pdfBytes, options) {
+  try {
+    const validation = validatePdfBytes(pdfBytes);
+    if (!validation.valid) {
+      logger.error("Invalid PDF:", validation.error);
+      throw new Error(validation.error || "Invalid PDF format");
+    }
+    const loadingTask = pdfjsLib2__namespace.getDocument({
+      data: pdfBytes,
+      verbosity: 0
+    });
+    const pdfDoc = await loadingTask.promise;
+    const pages = [];
+    let pdfLibDoc = null;
+    try {
+      const { PDFDocument } = await loadPdfLib();
+      pdfLibDoc = await PDFDocument.load(pdfBytes);
+    } catch {
+    }
+    for (let pageNum = 1; pageNum <= pdfDoc.numPages; pageNum++) {
+      const page = await pdfDoc.getPage(pageNum);
+      const viewport = page.getViewport({ scale: 2 });
+      let pdfWidth = viewport.width / 2;
+      let pdfHeight = viewport.height / 2;
+      if (pdfLibDoc) {
+        try {
+          const pdfLibPage = pdfLibDoc.getPage(pageNum - 1);
+          pdfWidth = pdfLibPage.getWidth();
+          pdfHeight = pdfLibPage.getHeight();
+        } catch {
+        }
+      }
+      const canvas = document.createElement("canvas");
+      const context = canvas.getContext("2d");
+      canvas.height = viewport.height;
+      canvas.width = viewport.width;
+      const hideFormFields = options?.hideFormFields ?? false;
+      const renderContext = {
+        canvasContext: context,
+        viewport,
+        renderInteractiveForms: !hideFormFields,
+        ...hideFormFields && {
+          annotationMode: 0,
+          renderAnnotations: false,
+          renderForms: false
+        }
+      };
+      await page.render(renderContext).promise;
+      const imageUrl = canvas.toDataURL("image/png");
+      pages.push({
+        pageNumber: pageNum,
+        width: pdfWidth,
+        height: pdfHeight,
+        imageUrl,
+        renderWidth: viewport.width,
+        renderHeight: viewport.height
+      });
+    }
+    return pages;
+  } catch (error) {
+    logger.error("Error converting PDF to images with PDF.js:", error);
+    return await fallbackPdfToImages(pdfBytes);
+  }
+}
+async function fallbackPdfToImages(pdfBytes) {
+  try {
+    const { PDFDocument } = await loadPdfLib();
+    const pdf = await PDFDocument.load(pdfBytes);
+    const pages = [];
+    for (let i = 0; i < pdf.getPageCount(); i++) {
+      const page = pdf.getPage(i);
+      const { width, height } = page.getSize();
+      const canvas = document.createElement("canvas");
+      const context = canvas.getContext("2d");
+      const scale = 1.5;
+      canvas.width = width * scale;
+      canvas.height = height * scale;
+      context.fillStyle = "#ffffff";
+      context.fillRect(0, 0, canvas.width, canvas.height);
+      context.strokeStyle = "#e5e7eb";
+      context.lineWidth = 2;
+      context.strokeRect(0, 0, canvas.width, canvas.height);
+      context.fillStyle = "#6b7280";
+      context.font = "bold 24px system-ui";
+      context.textAlign = "center";
+      context.fillText(`Page ${i + 1}`, canvas.width / 2, canvas.height / 2 - 20);
+      context.font = "16px system-ui";
+      context.fillStyle = "#9ca3af";
+      context.fillText("PDF preview not available", canvas.width / 2, canvas.height / 2 + 20);
+      const imageUrl = canvas.toDataURL("image/png");
+      pages.push({
+        pageNumber: i + 1,
+        width,
+        height,
+        imageUrl,
+        renderWidth: canvas.width,
+        renderHeight: canvas.height
+      });
+    }
+    return pages;
+  } catch (error) {
+    logger.error("Error with pdf-lib fallback:", error);
+    return [createErrorPage()];
+  }
+}
+function createErrorPage() {
+  const canvas = document.createElement("canvas");
+  const context = canvas.getContext("2d");
+  canvas.width = 600;
+  canvas.height = 800;
+  context.fillStyle = "#ffffff";
+  context.fillRect(0, 0, canvas.width, canvas.height);
+  context.strokeStyle = "#e5e7eb";
+  context.lineWidth = 2;
+  context.strokeRect(0, 0, canvas.width, canvas.height);
+  context.fillStyle = "#ef4444";
+  context.font = "bold 20px system-ui";
+  context.textAlign = "center";
+  context.fillText("PDF Processing Error", canvas.width / 2, canvas.height / 2 - 20);
+  context.font = "14px system-ui";
+  context.fillStyle = "#6b7280";
+  context.fillText("Unable to process the uploaded PDF file", canvas.width / 2, canvas.height / 2 + 20);
+  return {
+    pageNumber: 1,
+    width: 600,
+    height: 800,
+    imageUrl: canvas.toDataURL("image/png"),
+    renderWidth: canvas.width,
+    renderHeight: canvas.height
+  };
+}
+async function removeAllFormFields(pdfBytes, stripAllAnnotations = false) {
+  try {
+    const validation = validatePdfBytes(pdfBytes);
+    if (!validation.valid) {
+      return pdfBytes;
+    }
+    const { PDFDocument } = await loadPdfLib();
+    const pdfDoc = await PDFDocument.load(pdfBytes);
+    if (stripAllAnnotations) {
+      const pages = pdfDoc.getPages();
+      for (let i = 0; i < pages.length; i++) {
+        const page = pages[i];
+        try {
+          const pageRef = page.ref;
+          const pageDictObj = pdfDoc.context.lookup(pageRef);
+          if (pageDictObj) {
+            const pageDict = pageDictObj;
+            if (pageDict && pageDict.get && pageDict.delete) {
+              const annotsRef = pageDict.get(pdfDoc.context.obj("Annots"));
+              if (annotsRef) {
+                pageDict.delete(pdfDoc.context.obj("Annots"));
+              }
+            } else {
+            }
+          } else {
+          }
+        } catch (pageError) {
+        }
+      }
+    } else {
+      const form = pdfDoc.getForm();
+      const fields = form.getFields();
+      if (fields.length === 0) {
+        return pdfBytes;
+      }
+      for (const field of fields) {
+        try {
+          const acroField = field.acroField;
+          if (acroField && typeof acroField.getWidgets === "function") {
+            let widgets = acroField.getWidgets();
+            let safetyCounter = 0;
+            const maxIterations = widgets.length + 5;
+            while (widgets.length > 0 && safetyCounter < maxIterations) {
+              try {
+                const widgetIndex = widgets.length - 1;
+                acroField.removeWidget(widgetIndex);
+                widgets = acroField.getWidgets();
+              } catch (widgetError) {
+                break;
+              }
+              safetyCounter++;
+            }
+            if (safetyCounter >= maxIterations) {
+            }
+          }
+          form.removeField(field);
+        } catch (error) {
+          try {
+            form.removeField(field);
+          } catch (fallbackError) {
+          }
+        }
+      }
+      const remainingFields = form.getFields();
+      if (remainingFields.length > 0) {
+      }
+    }
+    const updatedPdfBytes = await pdfDoc.save();
+    return updatedPdfBytes;
+  } catch (error) {
+    logger.error("Error removing form fields from PDF:", error);
+    return pdfBytes;
+  }
+}
+async function readPdfFormFields(pdfBytes) {
+  try {
+    const validation = validatePdfBytes(pdfBytes);
+    if (!validation.valid) {
+      return [];
+    }
+    const { PDFDocument } = await loadPdfLib();
+    const pdfDoc = await PDFDocument.load(pdfBytes);
+    const form = pdfDoc.getForm();
+    const fields = form.getFields();
+    if (fields.length === 0) {
+      return [];
+    }
+    const formFields = fields.map((field) => {
+      const fieldName = field.getName();
+      const pdfField = field;
+      try {
+        const fieldType = detectFieldType(pdfField);
+        const value = extractFieldValue(pdfField, fieldType);
+        const required = isRequiredField(pdfField, fieldName, fieldType);
+        return {
+          name: fieldName,
+          type: fieldType,
+          required,
+          value
+        };
+      } catch (fieldError) {
+        return {
+          name: fieldName,
+          type: "text",
+          required: false,
+          value: ""
+        };
+      }
+    });
+    return formFields;
+  } catch (error) {
+    logger.error("Error reading PDF form fields:", error);
+    return [];
+  }
+}
+async function readCurrentPdfFormValues(pdfBytes) {
+  try {
+    if (!pdfBytes || pdfBytes.length === 0) {
+      return {};
+    }
+    const { PDFDocument } = await loadPdfLib();
+    const pdfDoc = await PDFDocument.load(pdfBytes);
+    const form = pdfDoc.getForm();
+    const fields = form.getFields();
+    const currentValues = {};
+    for (const field of fields) {
+      const fieldName = field.getName();
+      const pdfField = field;
+      try {
+        const fieldType = detectFieldType(pdfField);
+        const value = extractFieldValue(pdfField, fieldType);
+        currentValues[fieldName] = value;
+      } catch (fieldError) {
+        currentValues[fieldName] = "";
+      }
+    }
+    return currentValues;
+  } catch (error) {
+    logger.error("Error reading current PDF form values:", error);
+    return {};
+  }
+}
+async function validatePdfFormFields(pdfBytes, fieldValues, signatures, extractedFields, multiSignerContext) {
+  try {
+    const pdfFormFields = await readPdfFormFields(pdfBytes);
+    const errors = [];
+    for (const field of pdfFormFields) {
+      if (field.required) {
+        if (multiSignerContext?.isMultiSigner && extractedFields) {
+          const extractedField = extractedFields.find((f) => f.name === field.name);
+          if (!extractedField) {
+            continue;
+          }
+        }
+        let hasValue = false;
+        const fieldValue = fieldValues[field.name];
+        const signatureValue = signatures[field.name];
+        const mainSignature = signatures["signature_field_main"];
+        const mainInitials = signatures["initials_field_main"] || fieldValues["initials_field_main"];
+        if (field.name.includes("signature") || field.type === "signature") {
+          hasValue = !!(signatureValue || fieldValue || mainSignature);
+        } else if (field.name.includes("initials")) {
+          hasValue = !!(signatureValue || fieldValue || mainInitials);
+        } else {
+          hasValue = !!(fieldValue || field.value);
+        }
+        if (!hasValue) {
+          let friendlyName = field.name.replace(/[_-]/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+          if (field.name.includes("signature")) {
+            friendlyName = "Signature";
+          } else if (field.name.includes("initials")) {
+            friendlyName = "Initials";
+          }
+          errors.push(`${friendlyName} is required`);
+        }
+      }
+    }
+    return errors;
+  } catch (error) {
+    logger.error("Error validating PDF form fields:", error);
+    return ["Unable to validate form fields. Please ensure all required fields are completed."];
+  }
+}
+async function validateCurrentPdfState(pdfBytes, signatures, formFieldValues = {}) {
+  try {
+    const pdfFormFields = await readPdfFormFields(pdfBytes);
+    const currentValues = await readCurrentPdfFormValues(pdfBytes);
+    const errors = [];
+    for (const field of pdfFormFields) {
+      const isSignatureField2 = field.name.includes("signature") && field.type === "text";
+      const isInitialsField2 = field.name.includes("initials") && field.type === "text";
+      if (field.required || isSignatureField2 || isInitialsField2) {
+        let hasValue = false;
+        const currentValue = currentValues[field.name] || "";
+        if (isSignatureField2) {
+          hasValue = !!signatures[field.name];
+        } else if (isInitialsField2) {
+          hasValue = !!signatures[field.name] || !!formFieldValues[field.name]?.trim() || currentValue.trim() !== "";
+        } else {
+          hasValue = currentValue.trim() !== "";
+        }
+        if (!hasValue) {
+          let friendlyName = field.name.replace(/[_-]/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+          if (field.name.includes("signature")) {
+            friendlyName = "Signature";
+          } else if (field.name.includes("initials")) {
+            friendlyName = "Initials";
+          }
+          errors.push(`${friendlyName} is required`);
+        }
+      }
+    }
+    return errors;
+  } catch (error) {
+    logger.error("Error validating current PDF state:", error);
+    throw error;
+  }
+}
+async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {}, currentSignerEmail, extractedFormFields, metadata, auditTrail, multiSignerContext) {
+  try {
+    const { PDFDocument, rgb, StandardFonts } = await loadPdfLib();
+    const pdfDoc = await PDFDocument.load(pdfBytes);
+    const form = pdfDoc.getForm();
+    const pages = pdfDoc.getPages();
+    const { pageMap: fieldPageMap, positionMap: fieldPositionMap } = await getFieldPageNumbers(pdfBytes);
+    const fields = form.getFields();
+    for (const field of fields) {
+      const fieldName = field.getName();
+      const fieldValue = formFieldValues[fieldName];
+      if (!fieldValue) {
+        if (fieldName.includes("radio")) {
+        }
+        continue;
+      }
+      try {
+        const fieldTypeName = field.constructor.name;
+        if (fieldTypeName === "PDFTextField" || fieldTypeName === "PDFTextField2") {
+          const textField = field;
+          textField.setText?.(fieldValue);
+        } else if (fieldTypeName === "PDFCheckBox" || fieldTypeName === "PDFCheckBox2") {
+          const checkBox = field;
+          if (fieldValue === "true" || fieldValue === "Yes" || fieldValue === "checked" || fieldValue === "On") {
+            checkBox.check?.();
+          } else {
+            checkBox.uncheck?.();
+          }
+        } else if (fieldTypeName === "PDFRadioGroup" || fieldTypeName === "PDFRadioGroup2") {
+          const radioGroup = field;
+          if (fieldValue === "true" || fieldValue === "false") {
+            continue;
+          }
+          const idxMatch = fieldValue.match(/__RADIO_OPTION_INDEX_(\d+)__/);
+          if (idxMatch && idxMatch[1]) {
+            const selectedIndex = parseInt(idxMatch[1], 10);
+            const options = radioGroup.getOptions?.() || [];
+            if (selectedIndex >= 0 && selectedIndex < options.length) {
+              radioGroup.select?.(options[selectedIndex]);
+            }
+          } else {
+            const options = radioGroup.getOptions?.() || [];
+            if (options.includes(fieldValue)) {
+              radioGroup.select?.(fieldValue);
+            } else {
+            }
+          }
+        } else if (fieldTypeName === "PDFDropdown" || fieldTypeName === "PDFDropdown2") {
+          const dropdown = field;
+          dropdown.select?.(fieldValue);
+        }
+      } catch (fieldError) {
+        logger.error(`Error setting field "${fieldName}":`, fieldError);
+      }
+    }
+    try {
+      form.updateFieldAppearances();
+    } catch (appearanceError) {
+    }
+    const mainSignatureData = signatures["signature_field_main"];
+    if (mainSignatureData && mainSignatureData.trim()) {
+      const signatureFieldNames = [
+        "signature",
+        "Signature",
+        "SIGNATURE",
+        "sign",
+        "Sign",
+        "SIGN",
+        "_es_:signer:signature"
+      ];
+      let foundSignatureFields = Object.keys(fieldPageMap).filter((fieldName) => {
+        const hasSignaturePattern = signatureFieldNames.some(
+          (pattern) => fieldName.toLowerCase().includes(pattern.toLowerCase())
+        );
+        const isNotTextField = !fieldName.toLowerCase().startsWith("text_");
+        return hasSignaturePattern && isNotTextField;
+      });
+      if (extractedFormFields && extractedFormFields.length > 0) {
+        const currentSignerSignatureFields = foundSignatureFields.filter((fieldName) => {
+          const fieldInfo = extractedFormFields.find((f) => f.name === fieldName);
+          if (!fieldInfo) {
+            return false;
+          }
+          const isActualSignatureField = (fieldInfo.type === "signature" || fieldName.toLowerCase().includes("signature")) && !fieldName.toLowerCase().includes("initials");
+          if (!isActualSignatureField) {
+            return false;
+          }
+          const isVisible = multiSignerContext ? isFieldVisibleToSigner(fieldInfo, multiSignerContext) : true;
+          return isVisible;
+        });
+        foundSignatureFields = currentSignerSignatureFields;
+      }
+      if (foundSignatureFields.length > 0) {
+        try {
+          let signatureImage;
+          if (mainSignatureData.includes("data:image/png")) {
+            signatureImage = await pdfDoc.embedPng(mainSignatureData);
+          } else if (mainSignatureData.includes("data:image/jpeg") || mainSignatureData.includes("data:image/jpg")) {
+            signatureImage = await pdfDoc.embedJpg(mainSignatureData);
+          } else {
+            const base64Data = mainSignatureData.split(",")[1];
+            if (!base64Data) {
+              throw new Error("Invalid signature data format: missing base64 data");
+            }
+            const binaryData = atob(base64Data);
+            if (binaryData.charCodeAt(0) === 137 && binaryData.charCodeAt(1) === 80 && binaryData.charCodeAt(2) === 78 && binaryData.charCodeAt(3) === 71) {
+              signatureImage = await pdfDoc.embedPng(mainSignatureData);
+            } else if (binaryData.charCodeAt(0) === 255 && binaryData.charCodeAt(1) === 216 && binaryData.charCodeAt(2) === 255) {
+              signatureImage = await pdfDoc.embedJpg(mainSignatureData);
+            } else {
+              throw new Error("Unsupported image format. Please use PNG or JPEG.");
+            }
+          }
+          for (const fieldName of foundSignatureFields) {
+            const pageNumber = fieldPageMap[fieldName];
+            if (pageNumber && pageNumber <= pages.length) {
+              const page = pages[pageNumber - 1];
+              if (!page) continue;
+              const fieldPosition = fieldPositionMap[fieldName];
+              if (fieldPosition) {
+                const x = fieldPosition.x;
+                const y = fieldPosition.y;
+                const width = Math.max(fieldPosition.width, 80);
+                const height = Math.max(fieldPosition.height, 30);
+                const signatureDims = signatureImage.scaleToFit(width - 4, height - 4);
+                const finalX = x;
+                const finalY = y;
+                page.drawImage(signatureImage, {
+                  x: finalX,
+                  y: finalY,
+                  width: signatureDims.width,
+                  height: signatureDims.height
+                });
+              } else {
+              }
+            } else {
+            }
+          }
+        } catch (error) {
+          logger.error("Error applying signatures:", error);
+        }
+      }
+    }
+    const mainInitialsData = formFieldValues["initials_field_main"];
+    if (mainInitialsData && mainInitialsData.trim()) {
+      const initialsFieldNames = ["initials", "Initials", "INITIALS"];
+      let foundInitialsFields = Object.keys(fieldPageMap).filter(
+        (fieldName) => initialsFieldNames.some((pattern) => fieldName.toLowerCase().includes(pattern.toLowerCase()))
+      );
+      if (extractedFormFields && extractedFormFields.length > 0) {
+        foundInitialsFields = foundInitialsFields.filter((fieldName) => {
+          const fieldInfo = extractedFormFields.find((f) => f.name === fieldName);
+          if (!fieldInfo) return false;
+          const isActualInitialsField = fieldInfo.type === "initials" || fieldName.toLowerCase().includes("initials");
+          if (!isActualInitialsField) return false;
+          return !fieldInfo.assignedSignerEmail || fieldInfo.assignedSignerEmail === currentSignerEmail;
+        });
+      }
+      if (foundInitialsFields.length > 0) {
+        try {
+          const font = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
+          for (const fieldName of foundInitialsFields) {
+            const pageNumber = fieldPageMap[fieldName];
+            if (pageNumber && pageNumber <= pages.length) {
+              const page = pages[pageNumber - 1];
+              if (!page) continue;
+              const fieldPosition = fieldPositionMap[fieldName];
+              if (fieldPosition) {
+                const x = fieldPosition.x;
+                const y = fieldPosition.y;
+                const height = Math.max(fieldPosition.height, 20);
+                const fontSize = Math.min(height * 0.7, 14);
+                const finalX = x + 2;
+                const finalY = y + (height - fontSize) / 2;
+                page.drawText(mainInitialsData, {
+                  x: finalX,
+                  y: finalY,
+                  size: fontSize,
+                  font,
+                  color: rgb(0, 0, 0)
+                });
+              }
+            }
+          }
+        } catch (error) {
+          logger.error("Error applying initials:", error);
+        }
+      }
+    }
+    const allFormFields = form.getFields();
+    let fieldsToFlatten;
+    if (multiSignerContext?.isMultiSigner) {
+      fieldsToFlatten = allFormFields.filter((f) => {
+        const fieldName = f.getName();
+        if (!extractedFormFields || extractedFormFields.length === 0) {
+          return true;
+        }
+        const fieldInfo = extractedFormFields.find((fi) => fi.name === fieldName);
+        if (!fieldInfo) {
+          return true;
+        }
+        return shouldFlattenField(fieldInfo, multiSignerContext);
+      });
+    } else {
+      fieldsToFlatten = allFormFields;
+    }
+    let flattenedCount = 0;
+    for (const field of fieldsToFlatten) {
+      const fieldName = field.getName();
+      const fieldType = field.constructor.name;
+      try {
+        const userEnteredValue = formFieldValues[fieldName];
+        const isSignatureField2 = fieldName.toLowerCase().includes("signature") || fieldType.includes("Signature");
+        const isInitialsField2 = fieldName.toLowerCase().includes("initials") || fieldType.includes("Initials");
+        if (isSignatureField2 || isInitialsField2) {
+          form.removeField(field);
+          flattenedCount++;
+          continue;
+        }
+        const fieldWithWidgets = field;
+        const widgets = fieldWithWidgets.acroField?.getWidgets?.() || [];
+        if (fieldType === "PDFCheckBox" || fieldType === "PDFCheckBox2") {
+          const stringValue = String(userEnteredValue || "");
+          const isChecked = stringValue === "true" || stringValue === "Yes" || stringValue === "On" || stringValue === "checked";
+          if (isChecked) {
+            for (const widget of widgets) {
+              const result = getWidgetRectangleAndPage(widget, pages);
+              if (!result) continue;
+              const { rect, page } = result;
+              const checkboxSize = Math.min(rect.width, rect.height) * 0.6;
+              const checkboxX = rect.x + (rect.width - checkboxSize) / 2;
+              const checkboxY = rect.y + (rect.height - checkboxSize) / 2;
+              page.drawRectangle({
+                x: checkboxX,
+                y: checkboxY,
+                width: checkboxSize,
+                height: checkboxSize,
+                borderColor: rgb(0, 0, 0),
+                borderWidth: 1
+              });
+              const checkSize = checkboxSize * 0.6;
+              const textWidth = checkSize * 0.6;
+              const textHeight = checkSize * 0.8;
+              page.drawText("X", {
+                x: checkboxX + (checkboxSize - textWidth) / 2,
+                y: checkboxY + (checkboxSize - textHeight) / 2 + textHeight * 0.2,
+                size: checkSize,
+                font: await pdfDoc.embedFont(StandardFonts.HelveticaBold),
+                color: rgb(0, 0, 0)
+              });
+            }
+          }
+        } else if (fieldType === "PDFRadioGroup" || fieldType === "PDFRadioGroup2") {
+          let selectedValue = userEnteredValue ? String(userEnteredValue) : "";
+          if (selectedValue.startsWith("__RADIO_OPTION_INDEX_")) {
+            const indexMatch = selectedValue.match(/__RADIO_OPTION_INDEX_(\d+)__/);
+            if (indexMatch && indexMatch[1]) {
+              selectedValue = indexMatch[1];
+            }
+          }
+          let selectedIndex = -1;
+          if (selectedValue === "Option A") selectedIndex = 0;
+          else if (selectedValue === "Option B") selectedIndex = 1;
+          else if (selectedValue === "Option C") selectedIndex = 2;
+          else if (/^\d+$/.test(selectedValue)) {
+            selectedIndex = parseInt(selectedValue, 10);
+          }
+          const fieldInfo = extractedFormFields?.find((f) => f.name === fieldName);
+          const labelFont = await pdfDoc.embedFont("Helvetica-Bold");
+          const drawnGroupLabels = /* @__PURE__ */ new Set();
+          const drawnOptionLabels = /* @__PURE__ */ new Set();
+          for (let i = 0; i < widgets.length; i++) {
+            const widget = widgets[i];
+            const result = getWidgetRectangleAndPage(widget, pages);
+            if (!result) continue;
+            const { rect, page, pageIndex } = result;
+            if (i === 0 && fieldInfo?.label && fieldInfo.label.trim() && !isAutoGeneratedLabel(fieldInfo.label)) {
+              const groupLabelKey = `${pageIndex}-${fieldName}-grouplabel`;
+              if (!drawnGroupLabels.has(groupLabelKey)) {
+                const labelY = rect.y + rect.height + 3;
+                page.drawText(fieldInfo.label, {
+                  x: rect.x,
+                  y: labelY,
+                  size: 8,
+                  font: labelFont,
+                  color: rgb(0, 0, 0)
+                });
+                drawnGroupLabels.add(groupLabelKey);
+              }
+            } else if (i === 0 && isAutoGeneratedLabel(fieldInfo?.label || "")) {
+            }
+            const radioSize = Math.min(rect.width, rect.height) * 0.5;
+            const radioX = rect.x + (rect.width - radioSize) / 2;
+            const radioY = rect.y + (rect.height - radioSize) / 2;
+            page.drawCircle({
+              x: radioX + radioSize / 2,
+              y: radioY + radioSize / 2,
+              size: radioSize,
+              borderColor: rgb(0, 0, 0),
+              borderWidth: 1
+            });
+            if (i === selectedIndex) {
+              const circleSize = radioSize * 0.5;
+              page.drawCircle({
+                x: radioX + radioSize / 2,
+                y: radioY + radioSize / 2,
+                size: circleSize,
+                color: rgb(0, 0, 0)
+              });
+            }
+            if (fieldInfo?.options && fieldInfo.options.length > i) {
+              const optionText = fieldInfo.options[i];
+              const optionKey = `${pageIndex}-${fieldName}-opt-${i}`;
+              if (optionText && !drawnOptionLabels.has(optionKey)) {
+                page.drawText(optionText, {
+                  x: rect.x + rect.width + 4,
+                  y: rect.y + (rect.height - 8) / 2,
+                  size: 8,
+                  font: labelFont,
+                  color: rgb(0, 0, 0)
+                });
+                drawnOptionLabels.add(optionKey);
+              }
+            }
+          }
+          if (fieldInfo?.options) {
+          }
+        } else if (fieldType === "PDFDropdown" || fieldType === "PDFDropdown2") {
+          const selectedValue = userEnteredValue ? String(userEnteredValue) : "";
+          if (selectedValue && selectedValue.trim()) {
+            for (const widget of widgets) {
+              const result = getWidgetRectangleAndPage(widget, pages);
+              if (!result) continue;
+              const { rect, page } = result;
+              page.drawText(selectedValue, {
+                x: rect.x + 2,
+                y: rect.y + 2,
+                size: 10,
+                font: await pdfDoc.embedFont(StandardFonts.Helvetica),
+                color: rgb(0, 0, 0)
+              });
+            }
+          }
+        } else {
+          const fieldValue = userEnteredValue ? String(userEnteredValue) : "";
+          if (fieldValue && fieldValue.trim()) {
+            for (const widget of widgets) {
+              const result = getWidgetRectangleAndPage(widget, pages);
+              if (!result) continue;
+              const { rect, page } = result;
+              page.drawText(fieldValue, {
+                x: rect.x + 2,
+                y: rect.y + 2,
+                size: 10,
+                font: await pdfDoc.embedFont(StandardFonts.Helvetica),
+                color: rgb(0, 0, 0)
+              });
+            }
+          }
+        }
+        form.removeField(field);
+        flattenedCount++;
+      } catch (error) {
+      }
+    }
+    const remainingFields = form.getFields();
+    if (multiSignerContext?.isMultiSigner) {
+      const expectedRemainingCount = allFormFields.length - fieldsToFlatten.length;
+      if (remainingFields.length === expectedRemainingCount) {
+      } else {
+      }
+    } else {
+      if (remainingFields.length > 0) {
+        logger.error(`MANUAL FLATTENING INCOMPLETE: ${remainingFields.length} fields still exist!`);
+        logger.error(`Remaining fields:`, remainingFields.map((f) => f.getName()));
+        try {
+          form.flatten();
+          const finalRemainingFields = form.getFields();
+          if (finalRemainingFields.length > 0) {
+            logger.error(`ALL FLATTENING METHODS FAILED: ${finalRemainingFields.length} fields still exist!`);
+            logger.error(`Final remaining fields:`, finalRemainingFields.map((f) => f.getName()));
+          }
+        } catch (fallbackError) {
+          logger.error("Fallback flattening failed:", fallbackError);
+        }
+      } else {
+      }
+    }
+    try {
+      const documentTitle = metadata?.documentId ? `Document ID: ${metadata.documentId}` : "Signed Document";
+      pdfDoc.setTitle(documentTitle);
+      const documentSubject = metadata?.submissionId ? `Submission ID: ${metadata.submissionId}` : metadata?.signerEmail ? `Signed by ${metadata.signerEmail}` : "Digitally Signed Document";
+      pdfDoc.setSubject(documentSubject);
+      const documentAuthor = metadata?.author || metadata?.signerEmail || "Unknown";
+      pdfDoc.setAuthor(documentAuthor);
+      pdfDoc.setProducer("Created by signiphi (https://signiphi.ai/)");
+      if (metadata?.signerEmail) {
+        pdfDoc.setCreator(`Signer: ${metadata.signerEmail}`);
+      }
+      if (metadata?.createdAt) {
+        pdfDoc.setCreationDate(metadata.createdAt);
+      }
+      pdfDoc.setModificationDate(/* @__PURE__ */ new Date());
+      const keywords = [];
+      if (metadata?.signerEmail) {
+        keywords.push(metadata.signerEmail);
+      }
+      if (metadata?.signerInitials && metadata.signerInitials.trim()) {
+        keywords.push(`Initials:${metadata.signerInitials.trim()}`);
+      }
+      if (auditTrail) {
+        try {
+          if (auditTrail.userAgent) {
+            keywords.push(`UserAgent:${auditTrail.userAgent}`);
+          }
+          if (auditTrail.screenResolution) {
+            keywords.push(`Screen:${auditTrail.screenResolution}`);
+          }
+          if (auditTrail.timezone) {
+            keywords.push(`Timezone:${auditTrail.timezone}`);
+          }
+          if (auditTrail.language) {
+            keywords.push(`Language:${auditTrail.language}`);
+          }
+          if (auditTrail.platform) {
+            keywords.push(`Platform:${auditTrail.platform}`);
+          }
+          if (auditTrail.ipAddress) {
+            keywords.push(`IP:${auditTrail.ipAddress}`);
+          }
+          if (auditTrail.geolocation) {
+            const { latitude, longitude, accuracy } = auditTrail.geolocation;
+            const lat = latitude.toFixed(4);
+            const lon = longitude.toFixed(4);
+            keywords.push(`Location:${lat},${lon}`);
+            if (accuracy !== void 0) {
+              keywords.push(`LocationAccuracy:${accuracy}m`);
+            }
+          }
+        } catch (auditError) {
+          logger.warn("\u26A0\uFE0F Error adding audit trail to keywords:", auditError);
+        }
+      }
+      if (keywords.length > 0) {
+        pdfDoc.setKeywords(keywords);
+      }
+    } catch (error) {
+      logger.error("Failed to set document metadata:", error);
+    }
+    const finalPdfBytes = await pdfDoc.save();
+    return finalPdfBytes;
+  } catch (error) {
+    logger.error("Error filling PDF with signatures:", error);
+    throw error;
+  }
+}
+async function fillFormFieldsWithSignatures(pdfBytes, formFields, fieldValues, signatures) {
+  try {
+    const { PDFDocument, rgb, StandardFonts } = await loadPdfLib();
+    const pdfDoc = await PDFDocument.load(pdfBytes);
+    const pages = pdfDoc.getPages();
+    const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
+    for (const field of formFields) {
+      const pageIndex = field.position.page - 1;
+      if (pageIndex < 0 || pageIndex >= pages.length) {
+        continue;
+      }
+      const page = pages[pageIndex];
+      if (!page) continue;
+      const { height: pageHeight } = page.getSize();
+      const pdfX = field.position.x;
+      const pdfY = pageHeight - field.position.y - field.position.height;
+      try {
+        switch (field.type) {
+          case "text" /* TEXT */: {
+            const value = fieldValues[field.id] || "";
+            if (value) {
+              const fontSize = field.fontSize && field.fontSize >= 8 && field.fontSize <= 72 ? field.fontSize : Math.min(12, field.position.height * 0.6);
+              page.drawText(value, {
+                x: pdfX + 2,
+                // Small padding
+                y: pdfY + (field.position.height - fontSize) / 2,
+                // Center vertically
+                size: fontSize,
+                font,
+                color: rgb(0, 0, 0),
+                maxWidth: field.position.width - 4
+                // Leave padding
+              });
+            }
+            break;
+          }
+          case "date" /* DATE */: {
+            const value = fieldValues[field.id] || "";
+            if (value) {
+              const fontSize = field.fontSize && field.fontSize >= 8 && field.fontSize <= 72 ? field.fontSize : Math.min(12, field.position.height * 0.6);
+              page.drawText(value, {
+                x: pdfX + 2,
+                y: pdfY + (field.position.height - fontSize) / 2,
+                size: fontSize,
+                font,
+                color: rgb(0, 0, 0),
+                maxWidth: field.position.width - 4
+              });
+            }
+            break;
+          }
+          case "checkbox" /* CHECKBOX */: {
+            const value = fieldValues[field.id] || "";
+            if (value === "true") {
+              const checkSize = Math.min(field.position.width, field.position.height) * 0.6;
+              const checkX = pdfX + (field.position.width - checkSize) / 2;
+              const checkY = pdfY + (field.position.height - checkSize) / 2;
+              page.drawText("\u2713", {
+                x: checkX,
+                y: checkY,
+                size: checkSize,
+                font,
+                color: rgb(0, 0, 0)
+              });
+            }
+            break;
+          }
+          case "signature" /* SIGNATURE */: {
+            const signatureDataUrl = signatures[field.id];
+            if (signatureDataUrl) {
+              const base64Data = signatureDataUrl.split(",")[1];
+              if (!base64Data) {
+                logger.error("Invalid signature data URL format for field:", field.id);
+                break;
+              }
+              const imageBytes = Uint8Array.from(atob(base64Data), (c) => c.charCodeAt(0));
+              const image = await pdfDoc.embedPng(imageBytes);
+              const imageSize = image.size();
+              const fieldAspectRatio = field.position.width / field.position.height;
+              const imageAspectRatio = imageSize.width / imageSize.height;
+              let drawWidth = field.position.width;
+              let drawHeight = field.position.height;
+              if (imageAspectRatio > fieldAspectRatio) {
+                drawHeight = drawWidth / imageAspectRatio;
+              } else {
+                drawWidth = drawHeight * imageAspectRatio;
+              }
+              const imageX = pdfX + (field.position.width - drawWidth) / 2;
+              const imageY = pdfY + (field.position.height - drawHeight) / 2;
+              page.drawImage(image, {
+                x: imageX,
+                y: imageY,
+                width: drawWidth,
+                height: drawHeight
+              });
+            }
+            break;
+          }
+          case "initials" /* INITIALS */: {
+            const value = fieldValues[field.id] || "";
+            if (value) {
+              const fontSize = Math.min(18, field.position.height * 0.8);
+              page.drawText(value, {
+                x: pdfX + 2,
+                y: pdfY + (field.position.height - fontSize) / 2,
+                size: fontSize,
+                font,
+                color: rgb(0, 0, 0),
+                maxWidth: field.position.width - 4
+              });
+            }
+            break;
+          }
+          case "dropdown" /* DROPDOWN */: {
+            const value = fieldValues[field.id] || "";
+            if (value) {
+              const fontSize = Math.min(12, field.position.height * 0.6);
+              page.drawText(value, {
+                x: pdfX + 2,
+                y: pdfY + (field.position.height - fontSize) / 2,
+                size: fontSize,
+                font,
+                color: rgb(0, 0, 0),
+                maxWidth: field.position.width - 4
+              });
+            }
+            break;
+          }
+          default:
+            break;
+        }
+      } catch (fieldError) {
+        logger.error(`Error processing field ${field.name}:`, fieldError);
+      }
+    }
+    return await pdfDoc.save();
+  } catch (error) {
+    logger.error("Error filling form fields:", error);
+    throw error;
+  }
+}
+async function getFieldPageNumbers(pdfBytes) {
+  try {
+    const { PDFDocument } = await loadPdfLib();
+    const pdfDoc = await PDFDocument.load(pdfBytes);
+    const form = pdfDoc.getForm();
+    const fields = form.getFields();
+    const pages = pdfDoc.getPages();
+    const pageMap = {};
+    const positionMap = {};
+    for (const field of fields) {
+      const fieldName = field.getName();
+      const fieldWithAcro = field;
+      const widgets = fieldWithAcro.acroField?.getWidgets?.() ?? [];
+      if (widgets.length > 0) {
+        const widget = widgets[0];
+        if (!widget) continue;
+        const rect = widget.getRectangle?.();
+        const pageRef = widget.P?.();
+        if (rect && pageRef) {
+          const pageIndex = findPageIndexByRef(pages, pageRef);
+          if (pageIndex !== -1) {
+            const pageNumber = pageIndex + 1;
+            pageMap[fieldName] = pageNumber;
+            positionMap[fieldName] = {
+              x: rect.x,
+              y: rect.y,
+              width: rect.width,
+              height: rect.height,
+              page: pageNumber
+            };
+          }
+        }
+      }
+    }
+    return { pageMap, positionMap };
+  } catch (error) {
+    logger.error("Error extracting field page numbers:", error);
+    return { pageMap: {}, positionMap: {} };
+  }
+}
+
+// src/utils/field-extraction.ts
+var PDFName;
+async function extractVisibleFormFields(pdfBytes, currentSignerEmail) {
+  try {
+    const pdfLibModule = await loadPdfLib();
+    const { PDFDocument, AnnotationFlags, PDFName: PDFNameClass } = pdfLibModule;
+    PDFName = PDFNameClass;
+    const pdfDoc = await PDFDocument.load(pdfBytes);
+    const form = pdfDoc.getForm();
+    const fields = form.getFields();
+    const visibleFields = [];
+    let hasAnyInitialsFields = false;
+    let hasInitialsFieldsForCurrentSigner = false;
+    for (const field of fields) {
+      const fieldName = field.getName();
+      const fieldWithExtensions = field;
+      const widgets = fieldWithExtensions.acroField?.getWidgets?.() ?? [];
+      let isVisible = true;
+      for (const widget of widgets) {
+        const hasHiddenFlag = widget.hasFlag?.(AnnotationFlags.Hidden) ?? false;
+        const hasNoViewFlag = widget.hasFlag?.(AnnotationFlags.NoView) ?? false;
+        if (hasHiddenFlag || hasNoViewFlag) {
+          isVisible = false;
+          break;
+        }
+      }
+      if (isVisible) {
+        const decodedInfo = decodeFieldName(fieldName);
+        let fieldType = "text" /* TEXT */;
+        const fieldTypeName = field.constructor.name;
+        const isActualSignatureField = fieldTypeName.includes("Signature") || decodedInfo.decodedFieldName.toLowerCase().includes("signature") && !fieldTypeName.includes("CheckBox") && !fieldTypeName.includes("Radio");
+        const isActualInitialsField = decodedInfo.decodedFieldName.toLowerCase().includes("initials") && !fieldTypeName.includes("CheckBox") && !fieldTypeName.includes("Radio");
+        if (isActualSignatureField) {
+          fieldType = "signature" /* SIGNATURE */;
+        } else if (isActualInitialsField) {
+          fieldType = "initials" /* INITIALS */;
+          hasAnyInitialsFields = true;
+          if (currentSignerEmail && decodedInfo.assignedSignerEmail === currentSignerEmail) {
+            hasInitialsFieldsForCurrentSigner = true;
+          }
+        } else if (decodedInfo.decodedFieldName.toLowerCase().includes("date")) {
+          fieldType = "date" /* DATE */;
+        } else if (fieldTypeName.includes("CheckBox")) {
+          fieldType = "checkbox" /* CHECKBOX */;
+        } else if (fieldTypeName.toLowerCase().includes("dropdown")) {
+          fieldType = "dropdown" /* DROPDOWN */;
+        } else if (fieldTypeName.includes("Radio")) {
+          fieldType = "radio" /* RADIO */;
+        }
+        let displayLabel = decodedInfo.displayLabel;
+        if (!displayLabel || !displayLabel.trim()) {
+          try {
+            const tuLabel = extractTULabel(fieldWithExtensions);
+            if (tuLabel && tuLabel.trim()) {
+              displayLabel = tuLabel;
+            }
+          } catch (tuError) {
+          }
+        }
+        if (!displayLabel || !displayLabel.trim()) {
+          displayLabel = generateFallbackLabel(decodedInfo.decodedFieldName, fieldType);
+        }
+        const esignField = {
+          id: fieldName,
+          // Keep original encoded name as ID
+          name: fieldName,
+          // Keep original for removal later
+          type: fieldType,
+          label: displayLabel,
+          // Use friendly label for display
+          position: { x: 0, y: 0, width: 100, height: 30, page: 1 },
+          // Default position
+          required: fieldWithExtensions.isRequired?.() ?? false,
+          placeholder: decodedInfo.fieldPlaceholder || "",
+          // Use extracted placeholder
+          assignedSignerEmail: decodedInfo.assignedSignerEmail
+          // Add assigned signer
+        };
+        if (fieldType === "dropdown" /* DROPDOWN */ || fieldType === "radio" /* RADIO */) {
+          try {
+            const options = fieldWithExtensions.getOptions?.() ?? [];
+            esignField.options = options;
+            if (options.length > 0) {
+            }
+          } catch (error) {
+            logger.warn("Error extracting options for field:", error);
+          }
+        }
+        visibleFields.push(esignField);
+      }
+    }
+    const mainFields = [];
+    mainFields.push({
+      id: "signature_field_main",
+      name: "signature_field_main",
+      type: "signature" /* SIGNATURE */,
+      label: "Your Signature (will be applied to all signature fields)",
+      position: { x: 0, y: 0, width: 200, height: 60, page: 1 },
+      required: true,
+      placeholder: "Draw or upload your signature",
+      assignedSignerEmail: currentSignerEmail
+    });
+    const shouldCreateInitialsField = hasInitialsFieldsForCurrentSigner || hasAnyInitialsFields && !currentSignerEmail;
+    if (shouldCreateInitialsField) {
+      if (hasInitialsFieldsForCurrentSigner) {
+      } else {
+      }
+      mainFields.push({
+        id: "initials_field_main",
+        name: "initials_field_main",
+        type: "initials" /* INITIALS */,
+        label: "Your Initials (will be applied to all initials fields)",
+        position: { x: 0, y: 0, width: 100, height: 40, page: 1 },
+        required: true,
+        placeholder: "Enter your initials",
+        assignedSignerEmail: currentSignerEmail
+      });
+    }
+    return [...mainFields, ...visibleFields];
+  } catch (error) {
+    logger.error("Error extracting visible form fields from PDF:", error);
+    return [];
+  }
+}
+function decodeFieldName(fieldName) {
+  let decodedFieldName = fieldName;
+  let displayLabel = "";
+  let assignedSignerEmail = void 0;
+  let fieldPlaceholder = "";
+  if (fieldName.includes("__LABEL__")) {
+    const labelMarkerIndex = fieldName.indexOf("__LABEL__");
+    decodedFieldName = fieldName.substring(0, labelMarkerIndex);
+    const afterLabel = fieldName.substring(labelMarkerIndex + 9);
+    if (afterLabel.includes("__SIGNER__")) {
+      const signerMarkerIndex = afterLabel.indexOf("__SIGNER__");
+      displayLabel = afterLabel.substring(0, signerMarkerIndex);
+      const afterSigner = afterLabel.substring(signerMarkerIndex + 10);
+      if (afterSigner.includes("__PLACEHOLDER__")) {
+        const placeholderMarkerIndex = afterSigner.indexOf("__PLACEHOLDER__");
+        assignedSignerEmail = afterSigner.substring(0, placeholderMarkerIndex);
+        fieldPlaceholder = afterSigner.substring(placeholderMarkerIndex + 15);
+      } else {
+        assignedSignerEmail = afterSigner;
+      }
+    } else if (afterLabel.includes("__PLACEHOLDER__")) {
+      const placeholderMarkerIndex = afterLabel.indexOf("__PLACEHOLDER__");
+      displayLabel = afterLabel.substring(0, placeholderMarkerIndex);
+      fieldPlaceholder = afterLabel.substring(placeholderMarkerIndex + 15);
+    } else {
+      displayLabel = afterLabel;
+    }
+  } else if (fieldName.includes("__SIGNER__")) {
+    const signerMarkerIndex = fieldName.indexOf("__SIGNER__");
+    decodedFieldName = fieldName.substring(0, signerMarkerIndex);
+    const afterSigner = fieldName.substring(signerMarkerIndex + 10);
+    if (afterSigner.includes("__PLACEHOLDER__")) {
+      const placeholderMarkerIndex = afterSigner.indexOf("__PLACEHOLDER__");
+      assignedSignerEmail = afterSigner.substring(0, placeholderMarkerIndex);
+      fieldPlaceholder = afterSigner.substring(placeholderMarkerIndex + 15);
+    } else {
+      assignedSignerEmail = afterSigner;
+    }
+  } else if (fieldName.includes("__PLACEHOLDER__")) {
+    const placeholderMarkerIndex = fieldName.indexOf("__PLACEHOLDER__");
+    decodedFieldName = fieldName.substring(0, placeholderMarkerIndex);
+    fieldPlaceholder = fieldName.substring(placeholderMarkerIndex + 15);
+  }
+  return {
+    decodedFieldName,
+    displayLabel,
+    assignedSignerEmail,
+    fieldPlaceholder
+  };
+}
+function generateFallbackLabel(decodedFieldName, fieldType) {
+  let displayLabel = decodedFieldName;
+  displayLabel = displayLabel.replace(/_signature$/i, "").replace(/_initials$/i, "").replace(/_date$/i, "");
+  if (/^(text|signature|initials|date)_\d+$/i.test(displayLabel)) {
+    if (fieldType === "signature" /* SIGNATURE */) return "Signature";
+    if (fieldType === "initials" /* INITIALS */) return "Initials";
+    if (fieldType === "date" /* DATE */) return "Date";
+    if (fieldType === "text" /* TEXT */) return "Text";
+    if (fieldType === "checkbox" /* CHECKBOX */) return "Checkbox";
+    if (fieldType === "dropdown" /* DROPDOWN */) return "Dropdown";
+    if (fieldType === "radio" /* RADIO */) return "Option";
+  } else {
+    displayLabel = displayLabel.replace(/_/g, " ").replace(/\s+\d+$/g, "").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+  }
+  return displayLabel;
+}
+function extractTULabel(field) {
+  try {
+    if (!field.acroField?.dict) {
+      return "";
+    }
+    const tuLabel = field.acroField.dict.get(PDFName.of("TU"));
+    if (!tuLabel) {
+      return "";
+    }
+    const tuValue = tuLabel.toString();
+    if (!tuValue || !tuValue.trim()) {
+      return "";
+    }
+    if (tuValue.startsWith("(") || tuValue.startsWith("<")) {
+      const match = tuValue.match(/^\((.*)\)$/) || tuValue.match(/^<(.*)>$/);
+      if (match && match[1]) {
+        return match[1];
+      }
+    }
+    return tuValue;
+  } catch (error) {
+    return "";
+  }
+}
+var CDN_WORKER = "https://cdn.jsdelivr.net/npm/pdfjs-dist@5.3.93/build/pdf.worker.mjs";
+var CDN_VIEWER = "https://mozilla.github.io/pdf.js";
+var _workerSrcComputed = false;
+var _cachedWorkerSrc = null;
+function getDefaultWorkerSrc() {
+  if (_workerSrcComputed && _cachedWorkerSrc !== null) {
+    return _cachedWorkerSrc;
+  }
+  let workerSrc = "/pdfjs/build/pdf.worker.mjs";
+  if (typeof window !== "undefined" && typeof URL !== "undefined") {
+    try {
+      const meta = (function() {
+        try {
+          return new Function("return import.meta")();
+        } catch {
+          return null;
+        }
+      })();
+      if (meta && meta.url) {
+        workerSrc = new URL("pdfjs-dist/build/pdf.worker.mjs", meta.url).href;
+      }
+    } catch {
+    }
+  }
+  _workerSrcComputed = true;
+  _cachedWorkerSrc = workerSrc;
+  return workerSrc;
+}
+var globalConfig = {
+  viewerBasePath: "/pdfjs",
+  workerSrc: ""
+  // Lazy-initialized below
+};
+var _configInitialized = false;
+function ensureConfigInitialized() {
+  if (!_configInitialized) {
+    globalConfig.workerSrc = getDefaultWorkerSrc();
+    _configInitialized = true;
+    if (typeof window !== "undefined") {
+      pdfjsLib2__namespace.GlobalWorkerOptions.workerSrc = globalConfig.workerSrc;
+    }
+  }
+}
+function setPdfJsConfig(config) {
+  ensureConfigInitialized();
+  if (config.viewerBasePath !== void 0) {
+    globalConfig.viewerBasePath = config.viewerBasePath;
+  }
+  if (config.workerSrc !== void 0) {
+    globalConfig.workerSrc = config.workerSrc;
+  } else if (config.viewerBasePath !== void 0) {
+    globalConfig.workerSrc = `${config.viewerBasePath}/build/pdf.worker.mjs`;
+  }
+  if (typeof window !== "undefined") {
+    pdfjsLib2__namespace.GlobalWorkerOptions.workerSrc = globalConfig.workerSrc;
+  }
+}
+function getPdfJsConfig() {
+  ensureConfigInitialized();
+  return { ...globalConfig };
+}
+function resetPdfJsConfig() {
+  _workerSrcComputed = false;
+  _cachedWorkerSrc = null;
+  _configInitialized = false;
+  ensureConfigInitialized();
+}
+function initializePdfJs() {
+  ensureConfigInitialized();
+}
+async function checkPdfJsVersion(viewerBasePath = "/pdfjs") {
+  const workerVersion = pdfjsLib2__namespace.version;
+  try {
+    const versionUrl = `${viewerBasePath}/.version`;
+    const response = await fetch(versionUrl);
+    if (!response.ok) {
+      return {
+        viewerExists: false,
+        versionMatch: false,
+        workerVersion,
+        errorMessage: "PDF.js viewer files not found. Run: npx signiphi-setup"
+      };
+    }
+    const viewerVersion = (await response.text()).trim();
+    const versionMatch = viewerVersion === workerVersion;
+    if (!versionMatch) {
+      return {
+        viewerExists: true,
+        versionMatch: false,
+        viewerVersion,
+        workerVersion,
+        errorMessage: `Version mismatch: viewer=${viewerVersion}, worker=${workerVersion}. Run: npx signiphi-setup`
+      };
+    }
+    return {
+      viewerExists: true,
+      versionMatch: true,
+      viewerVersion,
+      workerVersion
+    };
+  } catch (error) {
+    return {
+      viewerExists: false,
+      versionMatch: false,
+      workerVersion,
+      errorMessage: "Unable to check PDF.js version. Viewer files may not be installed."
+    };
+  }
+}
+function logVersionCheckWarning(result) {
+  if (!result.viewerExists) {
+    console.warn(
+      "\u26A0\uFE0F PDF.js viewer files not found.\nThe PDF viewer requires viewer files to be installed.\nRun: npx signiphi-setup\nOr reinstall the package: npm install @signiphi/pdf-signer"
+    );
+  } else if (!result.versionMatch) {
+    console.warn(
+      `\u26A0\uFE0F PDF.js version mismatch detected:
+   Viewer: ${result.viewerVersion}
+   Worker: ${result.workerVersion}
+Run: npx signiphi-setup to sync versions`
+    );
+  }
+}
+async function checkAndLogPdfJsVersion(viewerBasePath = "/pdfjs") {
+  const result = await checkPdfJsVersion(viewerBasePath);
+  if (!result.viewerExists || !result.versionMatch) {
+    logVersionCheckWarning(result);
+  }
+  return result;
+}
+
+// src/utils/audit-trail.ts
+function captureDeviceMetadata() {
+  const metadata = {};
+  try {
+    if (navigator.userAgent) {
+      metadata.userAgent = navigator.userAgent.substring(0, 100);
+    }
+    if (screen.width && screen.height) {
+      metadata.screenResolution = `${screen.width}x${screen.height}`;
+    }
+    try {
+      const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      if (timezone) {
+        metadata.timezone = timezone;
+      }
+    } catch {
+    }
+    if (navigator.language) {
+      metadata.language = navigator.language;
+    }
+    if (navigator.platform) {
+      metadata.platform = navigator.platform;
+    }
+  } catch (error) {
+    logger.warn("Error capturing device metadata:", error);
+  }
+  return metadata;
+}
+async function captureIpAddress() {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const ipResponse = await fetch("https://api.ipify.org?format=json", {
+      method: "GET",
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (ipResponse.ok) {
+      const ipData = await ipResponse.json();
+      if (ipData.ip) {
+        return ipData.ip;
+      }
+    }
+    return "Unknown";
+  } catch (error) {
+    return "Unknown";
+  }
+}
+async function captureGeolocation() {
+  if (!navigator.geolocation) {
+    return null;
+  }
+  try {
+    const position = await new Promise((resolve, reject) => {
+      navigator.geolocation.getCurrentPosition(resolve, reject, {
+        timeout: 1e4,
+        // 10 second timeout
+        enableHighAccuracy: false,
+        maximumAge: 3e5
+        // 5 minutes cache
+      });
+    });
+    if (position.coords) {
+      const latitude = parseFloat(position.coords.latitude.toFixed(4));
+      const longitude = parseFloat(position.coords.longitude.toFixed(4));
+      const accuracy = position.coords.accuracy ? Math.round(position.coords.accuracy) : void 0;
+      return {
+        latitude,
+        longitude,
+        accuracy
+      };
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+async function captureAuditTrail() {
+  const auditTrail = {};
+  try {
+    const deviceMetadata = captureDeviceMetadata();
+    Object.assign(auditTrail, deviceMetadata);
+    try {
+      const ipAddress = await captureIpAddress();
+      auditTrail.ipAddress = ipAddress;
+    } catch (error) {
+      logger.warn("Error capturing IP address:", error);
+      auditTrail.ipAddress = "Unknown";
+    }
+    try {
+      const geolocation = await captureGeolocation();
+      if (geolocation) {
+        auditTrail.geolocation = geolocation;
+      }
+    } catch (error) {
+      logger.warn("Error capturing geolocation:", error);
+    }
+  } catch (error) {
+    logger.warn("Error capturing audit trail:", error);
+  }
+  return auditTrail;
+}
+
+// src/utils/errors.ts
+var PdfValidationError = class _PdfValidationError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "PdfValidationError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _PdfValidationError);
+    }
+  }
+};
+var PdfProcessingError = class _PdfProcessingError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "PdfProcessingError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _PdfProcessingError);
+    }
+  }
+};
+var FormFieldError = class _FormFieldError extends Error {
+  constructor(message, fieldName, details) {
+    super(message);
+    this.fieldName = fieldName;
+    this.details = details;
+    this.name = "FormFieldError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FormFieldError);
+    }
+  }
+};
+var AttachmentValidationError = class _AttachmentValidationError extends Error {
+  constructor(message, fileName, details) {
+    super(message);
+    this.fileName = fileName;
+    this.details = details;
+    this.name = "AttachmentValidationError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AttachmentValidationError);
+    }
+  }
+};
+function isPdfValidationError(error) {
+  return error instanceof PdfValidationError;
+}
+function isPdfProcessingError(error) {
+  return error instanceof PdfProcessingError;
+}
+function isFormFieldError(error) {
+  return error instanceof FormFieldError;
+}
+function isAttachmentValidationError(error) {
+  return error instanceof AttachmentValidationError;
+}
+function getErrorMessage(error, defaultMessage = "Unknown error") {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return defaultMessage;
+}
+
+// src/utils/attachment-validators.ts
+var DEFAULT_ATTACHMENT_CONSTRAINTS = {
+  maxFileSize: 10 * 1024 * 1024,
+  // 10MB
+  maxTotalSize: 50 * 1024 * 1024,
+  // 50MB
+  maxFiles: 10,
+  allowedTypes: ["image/*", "application/pdf", "application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
+  allowedExtensions: [".pdf", ".jpg", ".jpeg", ".png", ".gif", ".doc", ".docx"]
+};
+function validateFile(file, constraints = DEFAULT_ATTACHMENT_CONSTRAINTS) {
+  const errors = [];
+  if (file.size > constraints.maxFileSize) {
+    const maxMB = (constraints.maxFileSize / 1024 / 1024).toFixed(1);
+    const fileMB = (file.size / 1024 / 1024).toFixed(1);
+    errors.push(`File "${file.name}" is too large (${fileMB}MB). Maximum size is ${maxMB}MB.`);
+  }
+  const isTypeAllowed = constraints.allowedTypes.some((allowedType) => {
+    if (allowedType.endsWith("/*")) {
+      const prefix = allowedType.slice(0, -2);
+      return file.type.startsWith(prefix);
+    }
+    return file.type === allowedType;
+  });
+  if (!isTypeAllowed && constraints.allowedTypes.length > 0) {
+    errors.push(
+      `File type "${file.type}" is not allowed for "${file.name}". Allowed types: ${constraints.allowedTypes.join(", ")}`
+    );
+  }
+  if (constraints.allowedExtensions && constraints.allowedExtensions.length > 0) {
+    const fileExt = "." + file.name.split(".").pop()?.toLowerCase();
+    const isExtAllowed = constraints.allowedExtensions.some(
+      (ext) => ext.toLowerCase() === fileExt
+    );
+    if (!isExtAllowed) {
+      errors.push(
+        `File extension "${fileExt}" is not allowed for "${file.name}". Allowed extensions: ${constraints.allowedExtensions.join(", ")}`
+      );
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateFiles(files, existingAttachments = [], constraints = DEFAULT_ATTACHMENT_CONSTRAINTS) {
+  const errors = [];
+  const totalFiles = files.length + existingAttachments.length;
+  if (totalFiles > constraints.maxFiles) {
+    errors.push(
+      `Too many files. Maximum allowed is ${constraints.maxFiles}, you have ${totalFiles} files total.`
+    );
+  }
+  const existingSize = existingAttachments.reduce((sum, att) => sum + att.size, 0);
+  const newFilesSize = files.reduce((sum, file) => sum + file.size, 0);
+  const totalSize = existingSize + newFilesSize;
+  if (totalSize > constraints.maxTotalSize) {
+    const maxMB = (constraints.maxTotalSize / 1024 / 1024).toFixed(1);
+    const totalMB = (totalSize / 1024 / 1024).toFixed(1);
+    errors.push(
+      `Total size of all files is too large (${totalMB}MB). Maximum total size is ${maxMB}MB.`
+    );
+  }
+  for (const file of files) {
+    const fileResult = validateFile(file, constraints);
+    errors.push(...fileResult.errors);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateFileOrThrow(file, constraints = DEFAULT_ATTACHMENT_CONSTRAINTS) {
+  const result = validateFile(file, constraints);
+  if (!result.valid) {
+    throw new AttachmentValidationError(
+      `File validation failed: ${result.errors.join("; ")}`,
+      file.name,
+      { file, errors: result.errors }
+    );
+  }
+}
+function validateFilesOrThrow(files, existingAttachments = [], constraints = DEFAULT_ATTACHMENT_CONSTRAINTS) {
+  const result = validateFiles(files, existingAttachments, constraints);
+  if (!result.valid) {
+    throw new AttachmentValidationError(
+      `File validation failed: ${result.errors.join("; ")}`,
+      void 0,
+      { files, errors: result.errors }
+    );
+  }
+}
+function isImageType(fileType) {
+  return fileType.startsWith("image/");
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
+}
+
+// src/utils/performance-monitor.ts
+var PerformanceMonitor = class {
+  constructor(enabled = true) {
+    __publicField(this, "metrics", /* @__PURE__ */ new Map());
+    __publicField(this, "enabled");
+    this.enabled = enabled;
+  }
+  /**
+   * Start a timer for a labeled operation
+   * 
+   * @param label - Unique label for the operation
+   * @returns Function to call when operation completes
+   * 
+   * @example
+   * ```typescript
+   * const endTimer = monitor.startTimer('pdf-load');
+   * await loadPdf(url);
+   * endTimer(); // Records duration
+   * ```
+   */
+  startTimer(label) {
+    if (!this.enabled) {
+      return () => {
+      };
+    }
+    const startTime = performance.now();
+    return () => {
+      const duration = performance.now() - startTime;
+      this.measure(label, duration);
+    };
+  }
+  /**
+   * Manually record a performance measurement
+   * 
+   * @param label - Unique label for the operation
+   * @param duration - Duration in milliseconds
+   * 
+   * @example
+   * ```typescript
+   * monitor.measure('pdf-load', 1234.56);
+   * ```
+   */
+  measure(label, duration) {
+    if (!this.enabled) {
+      return;
+    }
+    const measurements = this.metrics.get(label) || [];
+    measurements.push(duration);
+    this.metrics.set(label, measurements);
+    logger.info(`[Performance] ${label}: ${duration.toFixed(2)}ms`);
+  }
+  /**
+   * Get all recorded metrics with statistics
+   * 
+   * @returns Object containing metrics for all labels
+   * 
+   * @example
+   * ```typescript
+   * const metrics = monitor.getMetrics();
+   * console.log(`PDF load avg: ${metrics['pdf-load'].avg}ms`);
+   * ```
+   */
+  getMetrics() {
+    const result = {};
+    for (const [label, measurements] of this.metrics.entries()) {
+      if (measurements.length === 0) continue;
+      const total = measurements.reduce((sum, val) => sum + val, 0);
+      const avg = total / measurements.length;
+      const min = Math.min(...measurements);
+      const max = Math.max(...measurements);
+      const last = measurements[measurements.length - 1] ?? 0;
+      result[label] = {
+        count: measurements.length,
+        total,
+        avg,
+        min,
+        max,
+        last
+      };
+    }
+    return result;
+  }
+  /**
+   * Get metrics for a specific label
+   * 
+   * @param label - Label to get metrics for
+   * @returns Metrics for the label, or null if not found
+   */
+  getMetric(label) {
+    const measurements = this.metrics.get(label);
+    if (!measurements || measurements.length === 0) {
+      return null;
+    }
+    const total = measurements.reduce((sum, val) => sum + val, 0);
+    const avg = total / measurements.length;
+    const min = Math.min(...measurements);
+    const max = Math.max(...measurements);
+    const last = measurements[measurements.length - 1] ?? 0;
+    return {
+      count: measurements.length,
+      total,
+      avg,
+      min,
+      max,
+      last
+    };
+  }
+  /**
+   * Get raw measurements for a label
+   * 
+   * @param label - Label to get measurements for
+   * @returns Array of duration measurements in milliseconds
+   */
+  getRawMeasurements(label) {
+    return this.metrics.get(label) || [];
+  }
+  /**
+   * Clear all metrics
+   */
+  clear() {
+    this.metrics.clear();
+  }
+  /**
+   * Clear metrics for a specific label
+   * 
+   * @param label - Label to clear metrics for
+   */
+  clearLabel(label) {
+    this.metrics.delete(label);
+  }
+  /**
+   * Enable or disable performance monitoring
+   * 
+   * @param enabled - Whether to enable monitoring
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Check if monitoring is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Generate a performance report as a string
+   * 
+   * @returns Formatted performance report
+   */
+  generateReport() {
+    const metrics = this.getMetrics();
+    const lines = [];
+    lines.push("Performance Report");
+    lines.push("=".repeat(50));
+    lines.push("");
+    for (const [label, stats] of Object.entries(metrics)) {
+      lines.push(`${label}:`);
+      lines.push(`  Count: ${stats.count}`);
+      lines.push(`  Avg:   ${stats.avg.toFixed(2)}ms`);
+      lines.push(`  Min:   ${stats.min.toFixed(2)}ms`);
+      lines.push(`  Max:   ${stats.max.toFixed(2)}ms`);
+      lines.push(`  Last:  ${stats.last.toFixed(2)}ms`);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+function createPerformanceMonitor(enabled) {
+  const isEnabled = enabled ?? process.env.NODE_ENV === "development";
+  return new PerformanceMonitor(isEnabled);
+}
+var globalPerformanceMonitor = createPerformanceMonitor();
+function measurePerformance(label, monitor = globalPerformanceMonitor) {
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const endTimer = monitor.startTimer(label);
+      try {
+        const result = await originalMethod.apply(this, args);
+        return result;
+      } finally {
+        endTimer();
+      }
+    };
+    return descriptor;
+  };
+}
+function withPerformanceMonitoring(label, fn, monitor = globalPerformanceMonitor) {
+  return (async (...args) => {
+    const endTimer = monitor.startTimer(label);
+    try {
+      return await fn(...args);
+    } finally {
+      endTimer();
+    }
+  });
+}
+function toIsoDateString(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function parseAndValidateDate(value) {
+  const originalValue = String(value || "");
+  if (!value || value.trim() === "") {
+    return {
+      isValid: false,
+      date: null,
+      isoString: null,
+      originalValue,
+      error: "Date is required"
+    };
+  }
+  const trimmedValue = value.trim();
+  const sanitizedValue = trimmedValue.replace(/(\d+)(st|nd|rd|th)/gi, "$1").replace(/,/g, " ").replace(/\s+/g, " ").trim();
+  try {
+    const isoDate = dateFns.parseISO(trimmedValue);
+    if (dateFns.isValid(isoDate) && !isNaN(isoDate.getTime())) {
+      return {
+        isValid: true,
+        date: isoDate,
+        isoString: trimmedValue,
+        originalValue
+      };
+    }
+  } catch {
+  }
+  const shortYearMatch = sanitizedValue.match(/^(\d{1,2})[\/.\-](\d{1,2})[\/.\-](\d{2})$/);
+  if (shortYearMatch) {
+    const [, monthStr, dayStr, yearStr] = shortYearMatch;
+    const month = parseInt(monthStr ?? "", 10);
+    const day = parseInt(dayStr ?? "", 10);
+    const year = 2e3 + parseInt(yearStr ?? "", 10);
+    const candidate = new Date(year, month - 1, day);
+    if (dateFns.isValid(candidate) && !isNaN(candidate.getTime())) {
+      return {
+        isValid: true,
+        date: candidate,
+        isoString: toIsoDateString(candidate),
+        originalValue
+      };
+    }
+  }
+  const formats = [
+    // US formats (MM/DD/YYYY - assume US for ambiguous dates)
+    { pattern: "MM/dd/yyyy", name: "US format (MM/DD/YYYY)" },
+    { pattern: "M/d/yyyy", name: "US format (M/D/YYYY)" },
+    { pattern: "MM-dd-yyyy", name: "US format (MM-DD-YYYY)" },
+    { pattern: "M-d-yyyy", name: "US format (M-D-YYYY)" },
+    { pattern: "MM/dd/yy", name: "US format (MM/DD/YY)" },
+    { pattern: "M/d/yy", name: "US format (M/D/YY)" },
+    { pattern: "MM-dd-yy", name: "US format (MM-DD-YY)" },
+    { pattern: "M-d-yy", name: "US format (M-D-YY)" },
+    // EU formats (DD/MM/YYYY)
+    { pattern: "dd/MM/yyyy", name: "EU format (DD/MM/YYYY)" },
+    { pattern: "d/M/yyyy", name: "EU format (D/M/YYYY)" },
+    { pattern: "dd.MM.yyyy", name: "EU format (DD.MM.YYYY)" },
+    { pattern: "d.M.yyyy", name: "EU format (D.M.YYYY)" },
+    // Full month names
+    { pattern: "MMMM d, yyyy", name: "Month name format (January 1, 2024)" },
+    { pattern: "MMM d, yyyy", name: "Short month format (Jan 1, 2024)" },
+    { pattern: "MMMM d yyyy", name: "Month name format without comma (January 1 2024)" },
+    { pattern: "MMM d yyyy", name: "Short month without comma (Jan 1 2024)" },
+    { pattern: "d MMMM yyyy", name: "EU month format (1 January 2024)" },
+    { pattern: "d MMM yyyy", name: "EU month short format (1 Jan 2024)" },
+    { pattern: "d MMM, yyyy", name: "EU month short with comma (1 Jan, 2024)" },
+    // Year first formats
+    { pattern: "yyyy/MM/dd", name: "ISO-like format (YYYY/MM/DD)" },
+    { pattern: "yyyy-MM-dd", name: "ISO format with dashes" }
+  ];
+  const referenceDate = /* @__PURE__ */ new Date();
+  for (const { pattern } of formats) {
+    try {
+      const parsedDate = dateFns.parse(sanitizedValue, pattern, referenceDate);
+      if (dateFns.isValid(parsedDate) && !isNaN(parsedDate.getTime())) {
+        const isoString = toIsoDateString(parsedDate);
+        return {
+          isValid: true,
+          date: parsedDate,
+          isoString,
+          originalValue
+        };
+      }
+    } catch {
+    }
+  }
+  if (/^\d+$/.test(trimmedValue)) {
+    try {
+      const timestamp = parseInt(trimmedValue, 10);
+      const date = new Date(timestamp);
+      if (dateFns.isValid(date) && !isNaN(date.getTime())) {
+        const isoString = toIsoDateString(date);
+        return {
+          isValid: true,
+          date,
+          isoString,
+          originalValue
+        };
+      }
+    } catch {
+    }
+  }
+  const nativeParsed = new Date(sanitizedValue);
+  if (dateFns.isValid(nativeParsed) && !isNaN(nativeParsed.getTime())) {
+    return {
+      isValid: true,
+      date: nativeParsed,
+      isoString: toIsoDateString(nativeParsed),
+      originalValue
+    };
+  }
+  return {
+    isValid: false,
+    date: null,
+    isoString: null,
+    originalValue,
+    error: `Invalid date format: "${trimmedValue}". Please use a date picker or format like MM/DD/YYYY.`
+  };
+}
+function isValidISODate(value) {
+  if (!value || typeof value !== "string") {
+    return false;
+  }
+  const isoPattern = /^\d{4}-\d{2}-\d{2}$/;
+  if (!isoPattern.test(value)) {
+    return false;
+  }
+  try {
+    const date = dateFns.parseISO(value);
+    return dateFns.isValid(date) && !isNaN(date.getTime());
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/tracking.ts
+var DEFAULT_API_ENDPOINT = "https://api-dev.signiphi.ai";
+var API_PREFIX = "/api/v1";
+async function trackDocumentSent(config, data) {
+  const endpoint = config.endpoint || DEFAULT_API_ENDPOINT;
+  const url = `${endpoint}${API_PREFIX}/usage/track-send`;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": config.apiKey
+      },
+      body: JSON.stringify({
+        recipientEmail: data.recipientEmail,
+        documentId: data.documentId,
+        idempotencyKey: data.idempotencyKey,
+        metadata: data.metadata
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.error(`Track send failed: ${response.status} - ${errorText}`);
+      throw new Error(`Tracking failed: ${response.status}`);
+    }
+    const result = await response.json();
+    logger.debug("Document send tracked successfully", { eventId: result.eventId });
+    return result;
+  } catch (error) {
+    logger.error("Failed to track document send:", error);
+    throw error;
+  }
+}
+async function trackDocumentSigned(config, data) {
+  const endpoint = config.endpoint || DEFAULT_API_ENDPOINT;
+  const url = `${endpoint}${API_PREFIX}/usage/track-signing`;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": config.apiKey
+      },
+      body: JSON.stringify({
+        signerEmail: data.signerEmail,
+        documentId: data.documentId,
+        idempotencyKey: data.idempotencyKey,
+        metadata: data.metadata
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.error(`Track signing failed: ${response.status} - ${errorText}`);
+      throw new Error(`Tracking failed: ${response.status}`);
+    }
+    const result = await response.json();
+    logger.debug("Document signing tracked successfully", { eventId: result.eventId });
+    return result;
+  } catch (error) {
+    logger.error("Failed to track document signing:", error);
+    throw error;
+  }
+}
+async function trackDocumentSignedSilent(config, data) {
+  try {
+    await trackDocumentSigned(config, data);
+  } catch (error) {
+    logger.warn("Silent tracking failed (non-critical):", error);
+  }
+}
+async function trackDocumentSentSilent(config, data) {
+  try {
+    await trackDocumentSent(config, data);
+  } catch (error) {
+    logger.warn("Silent tracking failed (non-critical):", error);
+  }
+}
+
+exports.AttachmentValidationError = AttachmentValidationError;
+exports.CDN_VIEWER = CDN_VIEWER;
+exports.CDN_WORKER = CDN_WORKER;
+exports.DEFAULT_ATTACHMENT_CONSTRAINTS = DEFAULT_ATTACHMENT_CONSTRAINTS;
+exports.FormFieldError = FormFieldError;
+exports.PdfProcessingError = PdfProcessingError;
+exports.PdfValidationError = PdfValidationError;
+exports.PerformanceMonitor = PerformanceMonitor;
+exports.captureAuditTrail = captureAuditTrail;
+exports.captureDeviceMetadata = captureDeviceMetadata;
+exports.captureGeolocation = captureGeolocation;
+exports.captureIpAddress = captureIpAddress;
+exports.checkAndLogPdfJsVersion = checkAndLogPdfJsVersion;
+exports.checkPdfJsVersion = checkPdfJsVersion;
+exports.createPdfBlobUrl = createPdfBlobUrl;
+exports.createPerformanceMonitor = createPerformanceMonitor;
+exports.dataUrlToBytes = dataUrlToBytes;
+exports.decodeFieldName = decodeFieldName;
+exports.detectFieldType = detectFieldType;
+exports.downloadPdf = downloadPdf;
+exports.extractFieldValue = extractFieldValue;
+exports.extractVisibleFormFields = extractVisibleFormFields;
+exports.fillFormFieldsWithSignatures = fillFormFieldsWithSignatures;
+exports.fillPdfWithSignatures = fillPdfWithSignatures;
+exports.filterFieldsBySigner = filterFieldsBySigner;
+exports.findPageIndexByRef = findPageIndexByRef;
+exports.findPageIndexWithFallback = findPageIndexWithFallback;
+exports.formatFieldName = formatFieldName;
+exports.formatFileSize = formatFileSize;
+exports.generateFallbackLabel = generateFallbackLabel;
+exports.getErrorMessage = getErrorMessage;
+exports.getFieldPageNumbers = getFieldPageNumbers;
+exports.getPdfJsConfig = getPdfJsConfig;
+exports.getWidgetRectangleAndPage = getWidgetRectangleAndPage;
+exports.globalPerformanceMonitor = globalPerformanceMonitor;
+exports.initializePdfJs = initializePdfJs;
+exports.isAttachmentValidationError = isAttachmentValidationError;
+exports.isAutoGeneratedLabel = isAutoGeneratedLabel;
+exports.isFieldVisibleToSigner = isFieldVisibleToSigner;
+exports.isFormFieldError = isFormFieldError;
+exports.isImageType = isImageType;
+exports.isInitialsField = isInitialsField;
+exports.isPdfProcessingError = isPdfProcessingError;
+exports.isPdfValidationError = isPdfValidationError;
+exports.isRequiredField = isRequiredField;
+exports.isSignatureField = isSignatureField;
+exports.isValidISODate = isValidISODate;
+exports.isValidPdf = isValidPdf;
+exports.logVersionCheckWarning = logVersionCheckWarning;
+exports.logger = logger;
+exports.measurePerformance = measurePerformance;
+exports.parseAndValidateDate = parseAndValidateDate;
+exports.pdfToImages = pdfToImages;
+exports.readCurrentPdfFormValues = readCurrentPdfFormValues;
+exports.readPdfFormFields = readPdfFormFields;
+exports.removeAllFormFields = removeAllFormFields;
+exports.resetPdfJsConfig = resetPdfJsConfig;
+exports.setPdfJsConfig = setPdfJsConfig;
+exports.shouldFlattenField = shouldFlattenField;
+exports.trackDocumentSent = trackDocumentSent;
+exports.trackDocumentSentSilent = trackDocumentSentSilent;
+exports.trackDocumentSigned = trackDocumentSigned;
+exports.trackDocumentSignedSilent = trackDocumentSignedSilent;
+exports.urlToPdfBytes = urlToPdfBytes;
+exports.validateCurrentPdfState = validateCurrentPdfState;
+exports.validateFieldValues = validateFieldValues;
+exports.validateFile = validateFile;
+exports.validateFileOrThrow = validateFileOrThrow;
+exports.validateFiles = validateFiles;
+exports.validateFilesOrThrow = validateFilesOrThrow;
+exports.validateFormField = validateFormField;
+exports.validatePdfBytes = validatePdfBytes;
+exports.validatePdfFormFields = validatePdfFormFields;
+exports.validatePdfUrl = validatePdfUrl;
+exports.validateSignatures = validateSignatures;
+exports.withPerformanceMonitoring = withPerformanceMonitoring;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map