@signiphi/pdf-signer 0.1.1

package/dist/hooks/index.mjs

@@ -0,0 +1,2139 @@
+import { useRef, useState, useCallback, useMemo } from 'react';
+import * as pdfjsLib2 from 'pdfjs-dist';
+import { parseISO, isValid } from 'date-fns';
+
+// src/hooks/usePdfViewer.ts
+
+// 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 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);
+}
+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;
+  }
+}
+
+// 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 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 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 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 isSignatureField = fieldName.toLowerCase().includes("signature") || fieldType.includes("Signature");
+        const isInitialsField = fieldName.toLowerCase().includes("initials") || fieldType.includes("Initials");
+        if (isSignatureField || isInitialsField) {
+          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 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 _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 = {
+  workerSrc: ""
+  // Lazy-initialized below
+};
+var _configInitialized = false;
+function ensureConfigInitialized() {
+  if (!_configInitialized) {
+    globalConfig.workerSrc = getDefaultWorkerSrc();
+    _configInitialized = true;
+    if (typeof window !== "undefined") {
+      pdfjsLib2.GlobalWorkerOptions.workerSrc = globalConfig.workerSrc;
+    }
+  }
+}
+function initializePdfJs() {
+  ensureConfigInitialized();
+}
+
+// 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);
+    }
+  }
+};
+
+// 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 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];
+}
+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 = parseISO(value);
+    return isValid(date) && !isNaN(date.getTime());
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/pdf-viewer-filter.ts
+async function drawFieldLabelsOnPdf(pdfDoc, fieldsToLabel, rgb) {
+  try {
+    const labelFont = await pdfDoc.embedFont("Helvetica-Bold");
+    const pages = pdfDoc.getPages();
+    const form = pdfDoc.getForm();
+    const drawnOnce = /* @__PURE__ */ new Set();
+    for (const field of fieldsToLabel) {
+      const isRadioField = field.type === "radio" /* RADIO */;
+      const hasRadioOptions = isRadioField && field.options && field.options.length > 0;
+      const hasCustomLabel = field.label && field.label.trim() && !isAutoGeneratedLabel(field.label);
+      if (!hasCustomLabel && !hasRadioOptions) {
+        continue;
+      }
+      const pdfField = form.getFieldMaybe(field.name);
+      if (!pdfField) {
+        continue;
+      }
+      const fieldWithExtensions = pdfField;
+      const widgets = fieldWithExtensions.acroField?.getWidgets?.() || [];
+      if (widgets.length === 0) continue;
+      if (isRadioField) {
+        if (field.label && field.label.trim() && !isAutoGeneratedLabel(field.label)) {
+          const firstWidget = widgets[0];
+          if (!firstWidget) continue;
+          const firstRect = firstWidget.getRectangle?.();
+          if (firstRect) {
+            const pageRef = firstWidget.P?.();
+            const pageIndex = findPageIndexWithFallback(pages, pageRef);
+            if (pageIndex >= 0) {
+              const page = pages[pageIndex];
+              if (!page) continue;
+              const groupLabelKey = `${pageIndex}-${field.name}-grouplabel`;
+              if (!drawnOnce.has(groupLabelKey)) {
+                const labelY = firstRect.y + firstRect.height + 5;
+                page.drawText(field.label, {
+                  x: firstRect.x,
+                  y: labelY,
+                  size: 10,
+                  font: labelFont,
+                  color: rgb(0, 0, 0)
+                });
+                drawnOnce.add(groupLabelKey);
+              }
+            }
+          }
+        }
+        if (field.options && field.options.length > 0) {
+          for (let i = 0; i < widgets.length; i++) {
+            const widget = widgets[i];
+            if (!widget) continue;
+            const rect = widget.getRectangle?.();
+            if (!rect) continue;
+            const pageRef = widget.P?.();
+            const pageIndex = findPageIndexWithFallback(pages, pageRef);
+            if (pageIndex >= 0) {
+              const page = pages[pageIndex];
+              if (!page) continue;
+              const optionTexts = field.options;
+              const optionText = optionTexts[i] || optionTexts[0];
+              const optionKey = `${pageIndex}-${field.name}-opt-${i}`;
+              if (optionText && !drawnOnce.has(optionKey)) {
+                page.drawText(optionText, {
+                  x: rect.x + rect.width + 6,
+                  y: rect.y + (rect.height - 10) / 2,
+                  size: 10,
+                  font: labelFont,
+                  color: rgb(0, 0, 0)
+                });
+                drawnOnce.add(optionKey);
+              }
+            }
+          }
+        }
+      } else {
+        const widget = widgets[0];
+        if (!widget) continue;
+        const rect = widget.getRectangle?.();
+        if (!rect) continue;
+        const pageRef = widget.P?.();
+        const pageIndex = findPageIndexWithFallback(pages, pageRef);
+        if (pageIndex >= 0 && pageIndex < pages.length) {
+          const page = pages[pageIndex];
+          if (!page) continue;
+          const key = `${pageIndex}-${field.name}`;
+          if (!drawnOnce.has(key)) {
+            if (!isAutoGeneratedLabel(field.label)) {
+              if (field.type === "checkbox" /* CHECKBOX */) {
+                page.drawText(field.label, {
+                  x: rect.x + rect.width + 5,
+                  y: rect.y + rect.height * 0.2,
+                  size: 10,
+                  font: labelFont,
+                  color: rgb(0, 0, 0)
+                });
+              } else {
+                const labelY = rect.y + rect.height + 5;
+                page.drawText(field.label, {
+                  x: rect.x,
+                  y: labelY,
+                  size: 9,
+                  font: labelFont,
+                  color: rgb(0.3, 0.3, 0.3)
+                });
+              }
+              drawnOnce.add(key);
+            }
+          }
+        }
+      }
+    }
+    try {
+      form.updateFieldAppearances();
+    } catch (appearanceError) {
+    }
+  } catch (error) {
+    logger.error("Error drawing field labels:", error);
+  }
+}
+async function filterPdfForCurrentSigner(pdfBytes, allFields, multiSignerContext) {
+  if (!multiSignerContext.isMultiSigner) {
+    try {
+      const { PDFDocument: PDFDocument2, rgb: rgb2 } = await loadPdfLib();
+      const pdfDoc = await PDFDocument2.load(pdfBytes);
+      await drawFieldLabelsOnPdf(pdfDoc, allFields, rgb2);
+      const labeledBytes = await pdfDoc.save();
+      return labeledBytes;
+    } catch (error) {
+      return pdfBytes;
+    }
+  }
+  const otherSignersFields = allFields.filter((f) => {
+    if (f.type === "text_label" /* TEXT_LABEL */) {
+      return false;
+    }
+    return !isFieldVisibleToSigner(f, multiSignerContext);
+  });
+  if (otherSignersFields.length === 0) {
+    try {
+      const { PDFDocument: PDFDocument2, rgb: rgb2 } = await loadPdfLib();
+      const pdfDoc = await PDFDocument2.load(pdfBytes);
+      const fieldsToLabel = allFields.filter((f) => {
+        if (f.type === "text_label" /* TEXT_LABEL */) {
+          return true;
+        }
+        return isFieldVisibleToSigner(f, multiSignerContext);
+      });
+      await drawFieldLabelsOnPdf(pdfDoc, fieldsToLabel, rgb2);
+      const labeledBytes = await pdfDoc.save();
+      return labeledBytes;
+    } catch (error) {
+      return pdfBytes;
+    }
+  }
+  const { PDFDocument, rgb } = await loadPdfLib();
+  const freshPdfDoc = await PDFDocument.load(pdfBytes);
+  const form = freshPdfDoc.getForm();
+  let removedCount = 0;
+  let notFoundCount = 0;
+  for (const field of otherSignersFields) {
+    try {
+      const pdfField = form.getFieldMaybe(field.name);
+      if (pdfField) {
+        form.removeField(pdfField);
+        removedCount++;
+      } else {
+        notFoundCount++;
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Error removing field:", errorMsg);
+    }
+  }
+  try {
+    const fieldsToLabel = allFields.filter((f) => {
+      if (f.type === "text_label" /* TEXT_LABEL */) {
+        return true;
+      }
+      return isFieldVisibleToSigner(f, multiSignerContext);
+    });
+    await drawFieldLabelsOnPdf(freshPdfDoc, fieldsToLabel, rgb);
+  } catch (labelError) {
+  }
+  const modifiedPdfBytes = await freshPdfDoc.save();
+  return modifiedPdfBytes;
+}
+
+// src/hooks/usePdfViewer.ts
+function usePdfViewer(multiSignerContext) {
+  const viewerRef = useRef(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [isLoaded, setIsLoaded] = useState(false);
+  const [pdfUrl, setPdfUrl] = useState(null);
+  const [originalPdfBytes, setOriginalPdfBytes] = useState(null);
+  const [_viewerPdfBytes, setViewerPdfBytes] = useState(null);
+  const [extractedFields, setExtractedFields] = useState([]);
+  const loadPdf = useCallback(async (url) => {
+    setIsLoading(true);
+    setError(null);
+    setIsLoaded(false);
+    setPdfUrl(url);
+    try {
+      initializePdfJs();
+      const urlValidation = validatePdfUrl(url);
+      if (!urlValidation.valid) {
+        throw new PdfValidationError(urlValidation.error || "Invalid PDF URL");
+      }
+      const bytes = await urlToPdfBytes(url);
+      setOriginalPdfBytes(bytes);
+      setViewerPdfBytes(bytes);
+      await viewerRef.current?.loadPdf(url);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to load PDF";
+      logger.error("Error loading PDF:", err);
+      setError(errorMessage);
+      setOriginalPdfBytes(null);
+      setViewerPdfBytes(null);
+    }
+  }, []);
+  const handleLoad = useCallback(() => {
+    setIsLoading(false);
+    setIsLoaded(true);
+    setError(null);
+  }, []);
+  const handleError = useCallback((errorMessage) => {
+    setIsLoading(false);
+    setIsLoaded(false);
+    setError(errorMessage);
+  }, []);
+  const getFormFieldValues = useCallback(async () => {
+    if (!viewerRef.current) {
+      return {};
+    }
+    return await viewerRef.current.getFormFieldValues();
+  }, []);
+  const setFormFieldValues = useCallback(async (values) => {
+    if (!viewerRef.current) {
+      return;
+    }
+    return await viewerRef.current.setFormFieldValues(values);
+  }, []);
+  const getAllFieldNames = useCallback(async () => {
+    if (!viewerRef.current) {
+      return [];
+    }
+    return await viewerRef.current.getAllFieldNames();
+  }, []);
+  const saveDocument = useCallback(async () => {
+    if (!viewerRef.current) {
+      return null;
+    }
+    return await viewerRef.current.saveDocument();
+  }, []);
+  const extractFormFields = useCallback(
+    async (currentSignerEmail) => {
+      if (!originalPdfBytes) {
+        throw new Error("No PDF loaded");
+      }
+      try {
+        const fields = await extractVisibleFormFields(
+          originalPdfBytes,
+          currentSignerEmail
+        );
+        setExtractedFields(fields);
+        if (multiSignerContext?.isMultiSigner) {
+          const filteredBytes = await filterPdfForCurrentSigner(
+            originalPdfBytes,
+            fields,
+            multiSignerContext
+          );
+          setViewerPdfBytes(filteredBytes);
+          const filteredBlobUrl = createPdfBlobUrl(filteredBytes);
+          await viewerRef.current?.loadPdf(filteredBlobUrl);
+        } else {
+          const labeledBytes = await filterPdfForCurrentSigner(
+            originalPdfBytes,
+            fields,
+            multiSignerContext || {
+              isMultiSigner: false,
+              currentSigner: null,
+              currentSignerEmail: "",
+              isPrimarySigner: true,
+              isFinalSigner: true
+            }
+          );
+          setViewerPdfBytes(labeledBytes);
+          const labeledBlobUrl = createPdfBlobUrl(labeledBytes);
+          await viewerRef.current?.loadPdf(labeledBlobUrl);
+        }
+        if (viewerRef.current && fields.length > 0) {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          viewerRef.current.injectPlaceholders(fields);
+        }
+        return fields;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to extract form fields";
+        throw new Error(errorMessage);
+      }
+    },
+    [originalPdfBytes, multiSignerContext]
+  );
+  const fillPdf = useCallback(
+    async (fieldValues, signatures, currentSignerEmail, metadata, auditTrail) => {
+      if (!originalPdfBytes) {
+        throw new PdfProcessingError("No PDF loaded");
+      }
+      try {
+        const valuesValidation = validateFieldValues(fieldValues);
+        if (!valuesValidation.valid) {
+          logger.warn("Field values validation warnings:", valuesValidation.errors);
+        }
+        const sigsValidation = validateSignatures(signatures);
+        if (!sigsValidation.valid) {
+          logger.warn("Signatures validation warnings:", sigsValidation.errors);
+        }
+        const filledPdfBytes = await fillPdfWithSignatures(
+          originalPdfBytes,
+          // CRITICAL: Use original PDF with ALL fields
+          signatures,
+          fieldValues,
+          currentSignerEmail,
+          extractedFields,
+          // Pass extracted fields for proper signature filtering
+          metadata,
+          auditTrail,
+          multiSignerContext
+          // Pass multi-signer context for partial flattening
+        );
+        return filledPdfBytes;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fill PDF";
+        logger.error("Error filling PDF:", err);
+        throw new PdfProcessingError(errorMessage, err);
+      }
+    },
+    [originalPdfBytes, extractedFields, multiSignerContext]
+  );
+  const validatePdf = useCallback(
+    async (fieldValues, signatures, visibleFields) => {
+      if (!originalPdfBytes) {
+        throw new Error("No PDF loaded");
+      }
+      try {
+        const fieldsToValidate = visibleFields || extractedFields;
+        const errors = await validatePdfFormFields(
+          originalPdfBytes,
+          fieldValues,
+          signatures,
+          fieldsToValidate,
+          // Pass visible/filtered fields for validation
+          multiSignerContext
+          // Pass multi-signer context for validation filtering
+        );
+        return {
+          isValid: errors.length === 0,
+          errors
+        };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to validate PDF";
+        throw new Error(errorMessage);
+      }
+    },
+    [originalPdfBytes, extractedFields, multiSignerContext]
+  );
+  const getRequiredFieldsMap = useCallback(async () => {
+    if (!originalPdfBytes) {
+      return {};
+    }
+    try {
+      const { PDFDocument } = await loadPdfLib();
+      const pdfDoc = await PDFDocument.load(originalPdfBytes);
+      const form = pdfDoc.getForm();
+      const fields = form.getFields();
+      const requiredMap = {};
+      for (const field of fields) {
+        const fieldName = field.getName();
+        const isRequired = field.isRequired();
+        requiredMap[fieldName] = isRequired;
+      }
+      return requiredMap;
+    } catch (err) {
+      logger.error("Failed to get required fields map:", err);
+      return {};
+    }
+  }, [originalPdfBytes]);
+  const getCurrentPdfBytes = useCallback(() => {
+    return originalPdfBytes;
+  }, [originalPdfBytes]);
+  const reloadPdfWithBytes = useCallback(
+    async (newPdfBytes) => {
+      try {
+        const blobUrl = createPdfBlobUrl(newPdfBytes);
+        setOriginalPdfBytes(newPdfBytes);
+        setViewerPdfBytes(newPdfBytes);
+        setPdfUrl(blobUrl);
+        await viewerRef.current?.loadPdf(blobUrl);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to reload PDF";
+        setError(errorMessage);
+      }
+    },
+    []
+  );
+  const reset = useCallback(() => {
+    setIsLoading(false);
+    setError(null);
+    setIsLoaded(false);
+    setPdfUrl(null);
+    setOriginalPdfBytes(null);
+    setViewerPdfBytes(null);
+    setExtractedFields([]);
+  }, []);
+  return {
+    // Ref and state
+    viewerRef,
+    isLoading,
+    error,
+    isLoaded,
+    pdfUrl,
+    pdfBytes: originalPdfBytes,
+    // Expose as pdfBytes for backward compatibility
+    extractedFields,
+    // Basic operations
+    loadPdf,
+    handleLoad,
+    handleError,
+    getFormFieldValues,
+    setFormFieldValues,
+    getAllFieldNames,
+    saveDocument,
+    // Enhanced operations
+    extractFormFields,
+    fillPdf,
+    validatePdf,
+    getRequiredFieldsMap,
+    getCurrentPdfBytes,
+    reloadPdfWithBytes,
+    reset
+  };
+}
+function useFormFields(fields = []) {
+  const [fieldValues, setFieldValues] = useState({});
+  const [errors, setErrors] = useState([]);
+  const [touched, setTouched] = useState({});
+  const updateField = useCallback((fieldId, value) => {
+    setFieldValues((prev) => ({
+      ...prev,
+      [fieldId]: value
+    }));
+    setTouched((prev) => ({
+      ...prev,
+      [fieldId]: true
+    }));
+    setErrors((prev) => prev.filter((err) => err.field !== fieldId));
+  }, []);
+  const updateMultipleFields = useCallback((values) => {
+    setFieldValues((prev) => ({
+      ...prev,
+      ...values
+    }));
+    const touchedFields = Object.keys(values).reduce((acc, key) => {
+      acc[key] = true;
+      return acc;
+    }, {});
+    setTouched((prev) => ({
+      ...prev,
+      ...touchedFields
+    }));
+    const updatedFieldIds = Object.keys(values);
+    setErrors((prev) => prev.filter((err) => !updatedFieldIds.includes(err.field)));
+  }, []);
+  const validateField = useCallback(
+    (fieldId) => {
+      const field = fields.find((f) => f.id === fieldId);
+      if (!field) return true;
+      const value = fieldValues[fieldId];
+      const newErrors = errors.filter((e) => e.field !== fieldId);
+      if (field.required) {
+        if (!value || value.trim() === "") {
+          newErrors.push({
+            field: fieldId,
+            message: `${field.label || field.name} is required`
+          });
+        }
+      }
+      if (value && field.maxLength && value.length > field.maxLength) {
+        newErrors.push({
+          field: fieldId,
+          message: `${field.label || field.name} must be at most ${field.maxLength} characters`
+        });
+      }
+      if (value && field.type === "date") {
+        if (!isValidISODate(value)) {
+          newErrors.push({
+            field: fieldId,
+            message: "Please enter a valid date"
+          });
+        }
+      }
+      setErrors(newErrors);
+      return newErrors.length === errors.length - newErrors.filter((e) => e.field === fieldId).length;
+    },
+    [fields, fieldValues, errors]
+  );
+  const validateFields = useCallback(
+    (signatures) => {
+      const newErrors = [];
+      for (const field of fields) {
+        if (field.required) {
+          const value2 = fieldValues[field.id];
+          if ((field.type === "signature" || field.type === "initials") && signatures) {
+            if (!signatures[field.id]) {
+              newErrors.push({
+                field: field.id,
+                message: `${field.label || field.name} is required`
+              });
+            }
+          } else if (!value2 || value2.trim() === "") {
+            newErrors.push({
+              field: field.id,
+              message: `${field.label || field.name} is required`
+            });
+          }
+        }
+        const value = fieldValues[field.id];
+        if (value && field.maxLength && value.length > field.maxLength) {
+          newErrors.push({
+            field: field.id,
+            message: `${field.label || field.name} must be at most ${field.maxLength} characters`
+          });
+        }
+        if (value && field.type === "date") {
+          if (!isValidISODate(value)) {
+            newErrors.push({
+              field: field.id,
+              message: "Please enter a valid date"
+            });
+          }
+        }
+      }
+      setErrors(newErrors);
+      return newErrors.length === 0;
+    },
+    [fields, fieldValues]
+  );
+  const resetFields = useCallback(() => {
+    setFieldValues({});
+    setErrors([]);
+    setTouched({});
+  }, []);
+  const resetValidation = useCallback(() => {
+    setErrors([]);
+  }, []);
+  const getFieldValue = useCallback(
+    (fieldId) => {
+      return fieldValues[fieldId] || "";
+    },
+    [fieldValues]
+  );
+  const getFieldError = useCallback(
+    (fieldId) => {
+      const error = errors.find((e) => e.field === fieldId);
+      return error?.message;
+    },
+    [errors]
+  );
+  const isFieldTouched = useCallback(
+    (fieldId) => {
+      return touched[fieldId] || false;
+    },
+    [touched]
+  );
+  const setFieldValue = updateField;
+  const setMultipleFieldValues = updateMultipleFields;
+  const clearFields = resetFields;
+  const hasErrors = errors.length > 0;
+  return {
+    fieldValues,
+    errors,
+    hasErrors,
+    touched,
+    updateField,
+    updateMultipleFields,
+    validateField,
+    validateFields,
+    resetFields,
+    resetValidation,
+    getFieldValue,
+    getFieldError,
+    isFieldTouched,
+    // Aliases
+    setFieldValue,
+    setMultipleFieldValues,
+    clearFields
+  };
+}
+function useSignatureCapture() {
+  const canvasRef = useRef(null);
+  const [signatureDataUrl, setSignatureDataUrl] = useState(null);
+  const [uploadedImage, setUploadedImage] = useState(null);
+  const [uploadError, setUploadError] = useState(null);
+  const clear = useCallback(() => {
+    canvasRef.current?.clear();
+    setSignatureDataUrl(null);
+  }, []);
+  const saveSignature = useCallback(() => {
+    const dataUrl = canvasRef.current?.getSignatureDataUrl();
+    if (dataUrl) {
+      setSignatureDataUrl(dataUrl);
+      return dataUrl;
+    }
+    return null;
+  }, []);
+  const isEmpty = useCallback(() => {
+    return canvasRef.current?.isEmpty() ?? true;
+  }, []);
+  const handleFileUpload = useCallback((file) => {
+    setUploadError(null);
+    const allowedTypes = ["image/png", "image/jpeg", "image/jpg"];
+    if (!allowedTypes.includes(file.type.toLowerCase())) {
+      setUploadError("Please upload a PNG or JPEG image file.");
+      return;
+    }
+    const maxSizeInBytes = 5 * 1024 * 1024;
+    if (file.size > maxSizeInBytes) {
+      setUploadError("File size must be less than 5MB. Please choose a smaller image.");
+      return;
+    }
+    const reader = new FileReader();
+    reader.onload = (event) => {
+      if (typeof event.target?.result === "string") {
+        setUploadedImage(event.target.result);
+        setSignatureDataUrl(event.target.result);
+        setUploadError(null);
+      }
+    };
+    reader.onerror = () => {
+      setUploadError("Failed to read the image file. Please try again.");
+    };
+    reader.readAsDataURL(file);
+  }, []);
+  const clearUpload = useCallback(() => {
+    setUploadedImage(null);
+    setUploadError(null);
+    setSignatureDataUrl(null);
+  }, []);
+  const reset = useCallback(() => {
+    clear();
+    clearUpload();
+  }, [clear, clearUpload]);
+  return {
+    canvasRef,
+    signatureDataUrl,
+    uploadedImage,
+    uploadError,
+    clear,
+    saveSignature,
+    isEmpty,
+    handleFileUpload,
+    clearUpload,
+    reset
+  };
+}
+function useSignatures() {
+  const [signatures, setSignatures] = useState({});
+  const setSignature = useCallback((fieldId, dataUrl) => {
+    setSignatures((prev) => ({
+      ...prev,
+      [fieldId]: dataUrl
+    }));
+  }, []);
+  const clearSignature = useCallback((fieldId) => {
+    setSignatures((prev) => {
+      const newSignatures = { ...prev };
+      delete newSignatures[fieldId];
+      return newSignatures;
+    });
+  }, []);
+  const clearAllSignatures = useCallback(() => {
+    setSignatures({});
+  }, []);
+  const hasSignature = useCallback(
+    (fieldId) => {
+      return !!signatures[fieldId];
+    },
+    [signatures]
+  );
+  const getSignature = useCallback(
+    (fieldId) => {
+      return signatures[fieldId] || null;
+    },
+    [signatures]
+  );
+  const validateSignatures2 = useCallback(
+    (fields, currentSignatures) => {
+      const signaturesToCheck = currentSignatures ?? signatures;
+      const errors = [];
+      for (const field of fields) {
+        if (field.required && (field.type === "signature" || field.type === "initials")) {
+          if (!signaturesToCheck[field.id]) {
+            errors.push(`${field.label || field.name} is required`);
+          }
+        }
+      }
+      return {
+        isValid: errors.length === 0,
+        errors
+      };
+    },
+    [signatures]
+  );
+  const signatureCount = Object.keys(signatures).length;
+  const hasAnySignatures = signatureCount > 0;
+  return {
+    signatures,
+    setSignature,
+    clearSignature,
+    clearAllSignatures,
+    hasSignature,
+    getSignature,
+    validateSignatures: validateSignatures2,
+    signatureCount,
+    hasAnySignatures
+  };
+}
+function useFieldFiltering(allFields, multiSignerContext) {
+  const filteredFields = useMemo(() => {
+    let fields = allFields.filter((field) => {
+      if (field.id === "signature_field_main" || field.id === "initials_field_main") {
+        return true;
+      }
+      if (field.type === "signature" || field.type === "initials") {
+        return false;
+      }
+      return true;
+    });
+    return filterFieldsBySigner(fields, multiSignerContext);
+  }, [allFields, multiSignerContext]);
+  const requiredFields = useMemo(() => {
+    return filteredFields.filter((field) => field.required);
+  }, [filteredFields]);
+  const optionalFields = useMemo(() => {
+    return filteredFields.filter((field) => !field.required);
+  }, [filteredFields]);
+  const isFieldVisible = (field) => {
+    return isFieldVisibleToSigner(field, multiSignerContext);
+  };
+  return {
+    // Filtered fields
+    filteredFields,
+    requiredFields,
+    optionalFields,
+    // Utilities
+    isFieldVisible,
+    // Counts
+    totalFields: allFields.length,
+    filteredCount: filteredFields.length,
+    requiredCount: requiredFields.length,
+    optionalCount: optionalFields.length
+  };
+}
+function generateAttachmentId() {
+  return `att_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+async function createPreview(file) {
+  if (!isImageType(file.type)) {
+    return void 0;
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
+function useAttachments(options = {}) {
+  const [attachments, setAttachments] = useState([]);
+  const [isUploading, setIsUploading] = useState(false);
+  const [validationErrors, setValidationErrors] = useState([]);
+  const constraints = {
+    ...DEFAULT_ATTACHMENT_CONSTRAINTS,
+    ...options.constraints
+  };
+  const addFiles = useCallback(
+    async (files) => {
+      setIsUploading(true);
+      setValidationErrors([]);
+      const fileArray = Array.from(files);
+      const errors = [];
+      const newAttachments = [];
+      for (const file of fileArray) {
+        const validation = validateFile(file, constraints);
+        if (!validation.valid) {
+          errors.push(...validation.errors);
+          continue;
+        }
+        const currentTotalSize = [...attachments, ...newAttachments].reduce((sum, att) => sum + att.size, 0);
+        if (currentTotalSize + file.size > constraints.maxTotalSize) {
+          const maxTotalMB = (constraints.maxTotalSize / 1024 / 1024).toFixed(1);
+          errors.push(`Adding "${file.name}" would exceed total size limit of ${maxTotalMB}MB`);
+          continue;
+        }
+        if ([...attachments, ...newAttachments].length >= constraints.maxFiles) {
+          errors.push(`Maximum of ${constraints.maxFiles} files allowed`);
+          continue;
+        }
+        try {
+          const preview = await createPreview(file);
+          const attachment = {
+            id: generateAttachmentId(),
+            file,
+            name: file.name,
+            size: file.size,
+            type: file.type,
+            uploadedAt: /* @__PURE__ */ new Date(),
+            preview
+          };
+          newAttachments.push(attachment);
+        } catch (error) {
+          logger.error("Error creating attachment:", error);
+          errors.push(`Failed to process file "${file.name}"`);
+        }
+      }
+      if (newAttachments.length > 0) {
+        setAttachments((prev) => [...prev, ...newAttachments]);
+      }
+      if (errors.length > 0) {
+        setValidationErrors(errors);
+        options.onError?.(errors);
+      }
+      setIsUploading(false);
+      return {
+        added: newAttachments.length,
+        errors
+      };
+    },
+    [attachments, constraints, options]
+  );
+  const removeAttachment = useCallback((attachmentId) => {
+    setAttachments((prev) => prev.filter((att) => att.id !== attachmentId));
+    setValidationErrors([]);
+  }, []);
+  const clearAttachments = useCallback(() => {
+    setAttachments([]);
+    setValidationErrors([]);
+  }, []);
+  const getTotalSize = useCallback(() => {
+    return attachments.reduce((sum, att) => sum + att.size, 0);
+  }, [attachments]);
+  const formatSize = useCallback((bytes) => {
+    return formatFileSize(bytes);
+  }, []);
+  const validateAll = useCallback(() => {
+    const errors = [];
+    const totalSize = getTotalSize();
+    if (totalSize > constraints.maxTotalSize) {
+      const maxTotalMB = (constraints.maxTotalSize / 1024 / 1024).toFixed(1);
+      errors.push(`Total file size (${formatSize(totalSize)}) exceeds ${maxTotalMB}MB limit`);
+    }
+    if (attachments.length > constraints.maxFiles) {
+      errors.push(`Maximum of ${constraints.maxFiles} files allowed (currently ${attachments.length})`);
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }, [attachments, constraints, getTotalSize, formatSize]);
+  return {
+    // State
+    attachments,
+    isUploading,
+    validationErrors,
+    constraints,
+    // Actions
+    addFiles,
+    removeAttachment,
+    clearAttachments,
+    // Utilities
+    getTotalSize,
+    formatSize,
+    validateAll
+  };
+}
+function useMultiSignerContext(currentSigner, isMultipleSignature, totalSigners) {
+  return useMemo(() => {
+    if (!isMultipleSignature || !currentSigner) {
+      return {
+        isMultiSigner: false,
+        currentSigner: null,
+        currentSignerEmail: "",
+        isPrimarySigner: false,
+        isFinalSigner: false
+      };
+    }
+    const isPrimarySigner = currentSigner.signOrder === 1;
+    const isFinalSigner = totalSigners ? currentSigner.signOrder === totalSigners : true;
+    return {
+      isMultiSigner: true,
+      currentSigner,
+      currentSignerEmail: currentSigner.email,
+      isPrimarySigner,
+      isFinalSigner
+    };
+  }, [currentSigner, isMultipleSignature, totalSigners]);
+}
+
+export { useAttachments, useFieldFiltering, useFormFields, useMultiSignerContext, usePdfViewer, useSignatureCapture, useSignatures };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map