@signiphi/pdf-signer 0.2.0-beta.2 → 0.2.0-beta.21

package/dist/utils/index.js

@@ -78,6 +78,7 @@ function validatePdfBytes(pdfBytes) {
 }
 function isAutoGeneratedLabel(label) {
   if (!label || !label.trim()) return true;
+  const trimmed = label.trim();
   const autoLabels = [
     "Signature",
     "Initials",
@@ -88,7 +89,65 @@ function isAutoGeneratedLabel(label) {
     "Option",
     "Radio"
   ];
-  return autoLabels.includes(label.trim());
+  if (autoLabels.includes(trimmed)) return true;
+  if (/^\d{10,}$/.test(trimmed)) return true;
+  const typeTimestampPattern = new RegExp(
+    `^(${autoLabels.join("|")})[\\s_-]?\\d{10,}$`,
+    "i"
+  );
+  if (typeTimestampPattern.test(trimmed)) return true;
+  const typeNumberPattern = new RegExp(
+    `^(${autoLabels.join("|")})[\\s_-]?\\d{1,3}$`,
+    "i"
+  );
+  if (typeNumberPattern.test(trimmed)) return true;
+  const typeWordsJoined = autoLabels.join("|");
+  const corruptedPattern = new RegExp(
+    `^(${typeWordsJoined})[\\s_-]?\\d{10,}[\\s_-]?(${typeWordsJoined})+`,
+    "i"
+  );
+  if (corruptedPattern.test(trimmed)) return true;
+  const repeatedTypePattern = new RegExp(
+    `^((${typeWordsJoined})[\\s_-]+)+(${typeWordsJoined})$`,
+    "i"
+  );
+  if (repeatedTypePattern.test(trimmed)) return true;
+  return false;
+}
+function hasDrawableLabel(field) {
+  if (!field.label || !field.label.trim()) return false;
+  if (field.isLabelAutoGenerated) return false;
+  if (isAutoGeneratedLabel(field.label)) return false;
+  return true;
+}
+function getFieldDisplayName(field) {
+  if (field.label && !isAutoGeneratedLabel(field.label)) {
+    return field.label;
+  }
+  const typeNames = {
+    "text": "Text field",
+    "signature": "Signature",
+    "initials": "Initials",
+    "date": "Date field",
+    "checkbox": "Checkbox",
+    "dropdown": "Dropdown",
+    "radio": "Radio selection",
+    "radiogroup": "Radio selection",
+    "text_label": "Text label"
+  };
+  if (field.type) {
+    const typeName = typeNames[field.type.toLowerCase()];
+    if (typeName) {
+      return typeName;
+    }
+  }
+  if (field.name) {
+    let cleaned = field.name.replace(/_?(signature|initials|date)$/i, "").replace(/[_-]\d{10,}$/, "").replace(/[_-]/g, " ").trim();
+    if (cleaned && !isAutoGeneratedLabel(cleaned)) {
+      return cleaned.replace(/\b\w/g, (l) => l.toUpperCase());
+    }
+  }
+  return "This field";
 }
 function validateFieldValues(values) {
   const errors = [];
@@ -324,6 +383,114 @@ function getSigniphiMetadata(pdfDoc) {
   }
 }
 
+// src/utils/font-loader.ts
+var SIGNATURE_FONTS = [
+  { name: "dancing-script", family: "Dancing Script", label: "Elegant" },
+  { name: "great-vibes", family: "Great Vibes", label: "Formal" },
+  { name: "caveat", family: "Caveat", label: "Casual" },
+  { name: "homemade-apple", family: "Homemade Apple", label: "Natural" },
+  { name: "sacramento", family: "Sacramento", label: "Flowing" }
+];
+var DEFAULT_SIGNATURE_FONT = {
+  name: "dancing-script",
+  family: "Dancing Script",
+  label: "Elegant"
+};
+var GOOGLE_FONTS_URL = "https://fonts.googleapis.com/css2?family=Dancing+Script&family=Great+Vibes&family=Caveat&family=Homemade+Apple&family=Sacramento&display=swap";
+var fontsLoaded = false;
+var fontsLoadingPromise = null;
+async function loadSignatureFonts() {
+  if (fontsLoaded) {
+    return;
+  }
+  if (fontsLoadingPromise) {
+    return fontsLoadingPromise;
+  }
+  fontsLoadingPromise = new Promise((resolve, reject) => {
+    const existingLink = document.querySelector(
+      `link[href="${GOOGLE_FONTS_URL}"]`
+    );
+    if (existingLink) {
+      fontsLoaded = true;
+      resolve();
+      return;
+    }
+    const link = document.createElement("link");
+    link.href = GOOGLE_FONTS_URL;
+    link.rel = "stylesheet";
+    link.onload = () => {
+      fontsLoaded = true;
+      resolve();
+    };
+    link.onerror = () => {
+      fontsLoadingPromise = null;
+      reject(new Error("Failed to load signature fonts from Google Fonts"));
+    };
+    document.head.appendChild(link);
+  });
+  return fontsLoadingPromise;
+}
+function isFontLoaded(fontFamily) {
+  if (typeof document === "undefined") {
+    return false;
+  }
+  return document.fonts.check(`48px "${fontFamily}"`);
+}
+async function waitForFont(fontFamily) {
+  if (typeof document === "undefined") {
+    return false;
+  }
+  try {
+    await document.fonts.load(`48px "${fontFamily}"`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateSignatureFromText(options) {
+  const {
+    text,
+    fontFamily,
+    width = 450,
+    height = 200,
+    fontSize = 48,
+    color = "#000000",
+    backgroundColor = null
+  } = options;
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Failed to get canvas 2d context");
+  }
+  if (backgroundColor) {
+    ctx.fillStyle = backgroundColor;
+    ctx.fillRect(0, 0, width, height);
+  } else {
+    ctx.clearRect(0, 0, width, height);
+  }
+  ctx.font = `${fontSize}px "${fontFamily}"`;
+  ctx.fillStyle = color;
+  ctx.textAlign = "center";
+  ctx.textBaseline = "middle";
+  let adjustedFontSize = fontSize;
+  let textMetrics = ctx.measureText(text);
+  const maxWidth = width * 0.9;
+  while (textMetrics.width > maxWidth && adjustedFontSize > 16) {
+    adjustedFontSize -= 2;
+    ctx.font = `${adjustedFontSize}px "${fontFamily}"`;
+    textMetrics = ctx.measureText(text);
+  }
+  ctx.fillText(text, width / 2, height / 2);
+  return canvas.toDataURL("image/png");
+}
+async function generateSignatureFromTextAsync(options) {
+  await loadSignatureFonts();
+  await waitForFont(options.fontFamily);
+  return generateSignatureFromText(options);
+}
+
 // src/utils/pdf-lib-loader.ts
 var pdfLibPromise = null;
 async function loadPdfLib() {
@@ -338,18 +505,15 @@ function isFieldVisibleToSigner(field, multiSignerContext) {
   if (!multiSignerContext.isMultiSigner) {
     return true;
   }
-  const { currentSignerEmail, isPrimarySigner, isFinalSigner } = multiSignerContext;
+  const { currentSignerEmail } = multiSignerContext;
   if (!field.assignedSignerEmail) {
-    return isFinalSigner;
+    return true;
   }
   if (field.assignedSignerEmail === currentSignerEmail) {
     return true;
   }
-  if (field.assignedSignerEmail.includes("recipients")) {
-    return isPrimarySigner;
-  }
-  if (field.assignedSignerEmail.includes("signers")) {
-    return isFinalSigner;
+  if (field.assignedSignerEmail === "to-recipients" || field.assignedSignerEmail === "additional-signers") {
+    return true;
   }
   return false;
 }
@@ -363,18 +527,15 @@ function shouldFlattenField(field, multiSignerContext) {
   if (!multiSignerContext.isMultiSigner) {
     return true;
   }
-  const { currentSignerEmail, isPrimarySigner, isFinalSigner } = multiSignerContext;
+  const { currentSignerEmail } = multiSignerContext;
   if (!field.assignedSignerEmail) {
-    return isFinalSigner;
+    return true;
   }
   if (field.assignedSignerEmail === currentSignerEmail) {
     return true;
   }
-  if (field.assignedSignerEmail.includes("recipients")) {
-    return isPrimarySigner;
-  }
-  if (field.assignedSignerEmail.includes("signers")) {
-    return isFinalSigner;
+  if (field.assignedSignerEmail === "to-recipients" || field.assignedSignerEmail === "additional-signers") {
+    return true;
   }
   return false;
 }
@@ -414,18 +575,23 @@ function findPageIndexWithFallback(pages, pageRef) {
 
 // src/utils/pdf-field-type-helpers.ts
 function detectFieldType(field) {
-  const typeName = field.constructor.name;
-  if (typeName === "PDFTextField") {
-    return "text";
-  } else if (typeName === "PDFCheckBox") {
+  const f = field;
+  if (typeof f.check === "function" && typeof f.uncheck === "function") {
     return "checkbox";
-  } else if (typeName === "PDFDropdown") {
+  }
+  if (typeof f.select === "function" && typeof f.getOptions === "function" && typeof f.check !== "function" && typeof f.setOptions !== "function") {
+    return "radiogroup";
+  }
+  if (typeof f.select === "function" && typeof f.getOptions === "function" && (typeof f.setOptions === "function" || typeof f.addOptions === "function")) {
     return "dropdown";
-  } else if (typeName === "PDFOptionList") {
+  }
+  if (typeof f.getOptions === "function" && typeof f.setOptions === "function" && typeof f.select !== "function") {
     return "optionlist";
-  } else if (typeName === "PDFRadioGroup") {
-    return "radiogroup";
-  } else if (typeName === "PDFSignature") {
+  }
+  if (typeof f.getText === "function" && typeof f.setText === "function") {
+    return "text";
+  }
+  if (typeof f.getText !== "function" && typeof f.check !== "function" && typeof f.select !== "function") {
     return "signature";
   }
   return "unknown";
@@ -434,13 +600,20 @@ function extractFieldValue(field, fieldType) {
   try {
     switch (fieldType) {
       case "text":
+      case "date":
         return field.getText?.() || "";
       case "checkbox":
         return field.isChecked?.() ? "true" : "false";
       case "dropdown":
-      case "optionlist":
+      case "optionlist": {
+        const selected = field.getSelected?.();
+        return Array.isArray(selected) ? selected[0] || "" : String(selected || "");
+      }
       case "radiogroup":
-        return field.getSelected?.()?.[0] || "";
+      case "radio": {
+        const radioSelected = field.getSelected?.();
+        return radioSelected ? String(radioSelected) : "";
+      }
       default:
         return "";
     }
@@ -744,12 +917,16 @@ async function validatePdfFormFields(pdfBytes, fieldValues, signatures, extracte
     const errors = [];
     for (const field of pdfFormFields) {
       if (field.required) {
+        const extractedField = extractedFields?.find((f) => f.name === field.name);
         if (multiSignerContext?.isMultiSigner && extractedFields) {
-          const extractedField = extractedFields.find((f) => f.name === field.name);
           if (!extractedField) {
             continue;
           }
         }
+        const logicalType = extractedField?.type || field.type;
+        if (logicalType === "date" || logicalType === "signature" || logicalType === "initials") {
+          continue;
+        }
         let hasValue = false;
         const fieldValue = fieldValues[field.name];
         const signatureValue = signatures[field.name];
@@ -759,16 +936,17 @@ async function validatePdfFormFields(pdfBytes, fieldValues, signatures, extracte
           hasValue = !!(signatureValue || fieldValue || mainSignature);
         } else if (field.name.includes("initials")) {
           hasValue = !!(signatureValue || fieldValue || mainInitials);
+        } else if (field.type === "checkbox" || logicalType === "checkbox") {
+          hasValue = fieldValue === "true" || field.value === "true";
         } 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";
-          }
+          const friendlyName = getFieldDisplayName({
+            label: extractedField?.label,
+            name: field.name,
+            type: logicalType
+          });
           errors.push(`${friendlyName} is required`);
         }
       }
@@ -798,12 +976,10 @@ async function validateCurrentPdfState(pdfBytes, signatures, formFieldValues = {
           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";
-          }
+          const friendlyName = getFieldDisplayName({
+            name: field.name,
+            type: field.type
+          });
           errors.push(`${friendlyName} is required`);
         }
       }
@@ -814,7 +990,80 @@ async function validateCurrentPdfState(pdfBytes, signatures, formFieldValues = {
     throw error;
   }
 }
-async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {}, currentSignerEmail, extractedFormFields, metadata, auditTrail, multiSignerContext) {
+function extractFieldFontSize(fieldName, field, extractedFormFields) {
+  const DEFAULT_FONT_SIZE = 10;
+  const MIN_FONT_SIZE = 8;
+  const MAX_FONT_SIZE = 72;
+  const fieldInfo = extractedFormFields?.find((f) => f.name === fieldName);
+  if (fieldInfo?.fontSize && fieldInfo.fontSize >= MIN_FONT_SIZE && fieldInfo.fontSize <= MAX_FONT_SIZE) {
+    return fieldInfo.fontSize;
+  }
+  const daFontSize = extractFromDAField(field);
+  if (daFontSize !== null) {
+    return daFontSize;
+  }
+  const tuFontSize = extractFromTUField(field);
+  if (tuFontSize !== null) {
+    return tuFontSize;
+  }
+  return DEFAULT_FONT_SIZE;
+}
+function extractFromDAField(field) {
+  try {
+    const fieldWithAcro = field;
+    const dict = fieldWithAcro.acroField?.dict;
+    if (!dict) return null;
+    const daKey = dict.context?.obj?.("DA") || "DA";
+    const daEntry = dict.lookup?.(daKey) || dict.get?.(daKey);
+    if (!daEntry) return null;
+    let daValue = "";
+    if (typeof daEntry.decodeText === "function") {
+      daValue = daEntry.decodeText();
+    } else if (typeof daEntry.asString === "function") {
+      daValue = daEntry.asString();
+    } else {
+      daValue = String(daEntry);
+    }
+    const daMatch = daValue.match(/\s+(\d+)\s+Tf/i);
+    if (daMatch?.[1]) {
+      const fontSize = parseInt(daMatch[1], 10);
+      if (fontSize >= 8 && fontSize <= 72) {
+        return fontSize;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function extractFromTUField(field) {
+  try {
+    const fieldWithAcro = field;
+    const dict = fieldWithAcro.acroField?.dict;
+    if (!dict) return null;
+    const tuKey = dict.context?.obj?.("TU") || "TU";
+    const tuEntry = dict.lookup?.(tuKey) || dict.get?.(tuKey);
+    if (!tuEntry) return null;
+    let tuValue = "";
+    if (typeof tuEntry.decodeText === "function") {
+      tuValue = tuEntry.decodeText();
+    } else if (typeof tuEntry.asString === "function") {
+      tuValue = tuEntry.asString();
+    } else {
+      tuValue = String(tuEntry);
+    }
+    tuValue = tuValue.replace(/^\(|\)$|^<|>$/g, "");
+    const match = tuValue.match(/\|fontSize:(\d+)$/);
+    if (match?.[1]) {
+      const fontSize = parseInt(match[1], 10);
+      if (fontSize >= 8 && fontSize <= 72) {
+        return fontSize;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {}, _currentSignerEmail, extractedFormFields, metadata, auditTrail, multiSignerContext) {
   try {
     const { PDFDocument, rgb, StandardFonts } = await loadPdfLib();
     const pdfDoc = await PDFDocument.load(pdfBytes);
@@ -831,39 +1080,39 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
         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;
+        const f = field;
+        const isTextField = typeof f.getText === "function" && typeof f.setText === "function";
+        const isCheckbox = typeof f.check === "function" && typeof f.uncheck === "function";
+        const isRadio = typeof f.select === "function" && typeof f.getOptions === "function" && typeof f.check !== "function" && typeof f.setOptions !== "function";
+        const isDropdown = typeof f.select === "function" && (typeof f.setOptions === "function" || typeof f.addOptions === "function");
+        if (isTextField) {
+          f.setText?.(fieldValue);
+        } else if (isCheckbox) {
           if (fieldValue === "true" || fieldValue === "Yes" || fieldValue === "checked" || fieldValue === "On") {
-            checkBox.check?.();
+            f.check?.();
           } else {
-            checkBox.uncheck?.();
+            f.uncheck?.();
           }
-        } else if (fieldTypeName === "PDFRadioGroup" || fieldTypeName === "PDFRadioGroup2") {
-          const radioGroup = field;
+        } else if (isRadio) {
           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?.() || [];
+            const options = f.getOptions?.() || [];
             if (selectedIndex >= 0 && selectedIndex < options.length) {
-              radioGroup.select?.(options[selectedIndex]);
+              f.select?.(options[selectedIndex]);
             }
           } else {
-            const options = radioGroup.getOptions?.() || [];
+            const options = f.getOptions?.() || [];
             if (options.includes(fieldValue)) {
-              radioGroup.select?.(fieldValue);
+              f.select?.(fieldValue);
             } else {
             }
           }
-        } else if (fieldTypeName === "PDFDropdown" || fieldTypeName === "PDFDropdown2") {
-          const dropdown = field;
-          dropdown.select?.(fieldValue);
+        } else if (isDropdown) {
+          f.select?.(fieldValue);
         }
       } catch (fieldError) {
         logger.error(`Error setting field "${fieldName}":`, fieldError);
@@ -871,11 +1120,6 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
     }
     try {
       form.updateFieldAppearances();
-      const PDFName3 = pdfLib.PDFName;
-      const acroForm = pdfDoc.catalog.lookup(PDFName3.of("AcroForm"));
-      if (acroForm && typeof acroForm === "object" && "set" in acroForm) {
-        acroForm.set(PDFName3.of("NeedAppearances"), false);
-      }
     } catch (appearanceError) {
       logger.warn("Could not update field appearances:", appearanceError);
     }
@@ -944,6 +1188,20 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
                 const y = fieldPosition.y;
                 const width = Math.max(fieldPosition.width, 80);
                 const height = Math.max(fieldPosition.height, 30);
+                const fieldInfo = extractedFormFields?.find((f) => f.name === fieldName);
+                if (fieldInfo && hasDrawableLabel(fieldInfo)) {
+                  const labelFont = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
+                  const labelFontSize = Math.min(10, height * 0.4);
+                  const labelX = x;
+                  const labelY = y + height + 5;
+                  page.drawText(fieldInfo.label, {
+                    x: labelX,
+                    y: labelY,
+                    size: labelFontSize,
+                    font: labelFont,
+                    color: rgb(0, 0, 0)
+                  });
+                }
                 const signatureDims = signatureImage.scaleToFit(width - 4, height - 4);
                 const finalX = x;
                 const finalY = y;
@@ -978,7 +1236,7 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
       console.log("[FLATTEN] After pattern matching in fieldPageMap:", foundInitialsFields);
       if (extractedFormFields && extractedFormFields.length > 0) {
         foundInitialsFields = foundInitialsFields.filter((fieldName) => {
-          const fieldInfo = extractedFormFields.find((f) => f.name === fieldName);
+          const fieldInfo = extractedFormFields.find((f) => f.name === fieldName) || extractedFormFields.find((f) => f.name === fieldName.replace(/_initials$/i, "")) || extractedFormFields.find((f) => fieldName.startsWith(f.name));
           if (!fieldInfo) return false;
           const isActualInitialsField = fieldInfo.type === "initials" || fieldName.toLowerCase().includes("initials");
           if (!isActualInitialsField) return false;
@@ -1007,6 +1265,19 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
                 const y = fieldPosition.y;
                 const height = Math.max(fieldPosition.height, 20);
                 const fontSize = Math.min(height * 0.7, 14);
+                const fieldInfo = extractedFormFields?.find((f) => f.name === fieldName) || extractedFormFields?.find((f) => f.name === fieldName.replace(/_initials$/i, "")) || extractedFormFields?.find((f) => fieldName.startsWith(f.name)) || extractedFormFields?.find((f) => f.fieldId && fieldName.includes(f.fieldId)) || extractedFormFields?.find((f) => f.type === "initials" && f.name !== "initials_field_main");
+                if (fieldInfo && hasDrawableLabel(fieldInfo)) {
+                  const labelFontSize = Math.min(10, height * 0.4);
+                  const labelX = x;
+                  const labelY = y + height + 5;
+                  page.drawText(fieldInfo.label, {
+                    x: labelX,
+                    y: labelY,
+                    size: labelFontSize,
+                    font,
+                    color: rgb(0, 0, 0)
+                  });
+                }
                 const finalX = x + 2;
                 const finalY = y + (height - fontSize) / 2;
                 console.log("[FLATTEN]   \u2705 Drawing initials at:", { x: finalX, y: finalY, fontSize, text: mainInitialsData });
@@ -1049,11 +1320,16 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
     let flattenedCount = 0;
     for (const field of fieldsToFlatten) {
       const fieldName = field.getName();
-      const fieldType = field.constructor.name;
+      const f = field;
+      const isCheckboxField = typeof f.check === "function" && typeof f.uncheck === "function";
+      const isRadioField = typeof f.select === "function" && typeof f.getOptions === "function" && typeof f.check !== "function" && typeof f.setOptions !== "function";
+      const isDropdownField = typeof f.select === "function" && (typeof f.setOptions === "function" || typeof f.addOptions === "function");
+      const isTextField = typeof f.getText === "function" && typeof f.setText === "function";
+      const isSignatureType = !isCheckboxField && !isRadioField && !isDropdownField && !isTextField;
       try {
         const userEnteredValue = formFieldValues[fieldName];
-        const isSignatureField2 = fieldName.toLowerCase().includes("signature") || fieldType.includes("Signature");
-        const isInitialsField2 = fieldName.toLowerCase().includes("initials") || fieldType.includes("Initials");
+        const isSignatureField2 = fieldName.toLowerCase().includes("signature") || isSignatureType;
+        const isInitialsField2 = fieldName.toLowerCase().includes("initials");
         if (isSignatureField2 || isInitialsField2) {
           form.removeField(field);
           flattenedCount++;
@@ -1061,15 +1337,29 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
         }
         const fieldWithWidgets = field;
         const widgets = fieldWithWidgets.acroField?.getWidgets?.() || [];
-        if (fieldType === "PDFCheckBox" || fieldType === "PDFCheckBox2") {
+        if (isCheckboxField) {
           const stringValue = String(userEnteredValue || "");
           const isChecked = stringValue === "true" || stringValue === "Yes" || stringValue === "On" || stringValue === "checked";
+          const fieldInfo = extractedFormFields?.find((f2) => f2.name === fieldName);
+          const labelFont = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
           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;
+              if (fieldInfo && hasDrawableLabel(fieldInfo)) {
+                const labelFontSize = Math.min(10, rect.height * 0.4);
+                const labelX = rect.x + rect.width + 5;
+                const labelY = rect.y + (rect.height - labelFontSize) / 2;
+                page.drawText(fieldInfo.label, {
+                  x: labelX,
+                  y: labelY,
+                  size: labelFontSize,
+                  font: labelFont,
+                  color: rgb(0, 0, 0)
+                });
+              }
+              const checkboxSize = Math.min(rect.width, rect.height);
               const checkboxX = rect.x + (rect.width - checkboxSize) / 2;
               const checkboxY = rect.y + (rect.height - checkboxSize) / 2;
               page.drawRectangle({
@@ -1080,21 +1370,51 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
                 borderColor: rgb(0, 0, 0),
                 borderWidth: 1
               });
-              const checkSize = checkboxSize * 0.6;
-              const textWidth = checkSize * 0.6;
-              const textHeight = checkSize * 0.8;
+              const checkFont = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
+              const checkFontSize = checkboxSize * 0.7;
+              const textWidth = checkFont.widthOfTextAtSize("X", checkFontSize);
+              const textHeight = checkFont.heightAtSize(checkFontSize);
               page.drawText("X", {
                 x: checkboxX + (checkboxSize - textWidth) / 2,
-                y: checkboxY + (checkboxSize - textHeight) / 2 + textHeight * 0.2,
-                size: checkSize,
-                font: await pdfDoc.embedFont(StandardFonts.HelveticaBold),
+                y: checkboxY + (checkboxSize - textHeight) / 2 + textHeight * 0.15,
+                size: checkFontSize,
+                font: checkFont,
                 color: rgb(0, 0, 0)
               });
             }
+          } else {
+            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);
+              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
+              });
+              if (fieldInfo && hasDrawableLabel(fieldInfo)) {
+                const labelFontSize = Math.min(12, rect.height * 0.6);
+                const labelX = rect.x + rect.width + 5;
+                const labelY = rect.y + (rect.height - labelFontSize) / 2;
+                page.drawText(fieldInfo.label, {
+                  x: labelX,
+                  y: labelY,
+                  size: labelFontSize,
+                  font: labelFont,
+                  color: rgb(0, 0, 0)
+                });
+              }
+            }
           }
-        } else if (fieldType === "PDFRadioGroup" || fieldType === "PDFRadioGroup2") {
-          const radioGroup = field;
-          const fieldInfo = extractedFormFields?.find((f) => f.name === fieldName);
+        } else if (isRadioField) {
+          const radioGroup = f;
+          const fieldInfo = extractedFormFields?.find((f2) => f2.name === fieldName);
           let actualSelectedValue = "";
           try {
             actualSelectedValue = radioGroup.getSelected?.() || "";
@@ -1139,14 +1459,15 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
             const result = getWidgetRectangleAndPage(widget, pages);
             if (!result) continue;
             const { rect, page, pageIndex } = result;
-            if (i === 0 && fieldInfo?.label && fieldInfo.label.trim() && !isAutoGeneratedLabel(fieldInfo.label)) {
+            if (i === 0 && fieldInfo && hasDrawableLabel(fieldInfo)) {
               const groupLabelKey = `${pageIndex}-${fieldName}-grouplabel`;
               if (!drawnGroupLabels.has(groupLabelKey)) {
+                const labelFontSize = Math.min(10, rect.height * 0.4);
                 const labelY = rect.y + rect.height + 3;
                 page.drawText(fieldInfo.label, {
                   x: rect.x,
                   y: labelY,
-                  size: 8,
+                  size: labelFontSize,
                   font: labelFont,
                   color: rgb(0, 0, 0)
                 });
@@ -1154,22 +1475,21 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
               }
             } 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;
+            const radioSize = Math.min(rect.width, rect.height);
+            const centerX = rect.x + rect.width / 2;
+            const centerY = rect.y + rect.height / 2;
             page.drawCircle({
-              x: radioX + radioSize / 2,
-              y: radioY + radioSize / 2,
-              size: radioSize,
+              x: centerX,
+              y: centerY,
+              size: radioSize / 2,
               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,
+                x: centerX,
+                y: centerY,
+                size: radioSize / 4,
                 color: rgb(0, 0, 0)
               });
             }
@@ -1179,8 +1499,8 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
               if (optionText && !drawnOptionLabels.has(optionKey)) {
                 page.drawText(optionText, {
                   x: rect.x + rect.width + 4,
-                  y: rect.y + (rect.height - 8) / 2,
-                  size: 8,
+                  y: rect.y + (rect.height - 7) / 2,
+                  size: 7,
                   font: labelFont,
                   color: rgb(0, 0, 0)
                 });
@@ -1190,17 +1510,31 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
           }
           if (fieldInfo?.options) {
           }
-        } else if (fieldType === "PDFDropdown" || fieldType === "PDFDropdown2") {
+        } else if (isDropdownField) {
           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;
+          const fieldInfo = extractedFormFields?.find((f2) => f2.name === fieldName);
+          const labelFont = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
+          for (const widget of widgets) {
+            const result = getWidgetRectangleAndPage(widget, pages);
+            if (!result) continue;
+            const { rect, page } = result;
+            if (fieldInfo && hasDrawableLabel(fieldInfo)) {
+              const labelFontSize = Math.min(10, rect.height * 0.4);
+              const labelX = rect.x;
+              const labelY = rect.y + rect.height + 5;
+              page.drawText(fieldInfo.label, {
+                x: labelX,
+                y: labelY,
+                size: labelFontSize,
+                font: labelFont,
+                color: rgb(0, 0, 0)
+              });
+            }
+            if (selectedValue && selectedValue.trim()) {
               page.drawText(selectedValue, {
                 x: rect.x + 2,
                 y: rect.y + 2,
-                size: 10,
+                size: 14,
                 font: await pdfDoc.embedFont(StandardFonts.Helvetica),
                 color: rgb(0, 0, 0)
               });
@@ -1208,15 +1542,31 @@ async function fillPdfWithSignatures(pdfBytes, signatures, formFieldValues = {},
           }
         } 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;
+          const fieldInfo = extractedFormFields?.find((f2) => f2.name === fieldName);
+          const labelFont = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
+          const isDateField = fieldName.toLowerCase().includes("date") || fieldName.toLowerCase().includes("_date");
+          const fontSize = isDateField ? 14 : extractFieldFontSize(fieldName, field, extractedFormFields);
+          for (const widget of widgets) {
+            const result = getWidgetRectangleAndPage(widget, pages);
+            if (!result) continue;
+            const { rect, page } = result;
+            if (fieldInfo && hasDrawableLabel(fieldInfo)) {
+              const labelFontSize = Math.min(10, rect.height * 0.4);
+              const labelX = rect.x;
+              const labelY = rect.y + rect.height + 5;
+              page.drawText(fieldInfo.label, {
+                x: labelX,
+                y: labelY,
+                size: labelFontSize,
+                font: labelFont,
+                color: rgb(0, 0, 0)
+              });
+            }
+            if (fieldValue && fieldValue.trim()) {
               page.drawText(fieldValue, {
                 x: rect.x + 2,
                 y: rect.y + 2,
-                size: 10,
+                size: fontSize,
                 font: await pdfDoc.embedFont(StandardFonts.Helvetica),
                 color: rgb(0, 0, 0)
               });
@@ -1339,24 +1689,45 @@ async function fillFormFieldsWithSignatures(pdfBytes, formFields, fieldValues, s
         switch (field.type) {
           case "text" /* TEXT */: {
             const value = fieldValues[field.id] || "";
+            if (hasDrawableLabel(field)) {
+              const labelFontSize = Math.min(10, field.position.height * 0.4);
+              const labelX = pdfX;
+              const labelY = pdfY + field.position.height + 5;
+              page.drawText(field.label, {
+                x: labelX,
+                y: labelY,
+                size: labelFontSize,
+                font,
+                color: rgb(0, 0, 0)
+              });
+            }
             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 (hasDrawableLabel(field)) {
+              const labelFontSize = Math.min(10, field.position.height * 0.4);
+              const labelX = pdfX;
+              const labelY = pdfY + field.position.height + 5;
+              page.drawText(field.label, {
+                x: labelX,
+                y: labelY,
+                size: labelFontSize,
+                font,
+                color: rgb(0, 0, 0)
+              });
+            }
             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, {
@@ -1372,10 +1743,22 @@ async function fillFormFieldsWithSignatures(pdfBytes, formFields, fieldValues, s
           }
           case "checkbox" /* CHECKBOX */: {
             const value = fieldValues[field.id] || "";
+            const checkboxSize = Math.min(field.position.width, field.position.height) * 0.7;
+            const checkboxX = pdfX + (field.position.width - checkboxSize) / 2;
+            const checkboxY = pdfY + (field.position.height - checkboxSize) / 2;
+            page.drawRectangle({
+              x: checkboxX,
+              y: checkboxY,
+              width: checkboxSize,
+              height: checkboxSize,
+              borderColor: rgb(0, 0, 0),
+              borderWidth: 1,
+              color: rgb(1, 1, 1)
+            });
             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;
+              const checkSize = checkboxSize * 0.7;
+              const checkX = checkboxX + (checkboxSize - checkSize) / 2;
+              const checkY = checkboxY + (checkboxSize - checkSize) / 2;
               page.drawText("\u2713", {
                 x: checkX,
                 y: checkY,
@@ -1434,6 +1817,18 @@ async function fillFormFieldsWithSignatures(pdfBytes, formFields, fieldValues, s
           }
           case "dropdown" /* DROPDOWN */: {
             const value = fieldValues[field.id] || "";
+            if (hasDrawableLabel(field)) {
+              const labelFontSize = Math.min(10, field.position.height * 0.4);
+              const labelX = pdfX;
+              const labelY = pdfY + field.position.height + 5;
+              page.drawText(field.label, {
+                x: labelX,
+                y: labelY,
+                size: labelFontSize,
+                font,
+                color: rgb(0, 0, 0)
+              });
+            }
             if (value) {
               const fontSize = Math.min(12, field.position.height * 0.6);
               page.drawText(value, {
@@ -1501,6 +1896,203 @@ async function getFieldPageNumbers(pdfBytes) {
   }
 }
 
+// src/utils/pdf-signer-utils.ts
+function getFieldSignerEmail(field) {
+  return field.assignedSignerEmail || null;
+}
+function isFieldAssignedToSigner(field, signerEmail, allSignerEmails = []) {
+  const assignedTo = field.assignedSignerEmail;
+  if (!assignedTo) return false;
+  if (assignedTo === signerEmail) return true;
+  if (assignedTo === "to-recipients" && allSignerEmails.includes(signerEmail)) {
+    return true;
+  }
+  if (assignedTo === "additional-signers" && allSignerEmails.includes(signerEmail)) {
+    return true;
+  }
+  return false;
+}
+async function preparePdfForSigner(inputPdfBytes, formFields, options) {
+  const {
+    activeSignerEmail,
+    hideMode = "NoView",
+    allSignerEmails = []
+  } = options;
+  logger.info(`\u{1F510} Preparing PDF for signer: ${activeSignerEmail}`);
+  logger.info(`\u{1F510} Form fields to process: ${formFields.length}`);
+  logger.info(`\u{1F510} Hide mode: ${hideMode}`);
+  logger.info(`\u{1F510} All signer emails:`, allSignerEmails);
+  logger.info(`\u{1F510} Form field assignments:`, formFields.map((f) => ({
+    name: f.name,
+    assignedTo: f.assignedSignerEmail
+  })));
+  const pdfLib = await loadPdfLib();
+  const { PDFDocument, AnnotationFlags } = pdfLib;
+  let pdfDoc;
+  try {
+    logger.info(`\u{1F510} Loading PDF document, bytes length: ${inputPdfBytes.byteLength || inputPdfBytes.length}`);
+    const bytesArray = inputPdfBytes instanceof Uint8Array ? inputPdfBytes : new Uint8Array(inputPdfBytes);
+    const header = new TextDecoder().decode(bytesArray.slice(0, 8));
+    logger.info(`\u{1F510} PDF header: "${header}"`);
+    if (!header.startsWith("%PDF-")) {
+      throw new Error(`Invalid PDF header: "${header}". Expected "%PDF-"`);
+    }
+    pdfDoc = await PDFDocument.load(inputPdfBytes);
+    logger.info(`\u2705 Successfully loaded PDF document`);
+  } catch (loadError) {
+    logger.error(`\u274C Failed to load PDF with pdf-lib:`, loadError);
+    logger.info(`\u{1F50D} PDF bytes details:`, {
+      type: inputPdfBytes.constructor.name,
+      length: inputPdfBytes.byteLength || inputPdfBytes.length,
+      isArrayBuffer: inputPdfBytes instanceof ArrayBuffer,
+      isUint8Array: inputPdfBytes instanceof Uint8Array,
+      first20Bytes: Array.from(new Uint8Array(inputPdfBytes instanceof ArrayBuffer ? inputPdfBytes : inputPdfBytes.buffer).slice(0, 20)).map((b) => b.toString(16).padStart(2, "0")).join(" ")
+    });
+    throw new Error(`PDF parsing failed for signer ${activeSignerEmail}: ${loadError instanceof Error ? loadError.message : "Unknown error"}`);
+  }
+  const form = pdfDoc.getForm();
+  const pdfFields = form.getFields();
+  logger.info(`\u{1F510} PDF contains ${pdfFields.length} form fields`);
+  for (const pdfField of pdfFields) {
+    const pdfFieldName = pdfField.getName();
+    const matchingFormField = formFields.find(
+      (f) => f.name === pdfFieldName || (f.type === "signature" /* SIGNATURE */ || f.type === "initials" /* INITIALS */) && `${f.name}_signature` === pdfFieldName
+    );
+    if (!matchingFormField) {
+      logger.info(`\u{1F510} PDF field "${pdfFieldName}" not found in provided form fields - leaving unchanged`);
+      continue;
+    }
+    logger.info(`\u{1F510} Matched PDF field "${pdfFieldName}" to FormField "${matchingFormField.name}". Assigned to: ${matchingFormField.assignedSignerEmail}`);
+    const fieldSignerEmail = getFieldSignerEmail(matchingFormField);
+    const isAssignedToActiveSigner = isFieldAssignedToSigner(
+      matchingFormField,
+      activeSignerEmail,
+      allSignerEmails
+    );
+    const isAssignedToCompletedSigner = (options.completedSignerEmails || []).some(
+      (completedEmail) => isFieldAssignedToSigner(matchingFormField, completedEmail, allSignerEmails)
+    );
+    const isUnassigned = !fieldSignerEmail;
+    let isVisible = false;
+    let reason = "";
+    if (isAssignedToActiveSigner) {
+      isVisible = true;
+      reason = "Assigned to active signer";
+    } else if (isUnassigned) {
+      isVisible = true;
+      reason = "Unassigned field (visible to all)";
+    } else {
+      isVisible = false;
+      reason = `Assigned to different signer (${fieldSignerEmail})`;
+    }
+    const isLocked = (options.lockCompletedFields ?? true) && isAssignedToCompletedSigner;
+    if (isLocked) {
+      reason += " - Locked (completed)";
+    }
+    logger.info(`\u{1F510} Processing field "${pdfFieldName}": ${reason}`);
+    if (isLocked) {
+      try {
+        const fieldWithExtensions = pdfField;
+        if (typeof fieldWithExtensions.enableReadOnly === "function") {
+          fieldWithExtensions.enableReadOnly();
+        } else if (typeof fieldWithExtensions.setReadOnly === "function") {
+          fieldWithExtensions.setReadOnly(true);
+        }
+        logger.info(`\u{1F512} Locked field "${pdfFieldName}"`);
+      } catch (error) {
+        logger.warn(`\u26A0\uFE0F Could not lock field "${pdfFieldName}":`, error);
+      }
+    }
+    try {
+      const fieldWithExtensions = pdfField;
+      const widgets = fieldWithExtensions.acroField?.getWidgets?.() ?? [];
+      for (const widget of widgets) {
+        if (typeof widget.clearFlag === "function") {
+          widget.clearFlag(AnnotationFlags.Hidden);
+          widget.clearFlag(AnnotationFlags.NoView);
+        }
+        if (!isVisible) {
+          const flag = hideMode === "Hidden" ? AnnotationFlags.Hidden : AnnotationFlags.NoView;
+          if (typeof widget.setFlag === "function") {
+            widget.setFlag(flag);
+          }
+          if (typeof widget.clearFlag === "function") {
+            widget.clearFlag(AnnotationFlags.Print);
+          }
+          logger.info(`\u{1F648} Hidden field "${pdfFieldName}" using ${hideMode} flag`);
+        } else {
+          if (typeof widget.setFlag === "function") {
+            widget.setFlag(AnnotationFlags.Print);
+          }
+          logger.info(`\u{1F441}\uFE0F Made field "${pdfFieldName}" visible`);
+        }
+      }
+    } catch (error) {
+      logger.warn(`\u26A0\uFE0F Could not set visibility for field "${pdfFieldName}":`, error);
+    }
+  }
+  try {
+    const currentSubject = pdfDoc.getSubject() || "";
+    const signerInfo = `Prepared for: ${activeSignerEmail}`;
+    const newSubject = currentSubject ? `${currentSubject} | ${signerInfo}` : signerInfo;
+    pdfDoc.setSubject(newSubject);
+    const currentKeywords = pdfDoc.getKeywords() || [];
+    const updatedKeywords = [...currentKeywords, `ActiveSigner:${activeSignerEmail}`];
+    pdfDoc.setKeywords(updatedKeywords);
+    logger.info(`\u{1F4DD} Added signer metadata to PDF`);
+  } catch (error) {
+    logger.warn(`\u26A0\uFE0F Could not set PDF metadata:`, error);
+  }
+  const modifiedPdfBytes = await pdfDoc.save();
+  logger.info(`\u2705 PDF prepared for ${activeSignerEmail}: ${modifiedPdfBytes.length} bytes`);
+  return new Uint8Array(modifiedPdfBytes);
+}
+function areAllSignersComplete(signers, completedSignerEmails) {
+  const requiredSigners = new Set(signers.map((s) => s.email));
+  const completedSigners = new Set(completedSignerEmails);
+  for (const signerEmail of requiredSigners) {
+    if (!completedSigners.has(signerEmail)) {
+      return false;
+    }
+  }
+  return true;
+}
+function getNextSigner(signers, completedSignerEmails) {
+  const completedSet = new Set(completedSignerEmails);
+  const sortedSigners = [...signers].sort((a, b) => a.signOrder - b.signOrder);
+  for (const signer of sortedSigners) {
+    if (!completedSet.has(signer.email)) {
+      return signer;
+    }
+  }
+  return null;
+}
+function validateFieldAssignments(formFields, signers) {
+  const errors = [];
+  const signerEmailSet = new Set(signers.map((s) => s.email));
+  const assignedEmails = new Set(
+    formFields.map((field) => field.assignedSignerEmail).filter((email) => email)
+  );
+  for (const assignedEmail of assignedEmails) {
+    if (assignedEmail === "to-recipients" || assignedEmail === "additional-signers") {
+      continue;
+    }
+    if (!signerEmailSet.has(assignedEmail)) {
+      errors.push(`Field assigned to unknown signer: ${assignedEmail}`);
+    }
+  }
+  const requiredUnassignedFields = formFields.filter(
+    (field) => field.required && !field.assignedSignerEmail
+  );
+  if (requiredUnassignedFields.length > 0) {
+    errors.push(`${requiredUnassignedFields.length} required fields are not assigned to any signer`);
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
 // src/utils/field-extraction.ts
 var PDFName2;
 async function extractVisibleFormFields(pdfBytes, currentSignerEmail) {
@@ -1515,7 +2107,6 @@ async function extractVisibleFormFields(pdfBytes, currentSignerEmail) {
     const fields = form.getFields();
     const visibleFields = [];
     let hasAnyInitialsFields = false;
-    let hasInitialsFieldsForCurrentSigner = false;
     for (const field of fields) {
       const fieldName = field.getName();
       const fieldWithExtensions = field;
@@ -1541,28 +2132,31 @@ async function extractVisibleFormFields(pdfBytes, currentSignerEmail) {
           };
         })();
         let fieldType = "text" /* TEXT */;
-        const fieldTypeName = field.constructor.name;
+        const f = field;
+        const isCheckboxField = typeof f.check === "function" && typeof f.uncheck === "function";
+        const isRadioField = typeof f.select === "function" && typeof f.getOptions === "function" && typeof f.check !== "function" && typeof f.setOptions !== "function";
+        const isDropdownField = typeof f.select === "function" && (typeof f.setOptions === "function" || typeof f.addOptions === "function");
+        const isTextField = typeof f.getText === "function" && typeof f.setText === "function";
+        const isSignatureType = !isCheckboxField && !isRadioField && !isDropdownField && !isTextField;
         const cleanFieldName = fieldName.replace(/_signature$|_initials$|_date$/i, "");
-        const isActualSignatureField = fieldTypeName.includes("Signature") || cleanFieldName.toLowerCase().includes("signature") && !fieldTypeName.includes("CheckBox") && !fieldTypeName.includes("Radio");
-        const isActualInitialsField = cleanFieldName.toLowerCase().includes("initials") && !fieldTypeName.includes("CheckBox") && !fieldTypeName.includes("Radio");
+        const isActualSignatureField = isSignatureType || cleanFieldName.toLowerCase().includes("signature") && !isCheckboxField && !isRadioField;
+        const isActualInitialsField = cleanFieldName.toLowerCase().includes("initials") && !isCheckboxField && !isRadioField;
         if (isActualSignatureField) {
           fieldType = "signature" /* SIGNATURE */;
         } else if (isActualInitialsField) {
           fieldType = "initials" /* INITIALS */;
           hasAnyInitialsFields = true;
-          if (currentSignerEmail && fieldMetadata.signer === currentSignerEmail) {
-            hasInitialsFieldsForCurrentSigner = true;
-          }
         } else if (cleanFieldName.toLowerCase().includes("date")) {
           fieldType = "date" /* DATE */;
-        } else if (fieldTypeName.includes("CheckBox")) {
+        } else if (isCheckboxField) {
           fieldType = "checkbox" /* CHECKBOX */;
-        } else if (fieldTypeName.toLowerCase().includes("dropdown")) {
+        } else if (isDropdownField) {
           fieldType = "dropdown" /* DROPDOWN */;
-        } else if (fieldTypeName.includes("Radio")) {
+        } else if (isRadioField) {
           fieldType = "radio" /* RADIO */;
         }
         let displayLabel = fieldMetadata.label || "";
+        let isLabelAutoGenerated = false;
         if (!displayLabel || !displayLabel.trim()) {
           try {
             const tuLabel = extractTULabel(fieldWithExtensions);
@@ -1574,6 +2168,7 @@ async function extractVisibleFormFields(pdfBytes, currentSignerEmail) {
         }
         if (!displayLabel || !displayLabel.trim()) {
           displayLabel = generateFallbackLabel(cleanFieldName, fieldType);
+          isLabelAutoGenerated = true;
         }
         const esignField = {
           id: fieldName,
@@ -1585,6 +2180,8 @@ async function extractVisibleFormFields(pdfBytes, currentSignerEmail) {
           type: fieldType,
           label: displayLabel,
           // Use friendly label for display
+          isLabelAutoGenerated,
+          // True when label was generated from field name (should not be drawn on PDF)
           position: { x: 0, y: 0, width: 100, height: 30, page: 1 },
           // Default position
           required: fieldWithExtensions.isRequired?.() ?? false,
@@ -1605,6 +2202,13 @@ async function extractVisibleFormFields(pdfBytes, currentSignerEmail) {
             logger.warn("Error extracting options for field:", error);
           }
         }
+        try {
+          const currentValue = extractFieldValue(f, esignField.type);
+          if (currentValue) {
+            esignField.defaultValue = currentValue;
+          }
+        } catch {
+        }
         visibleFields.push(esignField);
       }
     }
@@ -1621,11 +2225,8 @@ async function extractVisibleFormFields(pdfBytes, currentSignerEmail) {
       placeholder: "Draw or upload your signature",
       assignedSignerEmail: currentSignerEmail
     });
-    const shouldCreateInitialsField = hasInitialsFieldsForCurrentSigner || hasAnyInitialsFields && !currentSignerEmail;
+    const shouldCreateInitialsField = hasAnyInitialsFields;
     if (shouldCreateInitialsField) {
-      if (hasInitialsFieldsForCurrentSigner) {
-      } else {
-      }
       mainFields.push({
         id: "initials_field_main",
         fieldId: "initials_field_main",
@@ -1712,8 +2313,12 @@ function decodeFieldName(fieldName) {
 }
 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)) {
+  let prevLabel = "";
+  while (displayLabel !== prevLabel) {
+    prevLabel = displayLabel;
+    displayLabel = displayLabel.replace(/_signature$/i, "").replace(/_initials$/i, "").replace(/_date$/i, "");
+  }
+  if (/^(text|signature|initials|date|checkbox|radio|dropdown)_\d+/i.test(displayLabel)) {
     if (fieldType === "signature" /* SIGNATURE */) return "Signature";
     if (fieldType === "initials" /* INITIALS */) return "Initials";
     if (fieldType === "date" /* DATE */) return "Date";
@@ -1721,9 +2326,9 @@ function generateFallbackLabel(decodedFieldName, fieldType) {
     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(" ");
+    if (fieldType === "text_label" /* TEXT_LABEL */) return "Text Label";
   }
+  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) {
@@ -1750,6 +2355,28 @@ function extractTULabel(field) {
     return "";
   }
 }
+function findFieldByUuid(fields, uuid) {
+  return fields.find((f) => f.fieldId === uuid);
+}
+function resolveField(fields, identifier) {
+  let field = findFieldByUuid(fields, identifier);
+  if (field) {
+    return field;
+  }
+  field = fields.find((f) => f.id === identifier);
+  if (field) {
+    return field;
+  }
+  field = fields.find((f) => f.name === identifier);
+  if (field) {
+    return field;
+  }
+  const cleanIdentifier = identifier.replace(/_signature$|_initials$|_date$/i, "");
+  return fields.find((f) => f.fieldId === cleanIdentifier || f.id === cleanIdentifier || f.name === cleanIdentifier);
+}
+function getFieldUuidsForSigner(fields, signerEmail) {
+  return fields.filter((f) => f.assignedSignerEmail === signerEmail && f.fieldId).map((f) => f.fieldId);
+}
 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;
@@ -1823,7 +2450,7 @@ function initializePdfJs() {
 async function checkPdfJsVersion(viewerBasePath = "/pdfjs") {
   const workerVersion = pdfjsLib2__namespace.version;
   try {
-    const versionUrl = `${viewerBasePath}/.version`;
+    const versionUrl = `${viewerBasePath}/version.txt`;
     const response = await fetch(versionUrl);
     if (!response.ok) {
       return {
@@ -2051,13 +2678,13 @@ function getErrorMessage(error, defaultMessage = "Unknown error") {
 
 // src/utils/attachment-validators.ts
 var DEFAULT_ATTACHMENT_CONSTRAINTS = {
-  maxFileSize: 10 * 1024 * 1024,
-  // 10MB
+  maxFileSize: 25 * 1024 * 1024,
+  // 25MB
   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"]
+  allowedExtensions: [".pdf", ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".doc", ".docx"]
 };
 function validateFile(file, constraints = DEFAULT_ATTACHMENT_CONSTRAINTS) {
   const errors = [];
@@ -2349,6 +2976,23 @@ function withPerformanceMonitoring(label, fn, monitor = globalPerformanceMonitor
     }
   });
 }
+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/date-validation.ts
 function toIsoDateString(date) {
   const year = date.getFullYear();
   const month = String(date.getMonth() + 1).padStart(2, "0");
@@ -2472,21 +3116,6 @@ function parseAndValidateDate(value) {
     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";
@@ -2570,10 +3199,13 @@ exports.AttachmentValidationError = AttachmentValidationError;
 exports.CDN_VIEWER = CDN_VIEWER;
 exports.CDN_WORKER = CDN_WORKER;
 exports.DEFAULT_ATTACHMENT_CONSTRAINTS = DEFAULT_ATTACHMENT_CONSTRAINTS;
+exports.DEFAULT_SIGNATURE_FONT = DEFAULT_SIGNATURE_FONT;
 exports.FormFieldError = FormFieldError;
 exports.PdfProcessingError = PdfProcessingError;
 exports.PdfValidationError = PdfValidationError;
 exports.PerformanceMonitor = PerformanceMonitor;
+exports.SIGNATURE_FONTS = SIGNATURE_FONTS;
+exports.areAllSignersComplete = areAllSignersComplete;
 exports.captureAuditTrail = captureAuditTrail;
 exports.captureDeviceMetadata = captureDeviceMetadata;
 exports.captureGeolocation = captureGeolocation;
@@ -2591,22 +3223,30 @@ exports.extractVisibleFormFields = extractVisibleFormFields;
 exports.fillFormFieldsWithSignatures = fillFormFieldsWithSignatures;
 exports.fillPdfWithSignatures = fillPdfWithSignatures;
 exports.filterFieldsBySigner = filterFieldsBySigner;
+exports.findFieldByUuid = findFieldByUuid;
 exports.findPageIndexByRef = findPageIndexByRef;
 exports.findPageIndexWithFallback = findPageIndexWithFallback;
 exports.formatFieldName = formatFieldName;
 exports.formatFileSize = formatFileSize;
 exports.generateFallbackLabel = generateFallbackLabel;
+exports.generateSignatureFromText = generateSignatureFromText;
+exports.generateSignatureFromTextAsync = generateSignatureFromTextAsync;
 exports.getErrorMessage = getErrorMessage;
+exports.getFieldDisplayName = getFieldDisplayName;
 exports.getFieldPageNumbers = getFieldPageNumbers;
+exports.getFieldUuidsForSigner = getFieldUuidsForSigner;
+exports.getNextSigner = getNextSigner;
 exports.getPdfJsConfig = getPdfJsConfig;
 exports.getSigniphiMetadata = getSigniphiMetadata;
 exports.getWidgetRectangleAndPage = getWidgetRectangleAndPage;
 exports.globalPerformanceMonitor = globalPerformanceMonitor;
+exports.hasDrawableLabel = hasDrawableLabel;
 exports.initPdfMetadata = initPdfMetadata;
 exports.initializePdfJs = initializePdfJs;
 exports.isAttachmentValidationError = isAttachmentValidationError;
 exports.isAutoGeneratedLabel = isAutoGeneratedLabel;
 exports.isFieldVisibleToSigner = isFieldVisibleToSigner;
+exports.isFontLoaded = isFontLoaded;
 exports.isFormFieldError = isFormFieldError;
 exports.isImageType = isImageType;
 exports.isInitialsField = isInitialsField;
@@ -2616,15 +3256,18 @@ exports.isRequiredField = isRequiredField;
 exports.isSignatureField = isSignatureField;
 exports.isValidISODate = isValidISODate;
 exports.isValidPdf = isValidPdf;
+exports.loadSignatureFonts = loadSignatureFonts;
 exports.logVersionCheckWarning = logVersionCheckWarning;
 exports.logger = logger;
 exports.measurePerformance = measurePerformance;
 exports.parseAndValidateDate = parseAndValidateDate;
 exports.pdfToImages = pdfToImages;
+exports.preparePdfForSigner = preparePdfForSigner;
 exports.readCurrentPdfFormValues = readCurrentPdfFormValues;
 exports.readPdfFormFields = readPdfFormFields;
 exports.removeAllFormFields = removeAllFormFields;
 exports.resetPdfJsConfig = resetPdfJsConfig;
+exports.resolveField = resolveField;
 exports.setPdfJsConfig = setPdfJsConfig;
 exports.setSigniphiMetadata = setSigniphiMetadata;
 exports.shouldFlattenField = shouldFlattenField;
@@ -2634,6 +3277,7 @@ exports.trackDocumentSigned = trackDocumentSigned;
 exports.trackDocumentSignedSilent = trackDocumentSignedSilent;
 exports.urlToPdfBytes = urlToPdfBytes;
 exports.validateCurrentPdfState = validateCurrentPdfState;
+exports.validateFieldAssignments = validateFieldAssignments;
 exports.validateFieldValues = validateFieldValues;
 exports.validateFile = validateFile;
 exports.validateFileOrThrow = validateFileOrThrow;
@@ -2644,6 +3288,7 @@ exports.validatePdfBytes = validatePdfBytes;
 exports.validatePdfFormFields = validatePdfFormFields;
 exports.validatePdfUrl = validatePdfUrl;
 exports.validateSignatures = validateSignatures;
+exports.waitForFont = waitForFont;
 exports.withPerformanceMonitoring = withPerformanceMonitoring;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map