@signiphi/page-assembly 0.2.0-beta.2 → 0.2.0-beta.20

package/dist/index.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var React7 = require('react');
 var reactDnd = require('react-dnd');
 var reactDndHtml5Backend = require('react-dnd-html5-backend');
@@ -249,8 +247,9 @@ var SelectContent = React7__namespace.forwardRef(({ className, children, positio
     position,
     style: {
       zIndex: 99999,
-      backgroundColor: "#ffffff",
-      border: "1px solid #e2e8f0",
+      backgroundColor: "hsl(var(--xpa-popover))",
+      color: "hsl(var(--xpa-popover-foreground))",
+      border: "1px solid hsl(var(--xpa-border))",
       borderRadius: "0.5rem",
       boxShadow: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
       marginTop: "4px"
@@ -344,16 +343,23 @@ var AlertDialogOverlay = React7__namespace.forwardRef(({ className, ...props },
   }
 ));
 AlertDialogOverlay.displayName = AlertDialogPrimitive__namespace.Overlay.displayName;
-var AlertDialogContent = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogPortal, { container: document.querySelector(".signiphi-page-assembly"), children: [
+var CENTERED = {
+  position: "fixed",
+  left: "50%",
+  top: "50%",
+  transform: "translate(-50%, -50%)"
+};
+var AlertDialogContent = React7__namespace.forwardRef(({ className, style, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogPortal, { container: document.querySelector(".signiphi-page-assembly"), children: [
   /* @__PURE__ */ jsxRuntime.jsx(AlertDialogOverlay, {}),
   /* @__PURE__ */ jsxRuntime.jsx(
     AlertDialogPrimitive__namespace.Content,
     {
       ref,
       className: cn(
-        "fixed left-[50%] top-[50%] z-[9999] grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+        "z-[9999] grid w-full max-w-lg gap-4 border bg-background p-6 shadow-lg sm:rounded-lg",
         className
       ),
+      style: { ...CENTERED, ...style },
       ...props
     }
   )
@@ -469,8 +475,9 @@ var DropdownMenuContent = React7__namespace.forwardRef(({ className, sideOffset
     ),
     style: {
       zIndex: 99999,
-      backgroundColor: "#ffffff",
-      border: "1px solid #e2e8f0",
+      backgroundColor: "hsl(var(--xpa-popover))",
+      color: "hsl(var(--xpa-popover-foreground))",
+      border: "1px solid hsl(var(--xpa-border))",
       borderRadius: "0.5rem",
       boxShadow: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
       padding: "6px"
@@ -576,6 +583,623 @@ var TooltipContent = React7__namespace.forwardRef(({ className, sideOffset = 4,
   }
 ));
 TooltipContent.displayName = TooltipPrimitive__namespace.Content.displayName;
+var PdfPasswordRequiredError = class extends Error {
+  constructor() {
+    const message = "This PDF is password-protected. Please remove the password and upload it again.";
+    super(message);
+    this.code = "PDF_PASSWORD_REQUIRED";
+    this.recoverable = true;
+    this.name = "PdfPasswordRequiredError";
+    this.userMessage = message;
+  }
+};
+var UnsupportedPdfEncryptionError = class extends Error {
+  constructor(detail) {
+    super(`This PDF uses an unsupported encryption scheme (${detail}).`);
+    this.name = "UnsupportedPdfEncryptionError";
+    this.detail = detail;
+  }
+};
+function concatBytes(...parts) {
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    out.set(p, offset);
+    offset += p.length;
+  }
+  return out;
+}
+var MD5_S = [
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21
+];
+var MD5_K = (() => {
+  const k = new Uint32Array(64);
+  for (let i = 0; i < 64; i++) k[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 4294967296);
+  return k;
+})();
+function md5(input) {
+  const bitLen = input.length * 8;
+  const paddedLen = (input.length + 8 >> 6) + 1 << 6;
+  const buf = new Uint8Array(paddedLen);
+  buf.set(input);
+  buf[input.length] = 128;
+  const dv = new DataView(buf.buffer);
+  dv.setUint32(paddedLen - 8, bitLen >>> 0, true);
+  dv.setUint32(paddedLen - 4, Math.floor(bitLen / 4294967296), true);
+  let a0 = 1732584193;
+  let b0 = 4023233417;
+  let c0 = 2562383102;
+  let d0 = 271733878;
+  const M = new Uint32Array(16);
+  for (let offset = 0; offset < paddedLen; offset += 64) {
+    for (let i = 0; i < 16; i++) M[i] = dv.getUint32(offset + i * 4, true);
+    let A = a0;
+    let B = b0;
+    let C = c0;
+    let D = d0;
+    for (let i = 0; i < 64; i++) {
+      let F;
+      let g;
+      if (i < 16) {
+        F = B & C | ~B & D;
+        g = i;
+      } else if (i < 32) {
+        F = D & B | ~D & C;
+        g = 5 * i + 1 & 15;
+      } else if (i < 48) {
+        F = B ^ C ^ D;
+        g = 3 * i + 5 & 15;
+      } else {
+        F = C ^ (B | ~D);
+        g = 7 * i & 15;
+      }
+      const tmp = D;
+      D = C;
+      C = B;
+      const x = A + F + MD5_K[i] + M[g] | 0;
+      const s = MD5_S[i];
+      B = B + (x << s | x >>> 32 - s) | 0;
+      A = tmp;
+    }
+    a0 = a0 + A | 0;
+    b0 = b0 + B | 0;
+    c0 = c0 + C | 0;
+    d0 = d0 + D | 0;
+  }
+  const out = new Uint8Array(16);
+  const ov = new DataView(out.buffer);
+  ov.setUint32(0, a0 >>> 0, true);
+  ov.setUint32(4, b0 >>> 0, true);
+  ov.setUint32(8, c0 >>> 0, true);
+  ov.setUint32(12, d0 >>> 0, true);
+  return out;
+}
+function rc4(key, data) {
+  const S = new Uint8Array(256);
+  for (let i2 = 0; i2 < 256; i2++) S[i2] = i2;
+  let j = 0;
+  for (let i2 = 0; i2 < 256; i2++) {
+    j = j + S[i2] + key[i2 % key.length] & 255;
+    const t = S[i2];
+    S[i2] = S[j];
+    S[j] = t;
+  }
+  const out = new Uint8Array(data.length);
+  let i = 0;
+  j = 0;
+  for (let k = 0; k < data.length; k++) {
+    i = i + 1 & 255;
+    j = j + S[i] & 255;
+    const t = S[i];
+    S[i] = S[j];
+    S[j] = t;
+    out[k] = data[k] ^ S[S[i] + S[j] & 255];
+  }
+  return out;
+}
+function getSubtle() {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new UnsupportedPdfEncryptionError("WebCrypto is unavailable in this environment");
+  return subtle;
+}
+async function sha2(algorithm, data) {
+  return new Uint8Array(await getSubtle().digest(algorithm, data));
+}
+async function importAesKey(rawKey, usages) {
+  return getSubtle().importKey("raw", rawKey, "AES-CBC", false, usages);
+}
+async function aesCbcEncryptNoPad(rawKey, iv, data) {
+  const key = await importAesKey(rawKey, ["encrypt"]);
+  const out = new Uint8Array(await getSubtle().encrypt({ name: "AES-CBC", iv }, key, data));
+  return out.slice(0, data.length);
+}
+async function aesCbcDecryptNoPad(rawKey, iv, data) {
+  const key = await importAesKey(rawKey, ["encrypt", "decrypt"]);
+  const lastBlock = data.slice(data.length - 16);
+  const padBlock = new Uint8Array(
+    await getSubtle().encrypt({ name: "AES-CBC", iv: lastBlock }, key, new Uint8Array(0))
+  );
+  const joined = concatBytes(data, padBlock);
+  return new Uint8Array(await getSubtle().decrypt({ name: "AES-CBC", iv }, key, joined));
+}
+async function aesDecryptPdfData(rawKey, data) {
+  if (data.length < 32) return new Uint8Array(0);
+  const iv = data.slice(0, 16);
+  let ct = data.slice(16);
+  if (ct.length % 16 !== 0) ct = ct.slice(0, ct.length - ct.length % 16);
+  try {
+    const key = await importAesKey(rawKey, ["decrypt"]);
+    return new Uint8Array(await getSubtle().decrypt({ name: "AES-CBC", iv }, key, ct));
+  } catch {
+    const plain = await aesCbcDecryptNoPad(rawKey, iv, ct);
+    const padLen = plain[plain.length - 1];
+    return padLen >= 1 && padLen <= 16 ? plain.slice(0, plain.length - padLen) : plain;
+  }
+}
+var PAD = new Uint8Array([
+  40,
+  191,
+  78,
+  94,
+  78,
+  117,
+  138,
+  65,
+  100,
+  0,
+  78,
+  86,
+  255,
+  250,
+  1,
+  8,
+  46,
+  46,
+  0,
+  182,
+  208,
+  104,
+  62,
+  128,
+  47,
+  12,
+  169,
+  254,
+  100,
+  83,
+  105,
+  122
+]);
+var bytesEqual = (a, b) => {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+};
+function legacyFileKey(paddedPwd, params) {
+  const { revision, keyLen, O, P, id0, encryptMetadata } = params;
+  const pBytes = new Uint8Array(4);
+  new DataView(pBytes.buffer).setInt32(0, P | 0, true);
+  const parts = [paddedPwd, O.slice(0, 32), pBytes, id0];
+  if (revision >= 4 && !encryptMetadata) parts.push(new Uint8Array([255, 255, 255, 255]));
+  let h = md5(concatBytes(...parts));
+  if (revision >= 3) for (let i = 0; i < 50; i++) h = md5(h.slice(0, keyLen));
+  return h.slice(0, keyLen);
+}
+function legacyComputeU(fileKey, revision, id0) {
+  if (revision === 2) return rc4(fileKey, PAD);
+  let d = md5(concatBytes(PAD, id0));
+  d = rc4(fileKey, d);
+  for (let i = 1; i <= 19; i++) d = rc4(fileKey.map((b) => b ^ i), d);
+  return d;
+}
+function legacyUMatches(fileKey, params) {
+  const computed = legacyComputeU(fileKey, params.revision, params.id0);
+  return params.revision === 2 ? bytesEqual(computed, params.U.slice(0, 32)) : bytesEqual(computed.slice(0, 16), params.U.slice(0, 16));
+}
+function legacyAuthenticateEmptyPassword(params) {
+  const userKey = legacyFileKey(PAD, params);
+  if (legacyUMatches(userKey, params)) return userKey;
+  throw new PdfPasswordRequiredError();
+}
+async function hash2B(password, salt, udata) {
+  let k = await sha2("SHA-256", concatBytes(password, salt, udata));
+  let e = new Uint8Array(0);
+  let i = 0;
+  do {
+    const block = concatBytes(password, k, udata);
+    const k1 = new Uint8Array(block.length * 64);
+    for (let rep = 0; rep < 64; rep++) k1.set(block, rep * block.length);
+    e = await aesCbcEncryptNoPad(k.slice(0, 16), k.slice(16, 32), k1);
+    let sum = 0;
+    for (let b = 0; b < 16; b++) sum += e[b];
+    const mod = sum % 3;
+    k = await sha2(mod === 0 ? "SHA-256" : mod === 1 ? "SHA-384" : "SHA-512", e);
+    i++;
+  } while (i < 64 || e[e.length - 1] > i - 32);
+  return k.slice(0, 32);
+}
+async function v5AuthenticateEmptyPassword(revision, U, UE) {
+  const pwd = new Uint8Array(0);
+  const zeroIv = new Uint8Array(16);
+  const hash = async (salt, udata) => revision === 5 ? sha2("SHA-256", concatBytes(pwd, salt, udata)) : hash2B(pwd, salt, udata);
+  const userHash = await hash(U.slice(32, 40), new Uint8Array(0));
+  if (bytesEqual(userHash, U.slice(0, 32))) {
+    const intermediate = await hash(U.slice(40, 48), new Uint8Array(0));
+    return aesCbcDecryptNoPad(intermediate, zeroIv, UE.slice(0, 32));
+  }
+  throw new PdfPasswordRequiredError();
+}
+var identityCipher = async (data) => data;
+function rc4ObjectCipher(fileKey) {
+  return async (data, ref) => {
+    const ext = new Uint8Array([
+      ref.objectNumber & 255,
+      ref.objectNumber >> 8 & 255,
+      ref.objectNumber >> 16 & 255,
+      ref.generationNumber & 255,
+      ref.generationNumber >> 8 & 255
+    ]);
+    const key = md5(concatBytes(fileKey, ext)).slice(0, Math.min(fileKey.length + 5, 16));
+    return rc4(key, data);
+  };
+}
+var AES_SALT = new Uint8Array([115, 65, 108, 84]);
+function aes128ObjectCipher(fileKey) {
+  return async (data, ref) => {
+    const ext = new Uint8Array([
+      ref.objectNumber & 255,
+      ref.objectNumber >> 8 & 255,
+      ref.objectNumber >> 16 & 255,
+      ref.generationNumber & 255,
+      ref.generationNumber >> 8 & 255
+    ]);
+    const key = md5(concatBytes(fileKey, ext, AES_SALT)).slice(0, 16);
+    return aesDecryptPdfData(key, data);
+  };
+}
+function aes256ObjectCipher(fileKey) {
+  return async (data) => aesDecryptPdfData(fileKey, data);
+}
+function dictNumber(dict, key) {
+  const value = dict.lookup(pdfLib.PDFName.of(key));
+  return value instanceof pdfLib.PDFNumber ? value.asNumber() : void 0;
+}
+function dictBytes(dict, key) {
+  const value = dict.lookup(pdfLib.PDFName.of(key));
+  return value instanceof pdfLib.PDFString || value instanceof pdfLib.PDFHexString ? value.asBytes() : void 0;
+}
+async function buildDocumentCiphers(encDict, id0) {
+  const filter = encDict.lookup(pdfLib.PDFName.of("Filter"));
+  if (filter !== pdfLib.PDFName.of("Standard")) {
+    throw new UnsupportedPdfEncryptionError(`security handler ${String(filter)}`);
+  }
+  const V = dictNumber(encDict, "V") ?? 0;
+  const R = dictNumber(encDict, "R") ?? 0;
+  const O = dictBytes(encDict, "O");
+  const U = dictBytes(encDict, "U");
+  const P = dictNumber(encDict, "P") ?? -1;
+  const metadataValue = encDict.lookup(pdfLib.PDFName.of("EncryptMetadata"));
+  const encryptMetadata = metadataValue instanceof pdfLib.PDFBool ? metadataValue.asBoolean() : true;
+  if (!O || !U) throw new UnsupportedPdfEncryptionError("missing /O or /U");
+  if (V === 1 || V === 2) {
+    const keyLen = V === 1 ? 5 : (dictNumber(encDict, "Length") ?? 40) / 8;
+    const fileKey = legacyAuthenticateEmptyPassword({ revision: R, keyLen, O, U, P, id0, encryptMetadata });
+    const cipher = rc4ObjectCipher(fileKey);
+    return { stringCipher: cipher, streamCipher: cipher, encryptMetadata };
+  }
+  if (V === 4 || V === 5) {
+    const cf = encDict.lookup(pdfLib.PDFName.of("CF"));
+    const cfmOf = (filterKey) => {
+      const streamFilter = encDict.lookup(pdfLib.PDFName.of(filterKey));
+      if (!(streamFilter instanceof pdfLib.PDFName) || streamFilter === pdfLib.PDFName.of("Identity")) return void 0;
+      if (!(cf instanceof pdfLib.PDFDict)) throw new UnsupportedPdfEncryptionError("missing /CF");
+      const cfDict = cf.lookup(streamFilter);
+      if (!(cfDict instanceof pdfLib.PDFDict)) throw new UnsupportedPdfEncryptionError(`missing crypt filter ${streamFilter.toString()}`);
+      const cfm = cfDict.lookup(pdfLib.PDFName.of("CFM"));
+      return cfm instanceof pdfLib.PDFName ? cfm : void 0;
+    };
+    let fileKey;
+    if (V === 5) {
+      const UE = dictBytes(encDict, "UE");
+      if (!UE) throw new UnsupportedPdfEncryptionError("missing /UE");
+      fileKey = await v5AuthenticateEmptyPassword(R, U, UE);
+    } else {
+      const cryptFilterLengthBits = () => {
+        if (!(cf instanceof pdfLib.PDFDict)) return void 0;
+        for (const filterKey of ["StmF", "StrF"]) {
+          const filter2 = encDict.lookup(pdfLib.PDFName.of(filterKey));
+          if (!(filter2 instanceof pdfLib.PDFName) || filter2 === pdfLib.PDFName.of("Identity")) continue;
+          const cfDict = cf.lookup(filter2);
+          if (!(cfDict instanceof pdfLib.PDFDict)) continue;
+          const len = dictNumber(cfDict, "Length");
+          if (len === void 0) continue;
+          return len < 40 ? len * 8 : len;
+        }
+        return void 0;
+      };
+      const keyLenBits = cryptFilterLengthBits() ?? dictNumber(encDict, "Length") ?? 128;
+      fileKey = legacyAuthenticateEmptyPassword({
+        revision: R,
+        keyLen: keyLenBits / 8,
+        O,
+        U,
+        P,
+        id0,
+        encryptMetadata
+      });
+    }
+    const cipherFor = (cfm) => {
+      if (!cfm || cfm === pdfLib.PDFName.of("Identity")) return identityCipher;
+      if (cfm === pdfLib.PDFName.of("V2")) return rc4ObjectCipher(fileKey);
+      if (cfm === pdfLib.PDFName.of("AESV2")) return aes128ObjectCipher(fileKey);
+      if (cfm === pdfLib.PDFName.of("AESV3")) return aes256ObjectCipher(fileKey);
+      throw new UnsupportedPdfEncryptionError(`crypt filter method ${cfm.toString()}`);
+    };
+    return {
+      streamCipher: cipherFor(cfmOf("StmF")),
+      stringCipher: cipherFor(cfmOf("StrF")),
+      encryptMetadata
+    };
+  }
+  throw new UnsupportedPdfEncryptionError(`/V ${V}`);
+}
+var toHexString = (bytes) => {
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) hex += bytes[i].toString(16).padStart(2, "0");
+  return new pdfLib.PDFHexString(hex.toUpperCase());
+};
+function filterIncludesCrypt(dict) {
+  const filter = dict.lookup(pdfLib.PDFName.of("Filter"));
+  if (filter === pdfLib.PDFName.of("Crypt")) return true;
+  if (filter instanceof pdfLib.PDFArray) {
+    for (let i = 0; i < filter.size(); i++) {
+      if (filter.get(i) === pdfLib.PDFName.of("Crypt")) return true;
+    }
+  }
+  return false;
+}
+function cryptFilterIsIdentity(dict) {
+  const parms = dict.lookup(pdfLib.PDFName.of("DecodeParms")) ?? dict.lookup(pdfLib.PDFName.of("DP"));
+  const identityParms = (p) => {
+    if (!(p instanceof pdfLib.PDFDict)) return true;
+    const name = p.lookup(pdfLib.PDFName.of("Name"));
+    return !(name instanceof pdfLib.PDFName) || name === pdfLib.PDFName.of("Identity");
+  };
+  if (parms instanceof pdfLib.PDFArray) {
+    for (let i = 0; i < parms.size(); i++) {
+      if (!identityParms(parms.lookup(i))) return false;
+    }
+    return true;
+  }
+  return identityParms(parms);
+}
+async function decryptStringsWithin(obj, ref, stringCipher) {
+  if (obj instanceof pdfLib.PDFDict) {
+    const isSignature = obj.lookup(pdfLib.PDFName.of("Type")) === pdfLib.PDFName.of("Sig");
+    for (const [key, value] of obj.entries()) {
+      if (value instanceof pdfLib.PDFString || value instanceof pdfLib.PDFHexString) {
+        if (isSignature && key === pdfLib.PDFName.of("Contents")) continue;
+        obj.set(key, toHexString(await stringCipher(value.asBytes(), ref)));
+      } else {
+        await decryptStringsWithin(value, ref, stringCipher);
+      }
+    }
+  } else if (obj instanceof pdfLib.PDFArray) {
+    for (let i = 0; i < obj.size(); i++) {
+      const value = obj.get(i);
+      if (value instanceof pdfLib.PDFString || value instanceof pdfLib.PDFHexString) {
+        obj.set(i, toHexString(await stringCipher(value.asBytes(), ref)));
+      } else {
+        await decryptStringsWithin(value, ref, stringCipher);
+      }
+    }
+  }
+}
+async function decryptLoadedDocument(doc) {
+  const context = doc.context;
+  const encryptRef = context.trailerInfo.Encrypt;
+  const encDict = context.lookup(encryptRef);
+  if (!(encDict instanceof pdfLib.PDFDict)) {
+    throw new UnsupportedPdfEncryptionError("malformed /Encrypt dictionary");
+  }
+  const idArray = context.lookup(context.trailerInfo.ID);
+  const idFirst = idArray instanceof pdfLib.PDFArray ? idArray.get(0) : void 0;
+  const id0 = idFirst instanceof pdfLib.PDFString || idFirst instanceof pdfLib.PDFHexString ? idFirst.asBytes() : new Uint8Array(0);
+  const { stringCipher, streamCipher, encryptMetadata } = await buildDocumentCiphers(encDict, id0);
+  for (const [ref, obj] of context.enumerateIndirectObjects()) {
+    if (!(obj instanceof pdfLib.PDFInvalidObject)) continue;
+    const raw = new Uint8Array(obj.sizeInBytes());
+    obj.copyBytesInto(raw, 0);
+    try {
+      const parsed = pdfLib.PDFObjectParser.forBytes(raw, context).parseObject();
+      if (parsed instanceof pdfLib.PDFRawStream && parsed.dict.lookup(pdfLib.PDFName.of("Type")) === pdfLib.PDFName.of("ObjStm")) {
+        context.assign(ref, parsed);
+      }
+    } catch {
+    }
+  }
+  const decryptedObjectStreams = [];
+  const structuralStreamRefs = [];
+  for (const [ref, obj] of context.enumerateIndirectObjects()) {
+    if (ref === encryptRef || obj === encDict) continue;
+    if (obj instanceof pdfLib.PDFRawStream) {
+      const type = obj.dict.lookup(pdfLib.PDFName.of("Type"));
+      if (type === pdfLib.PDFName.of("XRef")) {
+        structuralStreamRefs.push(ref);
+        continue;
+      }
+      const isSkippedMetadata = !encryptMetadata && type === pdfLib.PDFName.of("Metadata");
+      if (filterIncludesCrypt(obj.dict)) {
+        if (!cryptFilterIsIdentity(obj.dict)) {
+          throw new UnsupportedPdfEncryptionError("stream-specific /Crypt filter");
+        }
+      } else if (!isSkippedMetadata) {
+        const decrypted = await streamCipher(obj.contents, ref);
+        const replacement = pdfLib.PDFRawStream.of(obj.dict, decrypted);
+        context.assign(ref, replacement);
+        if (type === pdfLib.PDFName.of("ObjStm")) {
+          decryptedObjectStreams.push([ref, replacement]);
+        }
+      }
+      await decryptStringsWithin(obj.dict, ref, stringCipher);
+    } else if (obj instanceof pdfLib.PDFString || obj instanceof pdfLib.PDFHexString) {
+      context.assign(ref, toHexString(await stringCipher(obj.asBytes(), ref)));
+    } else {
+      await decryptStringsWithin(obj, ref, stringCipher);
+    }
+  }
+  for (const [ref, stream] of decryptedObjectStreams) {
+    await pdfLib.PDFObjectStreamParser.forStream(stream).parseIntoContext();
+    context.delete(ref);
+  }
+  for (const ref of structuralStreamRefs) context.delete(ref);
+  delete context.trailerInfo.Encrypt;
+  if (encryptRef instanceof pdfLib.PDFRef) context.delete(encryptRef);
+  return doc.save({
+    useObjectStreams: false,
+    addDefaultPage: false,
+    updateFieldAppearances: false
+  });
+}
+async function decryptPdf(pdfBytes) {
+  const doc = await pdfLib.PDFDocument.load(pdfBytes.slice(), {
+    ignoreEncryption: true,
+    updateMetadata: false
+  });
+  if (!doc.isEncrypted) return pdfBytes;
+  return decryptLoadedDocument(doc);
+}
+var SLASH = 47;
+var HASH = 35;
+var ENCRYPT_NAME = "Encrypt";
+function hexDigit(byte) {
+  if (byte === void 0) return -1;
+  if (byte >= 48 && byte <= 57) return byte - 48;
+  if (byte >= 65 && byte <= 70) return byte - 65 + 10;
+  if (byte >= 97 && byte <= 102) return byte - 97 + 10;
+  return -1;
+}
+function matchesEncryptNameAt(bytes, start) {
+  let at = start;
+  for (let k = 0; k < ENCRYPT_NAME.length; k++) {
+    const want = ENCRYPT_NAME.charCodeAt(k);
+    const byte = bytes[at];
+    if (byte === want) {
+      at += 1;
+      continue;
+    }
+    if (byte === HASH) {
+      const high = hexDigit(bytes[at + 1]);
+      const low = hexDigit(bytes[at + 2]);
+      if (high >= 0 && low >= 0 && (high << 4 | low) === want) {
+        at += 3;
+        continue;
+      }
+    }
+    return false;
+  }
+  return true;
+}
+function containsEncryptMarker(bytes) {
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] !== SLASH) continue;
+    if (matchesEncryptNameAt(bytes, i + 1)) return true;
+  }
+  return false;
+}
+async function normalizePdfEncryption(pdfBytes, options) {
+  if (!containsEncryptMarker(pdfBytes)) return pdfBytes;
+  const doc = await pdfLib.PDFDocument.load(pdfBytes.slice(), {
+    ignoreEncryption: true,
+    updateMetadata: false
+  });
+  if (!doc.isEncrypted) return pdfBytes;
+  options?.logger?.info("[PDF_DECRYPT] Encrypted PDF detected during ingestion; decrypting");
+  return decryptLoadedDocument(doc);
+}
+
+// src/utils/pdf-decrypt.ts
+var PdfPasswordRequiredError2 = PdfPasswordRequiredError;
+var UnsupportedPdfEncryptionError2 = UnsupportedPdfEncryptionError;
+var decryptPdf2 = decryptPdf;
+var consoleLogger = {
+  info(message, ...args) {
+    if (typeof process === "undefined" || process.env?.NODE_ENV !== "production") {
+      console.info(`[PageAssembler] ${message}`, ...args);
+    }
+  }
+};
+function normalizePdfEncryption2(pdfBytes) {
+  return normalizePdfEncryption(pdfBytes, { logger: consoleLogger });
+}
+
+// src/utils/pdf-helpers.ts
 if (typeof window !== "undefined") {
   pdfjsLib__namespace.GlobalWorkerOptions.workerSrc = "/pdfjs/build/pdf.worker.mjs";
 }
@@ -647,6 +1271,68 @@ async function pdfToImages(pdfBytes, options) {
     throw error;
   }
 }
+var MAX_RASTER_PAGE_COUNT = 500;
+var MAX_RASTER_CANVAS_PIXELS = 4096 * 4096;
+var PREFERRED_RASTER_SCALE = 2;
+function computeRasterScale(width, height) {
+  const area = width * height;
+  if (!Number.isFinite(area) || area <= 0) return PREFERRED_RASTER_SCALE;
+  const preferredPixels = area * PREFERRED_RASTER_SCALE * PREFERRED_RASTER_SCALE;
+  if (preferredPixels <= MAX_RASTER_CANVAS_PIXELS) return PREFERRED_RASTER_SCALE;
+  return Math.sqrt(MAX_RASTER_CANVAS_PIXELS / area);
+}
+async function rasterizePdfToPdf(pdfBytes) {
+  if (typeof window !== "undefined") {
+    pdfjsLib__namespace.GlobalWorkerOptions.workerSrc = "/pdfjs/build/pdf.worker.mjs";
+  }
+  let sourceDoc;
+  try {
+    sourceDoc = await pdfjsLib__namespace.getDocument({ data: pdfBytes.slice(0), verbosity: 0 }).promise;
+  } catch (error) {
+    if (error?.name === "PasswordException") {
+      throw new PdfPasswordRequiredError2();
+    }
+    throw error;
+  }
+  try {
+    if (sourceDoc.numPages > MAX_RASTER_PAGE_COUNT) {
+      throw new Error(
+        `Cannot rebuild PDF: ${sourceDoc.numPages} pages exceeds the ${MAX_RASTER_PAGE_COUNT}-page limit`
+      );
+    }
+    const outDoc = await pdfLib.PDFDocument.create();
+    for (let pageNum = 1; pageNum <= sourceDoc.numPages; pageNum++) {
+      const page = await sourceDoc.getPage(pageNum);
+      const base = page.getViewport({ scale: 1 });
+      const scale = computeRasterScale(base.width, base.height);
+      const viewport = page.getViewport({ scale });
+      const canvas = document.createElement("canvas");
+      canvas.width = viewport.width;
+      canvas.height = viewport.height;
+      const context = canvas.getContext("2d");
+      await page.render({ canvasContext: context, viewport }).promise;
+      const png = await outDoc.embedPng(canvas.toDataURL("image/png"));
+      const outPage = outDoc.addPage([base.width, base.height]);
+      outPage.drawImage(png, { x: 0, y: 0, width: base.width, height: base.height });
+    }
+    return new Uint8Array(await outDoc.save({ useObjectStreams: false }));
+  } finally {
+    await sourceDoc.destroy();
+  }
+}
+async function normalizeUploadedPdfBytes(pdfBytes) {
+  try {
+    const normalized = await normalizePdfEncryption2(pdfBytes);
+    return normalized === pdfBytes ? pdfBytes : new Uint8Array(normalized);
+  } catch (error) {
+    if (error instanceof PdfPasswordRequiredError2) throw error;
+    console.warn(
+      "[PageAssembler] Structural decryption failed; rebuilding document from rendered pages:",
+      error
+    );
+    return rasterizePdfToPdf(pdfBytes);
+  }
+}
 async function imageToPdf(imageFile) {
   return new Promise((resolve, reject) => {
     const img = new Image();
@@ -722,6 +1408,701 @@ function downloadPdf(pdfBytes, filename) {
   a.click();
   URL.revokeObjectURL(url);
 }
+var KEY = "SigniphiMetadata";
+function readMetadata(doc, pdfLib) {
+  let blockPresent = false;
+  try {
+    const infoRef = doc.context.trailerInfo.Info;
+    if (!infoRef) return { metadata: null, blockPresent };
+    const info = doc.context.lookup(infoRef);
+    if (!info || typeof info.get !== "function") return { metadata: null, blockPresent };
+    const value = info.get(pdfLib.PDFName.of(KEY));
+    if (!value) return { metadata: null, blockPresent };
+    blockPresent = true;
+    const json = typeof value.decodeText === "function" ? value.decodeText() : stripDelimiters(value.toString());
+    return { metadata: JSON.parse(json), blockPresent };
+  } catch {
+    return { metadata: null, blockPresent };
+  }
+}
+function writeMetadata(doc, metadata, pdfLib) {
+  const info = doc.context.lookup(doc.context.trailerInfo.Info);
+  if (!info || typeof info.set !== "function") {
+    throw new Error("Cannot write SigniphiMetadata: the PDF has no Info dictionary");
+  }
+  info.set(pdfLib.PDFName.of(KEY), pdfLib.PDFHexString.fromText(JSON.stringify(metadata)));
+}
+function stripDelimiters(raw) {
+  const wrapped = raw.startsWith("(") && raw.endsWith(")") || raw.startsWith("<") && raw.endsWith(">");
+  return wrapped ? raw.slice(1, -1) : raw;
+}
+function textLabelPlacements(source) {
+  const fields = source.metadata?.fields;
+  if (!fields || !source.pages?.length) return [];
+  const out = [];
+  for (const [name, entry] of Object.entries(fields)) {
+    if (entry.type !== "text_label" || !entry.position) continue;
+    for (const { source: page, combined } of source.pages) {
+      if (page === entry.position.page) out.push({ name, page: combined });
+    }
+  }
+  return out;
+}
+function toCombinedPage(entry, page) {
+  if (!entry.position && !entry.radioPositions && !entry.radioOptions) return entry;
+  const carried = { ...entry };
+  if (entry.position) carried.position = { ...entry.position, page };
+  if (entry.radioPositions) carried.radioPositions = entry.radioPositions.map((p) => ({ ...p, page }));
+  if (entry.radioOptions) {
+    carried.radioOptions = entry.radioOptions.map((o) => ({ ...o, position: { ...o.position, page } }));
+  }
+  return carried;
+}
+function assembleMetadata(sources) {
+  const merged = { version: "1.0", fields: {}, fieldIdIndex: {} };
+  let radioLabelsBaked;
+  let textLabelsBaked;
+  let checkboxLabelsBaked;
+  let legacyRadioStripped;
+  for (const source of sources) {
+    const meta = source.metadata;
+    if (!meta || source.fields.length === 0 && !source.pages?.length) continue;
+    if (meta.radioLabelsBaked === false) radioLabelsBaked = false;
+    else if (meta.radioLabelsBaked === true && radioLabelsBaked === void 0) radioLabelsBaked = true;
+    if (meta.textLabelsBaked === false) textLabelsBaked = false;
+    else if (meta.textLabelsBaked === true && textLabelsBaked === void 0) textLabelsBaked = true;
+    if (meta.checkboxLabelsBaked === false) checkboxLabelsBaked = false;
+    else if (meta.checkboxLabelsBaked === true && checkboxLabelsBaked === void 0) checkboxLabelsBaked = true;
+    legacyRadioStripped = meta.legacyRadioStripped === true && legacyRadioStripped !== false;
+  }
+  for (const source of sources) {
+    const meta = source.metadata;
+    if (!meta) continue;
+    const sourceTextLabelsBaked = meta.textLabelsBaked !== false;
+    for (const { name, page } of [...source.fields, ...textLabelPlacements(source)]) {
+      const key = `${name}_p${page}`;
+      const entry = meta.fields?.[name];
+      if (!entry) continue;
+      const carried = toCombinedPage(entry, page);
+      merged.fields[key] = textLabelsBaked === false && sourceTextLabelsBaked ? { ...carried, textLabelBaked: true } : carried;
+      if (entry.fieldId) merged.fieldIdIndex[entry.fieldId] = key;
+    }
+  }
+  if (radioLabelsBaked !== void 0) merged.radioLabelsBaked = radioLabelsBaked;
+  if (textLabelsBaked !== void 0) merged.textLabelsBaked = textLabelsBaked;
+  if (checkboxLabelsBaked !== void 0) merged.checkboxLabelsBaked = checkboxLabelsBaked;
+  if (legacyRadioStripped) merged.legacyRadioStripped = true;
+  const hasEntries = Object.keys(merged.fields).length > 0;
+  const hasMarkers = radioLabelsBaked !== void 0 || textLabelsBaked !== void 0 || checkboxLabelsBaked !== void 0;
+  if (!hasEntries && !hasMarkers) return null;
+  if (Object.keys(merged.fieldIdIndex).length === 0) delete merged.fieldIdIndex;
+  return merged;
+}
+function mergeSourceMetadata(sources) {
+  return assembleMetadata(sources);
+}
+function getSigniphiMetadata(pdfDoc) {
+  const { metadata, blockPresent } = readMetadata(pdfDoc, { PDFName: pdfLib.PDFName });
+  if (blockPresent && !metadata) {
+    console.error("Failed to load Signiphi metadata: the block is present but will not parse");
+  }
+  return metadata;
+}
+function getBaseFieldName(encodedName) {
+  let baseName = encodedName;
+  if (baseName.includes("__SIGNER__")) {
+    baseName = baseName.split("__SIGNER__")[0];
+  }
+  if (baseName.includes("__LABEL__")) {
+    baseName = baseName.split("__LABEL__")[0];
+  }
+  if (baseName.includes("__PLACEHOLDER__")) {
+    baseName = baseName.split("__PLACEHOLDER__")[0];
+  }
+  return baseName;
+}
+function stripFieldTypeSuffix(value) {
+  const stripped = value.replace(/_(signature|initials|date)$/i, "");
+  return stripped || value;
+}
+function getSignerFromFieldName(encodedName) {
+  if (encodedName.includes("__SIGNER__")) {
+    const parts = encodedName.split("__SIGNER__");
+    if (parts[1]) {
+      const segment = parts[1].split("__")[0] || parts[1];
+      const isTerminal = segment === parts[1];
+      return isTerminal ? stripFieldTypeSuffix(segment) : segment;
+    }
+  }
+  return void 0;
+}
+function determineFieldType(fieldName, widgetType) {
+  const baseName = getBaseFieldName(fieldName);
+  const nameLower = baseName.toLowerCase();
+  if (nameLower.includes("_signature") || nameLower.includes("signature")) {
+    return "signature";
+  }
+  if (nameLower.includes("_initials") || nameLower.includes("initials")) {
+    return "initials";
+  }
+  if (nameLower.includes("_date") || nameLower.includes("date")) {
+    return "date";
+  }
+  if (widgetType === "checkbox" || nameLower.includes("checkbox")) {
+    return "checkbox";
+  }
+  if (widgetType === "radio" || nameLower.includes("radio")) {
+    return "radio";
+  }
+  if (widgetType === "dropdown" || widgetType === "select" || nameLower.includes("dropdown")) {
+    return "dropdown";
+  }
+  return "text";
+}
+async function extractFieldsFromPdf(pdfBytes) {
+  const pdfDoc = await pdfLib.PDFDocument.load(pdfBytes);
+  const fields = [];
+  const metadata = getSigniphiMetadata(pdfDoc);
+  const form = pdfDoc.getForm();
+  const pdfFields = form.getFields();
+  const pages = pdfDoc.getPages();
+  const pageHeights = pages.map((p) => p.getHeight());
+  const pageIndexByRef = new Map(pages.map((p, i) => [p.ref, i + 1]));
+  const pageNumberOf = (ref) => ref && pageIndexByRef.get(ref) || 1;
+  for (const field of pdfFields) {
+    const fieldName = field.getName();
+    const widgets = field.acroField.getWidgets();
+    const baseName = getBaseFieldName(fieldName);
+    const signerFromName = getSignerFromFieldName(fieldName);
+    let required = false;
+    let options;
+    let widgetType;
+    if (field instanceof pdfLib.PDFTextField) {
+      required = field.isRequired();
+      console.log(`[field-extraction] PDFTextField "${fieldName}" isRequired=${required}`);
+    } else if (field instanceof pdfLib.PDFCheckBox) {
+      widgetType = "checkbox";
+      required = field.isRequired();
+      console.log(`[field-extraction] PDFCheckBox "${fieldName}" isRequired=${required}`);
+    } else if (field instanceof pdfLib.PDFDropdown) {
+      widgetType = "dropdown";
+      required = field.isRequired();
+      options = field.getOptions();
+      console.log(`[field-extraction] PDFDropdown "${fieldName}" isRequired=${required}`);
+    } else if (field instanceof pdfLib.PDFRadioGroup) {
+      widgetType = "radio";
+      required = field.isRequired();
+      options = field.getOptions();
+      console.log(`[field-extraction] PDFRadioGroup "${fieldName}" isRequired=${required}`);
+    } else {
+      console.log(`[field-extraction] Unknown field type "${fieldName}" - defaulting required=false`);
+    }
+    const optionPositionsByPage = /* @__PURE__ */ new Map();
+    if (widgetType === "radio") {
+      for (const w of widgets) {
+        const pageNumber = pageNumberOf(w.P());
+        const r = w.getRectangle();
+        const top = pageHeights[pageNumber - 1] - r.y - r.height;
+        const bucket = optionPositionsByPage.get(pageNumber) ?? [];
+        bucket.push({ x: r.x, y: top, width: r.width, height: r.height });
+        optionPositionsByPage.set(pageNumber, bucket);
+      }
+    }
+    for (const widget of widgets) {
+      const rect = widget.getRectangle();
+      const pageNumber = pageNumberOf(widget.P());
+      const pageQualifiedKey = `${baseName}_p${pageNumber}`;
+      let fieldMetadata = metadata?.fields?.[pageQualifiedKey];
+      if (!fieldMetadata) {
+        fieldMetadata = metadata?.fields?.[fieldName];
+      }
+      if (!fieldMetadata && baseName !== fieldName) {
+        fieldMetadata = metadata?.fields?.[baseName];
+      }
+      let fieldRequired = required;
+      let fieldOptions = options;
+      if (fieldMetadata?.required !== void 0) {
+        fieldRequired = fieldMetadata.required;
+      }
+      if (fieldMetadata?.options?.length) {
+        fieldOptions = fieldMetadata.options;
+      }
+      const pageHeight = pageHeights[pageNumber - 1];
+      const extractedField = {
+        name: baseName,
+        // Use clean base name without __SIGNER__ encoding (signer stored in signer property)
+        // Uses base name internally. A stored date_signed is a declaration the
+        // name can't express, so it wins.
+        type: fieldMetadata?.type === "date_signed" ? "date_signed" : determineFieldType(fieldName, widgetType),
+        page: pageNumber,
+        x: rect.x,
+        y: pageHeight - rect.y - rect.height,
+        // Convert from PDF coords (bottom-left) to top-left
+        width: rect.width,
+        height: rect.height,
+        required: fieldRequired,
+        options: fieldOptions,
+        signer: signerFromName
+        // Extract signer from encoded name
+      };
+      if (widgetType === "radio") {
+        extractedField.optionPositions = optionPositionsByPage.get(pageNumber) ?? [];
+      }
+      if (fieldMetadata) {
+        if (fieldMetadata.fieldId) {
+          extractedField.fieldId = fieldMetadata.fieldId;
+        }
+        if (fieldMetadata.label) {
+          extractedField.label = fieldMetadata.label;
+        }
+        if (!extractedField.signer && fieldMetadata.signer) {
+          extractedField.signer = fieldMetadata.signer;
+        }
+        if (fieldMetadata.placeholder) {
+          extractedField.placeholder = fieldMetadata.placeholder;
+        }
+      }
+      fields.push(extractedField);
+    }
+  }
+  const deduplicatedFields = fields.reduce((acc, field) => {
+    const newBaseName = getBaseFieldName(field.name);
+    const existingIndex = acc.findIndex((f) => {
+      const existingBaseName = getBaseFieldName(f.name);
+      return existingBaseName === newBaseName && f.page === field.page;
+    });
+    if (existingIndex === -1) {
+      acc.push(field);
+    } else {
+      const existing = acc[existingIndex];
+      acc[existingIndex] = {
+        ...existing,
+        // Prefer non-empty values from either field
+        label: existing.label || field.label,
+        placeholder: existing.placeholder || field.placeholder,
+        required: existing.required || field.required,
+        options: existing.options?.length ? existing.options : field.options,
+        fieldId: existing.fieldId || field.fieldId,
+        // Prefer signer from the field that has it
+        signer: existing.signer || field.signer
+      };
+    }
+    return acc;
+  }, []);
+  return deduplicatedFields;
+}
+function setSigniphiMetadata(pdfDoc, metadata) {
+  try {
+    writeMetadata(pdfDoc, metadata, { PDFName: pdfLib.PDFName, PDFHexString: pdfLib.PDFHexString });
+  } catch (error) {
+    console.error("Failed to set Signiphi metadata:", error);
+    throw error;
+  }
+}
+var SIGNIPHI_CHECKBOX_LABEL_MARKER = "SiPL_Check";
+var RADIO_BORDER_WIDTH = 1;
+var FormFieldType = /* @__PURE__ */ ((FormFieldType2) => {
+  FormFieldType2["TEXT"] = "text";
+  FormFieldType2["SIGNATURE"] = "signature";
+  FormFieldType2["INITIALS"] = "initials";
+  FormFieldType2["DATE"] = "date";
+  FormFieldType2["CHECKBOX"] = "checkbox";
+  FormFieldType2["RADIO"] = "radio";
+  FormFieldType2["DROPDOWN"] = "dropdown";
+  FormFieldType2["TEXT_LABEL"] = "text_label";
+  FormFieldType2["DATE_SIGNED"] = "date_signed";
+  return FormFieldType2;
+})(FormFieldType || {});
+function parseEncodedFieldName(encodedName) {
+  let baseName = encodedName;
+  let label;
+  let signer;
+  if (baseName.includes("__SIGNER__")) {
+    const parts = baseName.split("__SIGNER__");
+    baseName = parts[0];
+    signer = parts[1];
+  }
+  if (baseName.includes("__LABEL__")) {
+    const parts = baseName.split("__LABEL__");
+    baseName = parts[0];
+    label = parts[1];
+  }
+  if (baseName.includes("__PLACEHOLDER__")) {
+    const parts = baseName.split("__PLACEHOLDER__");
+    baseName = parts[0];
+  }
+  return { baseName, label, signer };
+}
+function encodeFieldNameWithSigner(fieldName, signerEmail) {
+  const { baseName, signer: existingSigner } = parseEncodedFieldName(fieldName);
+  const finalSigner = existingSigner || signerEmail;
+  if (!finalSigner) return baseName;
+  return `${baseName}__SIGNER__${finalSigner}`;
+}
+function encodeFieldNameWithLabelAndSigner(fieldName, label, signerEmail) {
+  const { baseName, label: existingLabel, signer: existingSigner } = parseEncodedFieldName(fieldName);
+  const finalLabel = existingLabel || label;
+  const finalSigner = existingSigner || signerEmail;
+  let name = baseName;
+  if (finalLabel && finalLabel.trim()) {
+    name = `${name}__LABEL__${finalLabel.trim()}`;
+  }
+  if (finalSigner) {
+    name = `${name}__SIGNER__${finalSigner}`;
+  }
+  return name;
+}
+async function addFormFieldsToPdf(pdfBytes, formFields, options = {}) {
+  const { removeExistingFields = false, drawLabels = false } = options;
+  const pdfDoc = await pdfLib.PDFDocument.load(pdfBytes);
+  const form = pdfDoc.getForm();
+  const pages = pdfDoc.getPages();
+  if (removeExistingFields) {
+    const existingFields = form.getFields();
+    for (const field of existingFields) {
+      try {
+        const acroField = field.acroField;
+        if (acroField && typeof acroField.getWidgets === "function") {
+          let widgets = acroField.getWidgets();
+          let safetyCounter = 0;
+          const maxIterations = widgets.length + 5;
+          while (widgets.length > 0 && safetyCounter < maxIterations) {
+            try {
+              acroField.removeWidget(widgets.length - 1);
+              widgets = acroField.getWidgets();
+            } catch {
+              break;
+            }
+            safetyCounter++;
+          }
+        }
+        form.removeField(field);
+      } catch (error) {
+        console.warn(`Failed to remove field ${field.getName()}:`, error);
+        try {
+          form.removeField(field);
+        } catch {
+        }
+      }
+    }
+  }
+  const font = await pdfDoc.embedFont(pdfLib.StandardFonts.Helvetica);
+  const bakedCheckboxCaptions = /* @__PURE__ */ new Map();
+  const fieldNamePages = /* @__PURE__ */ new Map();
+  for (const field of formFields) {
+    const baseName = field.name;
+    if (!fieldNamePages.has(baseName)) {
+      fieldNamePages.set(baseName, /* @__PURE__ */ new Set());
+    }
+    fieldNamePages.get(baseName).add(field.position.page);
+  }
+  const conflictingNames = /* @__PURE__ */ new Set();
+  for (const [name, pages2] of fieldNamePages) {
+    if (pages2.size > 1) {
+      conflictingNames.add(name);
+    }
+  }
+  for (const field of formFields) {
+    const pageIndex = field.position.page - 1;
+    if (pageIndex < 0 || pageIndex >= pages.length) {
+      console.warn(`Field ${field.name} references page ${field.position.page} but PDF only has ${pages.length} pages`);
+      continue;
+    }
+    const page = pages[pageIndex];
+    const { height: pageHeight } = page.getSize();
+    const pdfX = field.position.x;
+    const pdfY = pageHeight - field.position.y - field.position.height;
+    const uniqueFieldName = conflictingNames.has(field.name) ? `${field.name}_p${field.position.page}` : field.name;
+    try {
+      const fieldType = typeof field.type === "string" ? field.type : field.type;
+      switch (fieldType) {
+        case "text" /* TEXT */: {
+          const encodedName = encodeFieldNameWithSigner(uniqueFieldName, field.assignedSignerEmail);
+          const textField = form.createTextField(encodedName);
+          textField.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0.5, 0.5, 0.5),
+            backgroundColor: pdfLib.rgb(1, 1, 1)
+          });
+          if (field.label && field.label.trim()) {
+            textField.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+            if (drawLabels) {
+              const fontSize = Math.min(10, field.position.height * 0.4);
+              const labelY = pdfY + field.position.height + 5;
+              page.drawText(field.label, { x: pdfX, y: labelY, size: fontSize, font, color: pdfLib.rgb(0, 0, 0) });
+            }
+          }
+          if (field.defaultValue && field.defaultValue.trim()) {
+            textField.setText(field.defaultValue);
+          }
+          if (field.fontSize && field.fontSize >= 8 && field.fontSize <= 72) {
+            try {
+              textField.setFontSize(field.fontSize);
+            } catch {
+            }
+          }
+          if (field.multiline) {
+            try {
+              textField.enableMultiline();
+            } catch {
+            }
+          }
+          if (field.maxLength && field.maxLength > 0) {
+            try {
+              textField.setMaxLength(field.maxLength);
+            } catch {
+            }
+          }
+          if (field.required) {
+            textField.enableRequired();
+          }
+          break;
+        }
+        case "checkbox" /* CHECKBOX */: {
+          const encodedName = encodeFieldNameWithSigner(uniqueFieldName, field.assignedSignerEmail);
+          const checkBox = form.createCheckBox(encodedName);
+          checkBox.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0.5, 0.5, 0.5),
+            backgroundColor: pdfLib.rgb(1, 1, 1)
+          });
+          if (field.defaultValue === "true" || field.defaultValue === "checked") {
+            checkBox.check();
+          }
+          if (field.required) {
+            checkBox.enableRequired();
+          }
+          if (field.label && field.label.trim()) {
+            try {
+              checkBox.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+            } catch {
+            }
+            if (drawLabels) {
+              const fontSize = Math.max(1, field.position.height * 0.4);
+              const labelX = pdfX + field.position.width + 5;
+              const labelY = pdfY + (field.position.height - fontSize) / 2;
+              page.pushOperators(
+                pdfLib.PDFOperator.of(pdfLib.PDFOperatorNames.BeginMarkedContent, [pdfLib.PDFName.of(SIGNIPHI_CHECKBOX_LABEL_MARKER)])
+              );
+              page.drawText(field.label, { x: labelX, y: labelY, size: fontSize, font, color: pdfLib.rgb(0, 0, 0) });
+              page.pushOperators(pdfLib.PDFOperator.of(pdfLib.PDFOperatorNames.EndMarkedContent));
+              bakedCheckboxCaptions.set(encodedName, field);
+            }
+          }
+          break;
+        }
+        case "signature" /* SIGNATURE */: {
+          const baseWithSuffix = field.name.endsWith("_signature") ? field.name : `${field.name}_signature`;
+          const finalName = conflictingNames.has(field.name) ? `${baseWithSuffix}_p${field.position.page}` : baseWithSuffix;
+          const encodedName = encodeFieldNameWithLabelAndSigner(finalName, field.label, field.assignedSignerEmail);
+          const sigField = form.createTextField(encodedName);
+          sigField.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0, 0, 1),
+            backgroundColor: pdfLib.rgb(0.9, 0.9, 1)
+          });
+          if (field.label && field.label.trim()) {
+            sigField.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+          }
+          sigField.enableReadOnly();
+          if (field.required) {
+            sigField.enableRequired();
+          }
+          break;
+        }
+        case "initials" /* INITIALS */: {
+          const baseWithSuffix = field.name.endsWith("_initials") ? field.name : `${field.name}_initials`;
+          const finalName = conflictingNames.has(field.name) ? `${baseWithSuffix}_p${field.position.page}` : baseWithSuffix;
+          const encodedName = encodeFieldNameWithLabelAndSigner(finalName, field.label, field.assignedSignerEmail);
+          const initField = form.createTextField(encodedName);
+          initField.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0.5, 0, 0.5),
+            backgroundColor: pdfLib.rgb(1, 0.95, 1)
+          });
+          if (field.label && field.label.trim()) {
+            initField.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+          }
+          initField.enableReadOnly();
+          if (field.required) {
+            initField.enableRequired();
+          }
+          break;
+        }
+        // DATE_SIGNED is the same widget; its metadata `type` (carried by the
+        // merge, not by this pass) is what tells pdf-signer to stamp it.
+        case "date" /* DATE */:
+        case "date_signed" /* DATE_SIGNED */: {
+          const baseWithSuffix = field.name.endsWith("_date") ? field.name : `${field.name}_date`;
+          const finalName = conflictingNames.has(field.name) ? `${baseWithSuffix}_p${field.position.page}` : baseWithSuffix;
+          const encodedName = encodeFieldNameWithLabelAndSigner(finalName, field.label, field.assignedSignerEmail);
+          const dateField = form.createTextField(encodedName);
+          dateField.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0, 0.5, 0),
+            backgroundColor: pdfLib.rgb(0.95, 1, 0.95)
+          });
+          if (field.label && field.label.trim()) {
+            dateField.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+          }
+          if (field.required) {
+            dateField.enableRequired();
+          }
+          break;
+        }
+        case "dropdown" /* DROPDOWN */: {
+          const encodedName = encodeFieldNameWithSigner(uniqueFieldName, field.assignedSignerEmail);
+          const dropdown = form.createDropdown(encodedName);
+          dropdown.addToPage(page, {
+            x: pdfX,
+            y: pdfY,
+            width: field.position.width,
+            height: field.position.height,
+            borderColor: pdfLib.rgb(0.5, 0.5, 0.5),
+            backgroundColor: pdfLib.rgb(1, 1, 1)
+          });
+          if (field.options && field.options.length > 0) {
+            dropdown.addOptions(field.options);
+            if (field.defaultValue && field.options.includes(field.defaultValue)) {
+              dropdown.select(field.defaultValue);
+            }
+          }
+          if (field.label && field.label.trim()) {
+            try {
+              dropdown.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+            } catch {
+            }
+            if (drawLabels) {
+              const fontSize = Math.min(10, field.position.height * 0.4);
+              const labelY = pdfY + field.position.height + 5;
+              page.drawText(field.label, { x: pdfX, y: labelY, size: fontSize, font, color: pdfLib.rgb(0, 0, 0) });
+            }
+          }
+          if (field.required) {
+            dropdown.enableRequired();
+          }
+          break;
+        }
+        case "radio" /* RADIO */: {
+          const encodedName = encodeFieldNameWithSigner(uniqueFieldName, field.assignedSignerEmail);
+          const radioGroup = form.createRadioGroup(encodedName);
+          if (field.options && field.options.length > 0 && field.optionPositions?.length === field.options.length) {
+            const optionPositions = field.optionPositions;
+            field.options.forEach((option, index) => {
+              const at = optionPositions[index];
+              radioGroup.addOptionToPage(option, page, {
+                x: at.x + RADIO_BORDER_WIDTH / 2,
+                y: pageHeight - at.y - at.height + RADIO_BORDER_WIDTH / 2,
+                width: at.width - RADIO_BORDER_WIDTH,
+                height: at.height - RADIO_BORDER_WIDTH,
+                borderWidth: RADIO_BORDER_WIDTH,
+                borderColor: pdfLib.rgb(0.5, 0.5, 0.5),
+                backgroundColor: pdfLib.rgb(1, 1, 1)
+              });
+            });
+            if (field.defaultValue && field.options.includes(field.defaultValue)) {
+              radioGroup.select(field.defaultValue);
+            }
+          } else if (field.options && field.options.length > 0) {
+            const optionHeight = Math.min(20, field.position.height / field.options.length);
+            const spacing = field.position.height / field.options.length;
+            field.options.forEach((option, index) => {
+              const optionY = pdfY + field.position.height - (index + 1) * spacing + (spacing - optionHeight) / 2;
+              radioGroup.addOptionToPage(option, page, {
+                x: pdfX,
+                y: optionY,
+                width: optionHeight,
+                height: optionHeight,
+                borderColor: pdfLib.rgb(0.5, 0.5, 0.5),
+                backgroundColor: pdfLib.rgb(1, 1, 1)
+              });
+              if (drawLabels) {
+                const labelX = pdfX + optionHeight + 5;
+                const labelY = optionY + optionHeight / 4;
+                page.drawText(option, { x: labelX, y: labelY, size: 10, font, color: pdfLib.rgb(0, 0, 0) });
+              }
+            });
+            if (field.defaultValue && field.options.includes(field.defaultValue)) {
+              radioGroup.select(field.defaultValue);
+            }
+          }
+          if (field.label && field.label.trim()) {
+            try {
+              radioGroup.acroField.dict.set(pdfLib.PDFName.of("TU"), pdfLib.PDFString.of(field.label));
+            } catch {
+            }
+            if (drawLabels) {
+              const fontSize = 10;
+              const labelY = pdfY + field.position.height + 5;
+              page.drawText(field.label, { x: pdfX, y: labelY, size: fontSize, font, color: pdfLib.rgb(0, 0, 0) });
+            }
+          }
+          if (field.required) {
+            radioGroup.enableRequired();
+          }
+          break;
+        }
+        default:
+          console.warn(`Unknown field type: ${fieldType} for field ${field.name}`);
+      }
+    } catch (error) {
+      console.error(`Error adding field ${field.name}:`, error);
+    }
+  }
+  recordBakedCheckboxCaptions(pdfDoc, bakedCheckboxCaptions);
+  return await pdfDoc.save();
+}
+function recordBakedCheckboxCaptions(pdfDoc, captions) {
+  if (captions.size === 0) return;
+  try {
+    const metadata = getSigniphiMetadata(pdfDoc);
+    if (!metadata) return;
+    metadata.fields ?? (metadata.fields = {});
+    for (const [name, field] of captions) {
+      metadata.fields[name] = {
+        signer: field.assignedSignerEmail,
+        label: field.label,
+        ...metadata.fields[name],
+        checkboxCaptionBaked: true
+      };
+    }
+    setSigniphiMetadata(pdfDoc, metadata);
+  } catch (error) {
+    console.warn("Failed to record baked checkbox captions:", error);
+  }
+}
+function mapFieldPositionsAfterAssembly(fields, pageMapping) {
+  return fields.map((field) => {
+    const mappingKey = String(field.position.page - 1);
+    const newPageNumber = pageMapping.get(mappingKey);
+    if (newPageNumber !== void 0) {
+      return {
+        ...field,
+        position: { ...field.position, page: newPageNumber }
+      };
+    }
+    return field;
+  }).filter((field) => {
+    const mappingKey = String(field.position.page - 1);
+    return pageMapping.has(mappingKey) || pageMapping.size === 0;
+  });
+}
+var VISIBLE_PAGE_ROWS = 2;
 var isMultiSelectModifier = (event) => {
   return event.ctrlKey || event.metaKey;
 };
@@ -977,7 +2358,7 @@ var DraggablePageThumbnail = ({
       ref,
       "data-handler-id": handlerId,
       className: cn(
-        "relative group cursor-pointer border-2 rounded-lg overflow-hidden bg-white transition-all",
+        "relative group cursor-pointer border-2 rounded-lg overflow-hidden bg-card transition-all",
         isDragging && "opacity-50 scale-95",
         isSelected ? "border-primary shadow-md" : "border-gray-200 hover:border-gray-300"
       ),
@@ -1005,7 +2386,7 @@ var DraggablePageThumbnail = ({
                   }
                 },
                 onContextMenu: handleContextMenu,
-                className: "h-4 w-4 rounded border-gray-300 text-primary focus:ring-primary focus:ring-2 bg-white/90 cursor-pointer"
+                className: "h-4 w-4 rounded border-border text-primary focus:ring-primary focus:ring-2 bg-card/90 cursor-pointer"
               }
             )
           }
@@ -1048,21 +2429,48 @@ var ReorderablePageGrid = ({
     newPages.splice(hoverIndex, 0, draggedPage);
     onReorderPages(file.id, newPages);
   }, [file.id, file.pages, onReorderPages]);
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-6 gap-4", children: file.pages.map((page, index) => /* @__PURE__ */ jsxRuntime.jsx(
-    DraggablePageThumbnail,
+  const gridRef = React7.useRef(null);
+  const [maxHeight, setMaxHeight] = React7.useState(void 0);
+  React7.useEffect(() => {
+    const grid = gridRef.current;
+    if (!grid || typeof ResizeObserver === "undefined") return;
+    const measure = () => {
+      const firstThumbnail = grid.firstElementChild;
+      if (!firstThumbnail) return;
+      const rowHeight = firstThumbnail.getBoundingClientRect().height;
+      if (rowHeight <= 0) return;
+      const rowGap = parseFloat(getComputedStyle(grid).rowGap) || 0;
+      setMaxHeight(Math.ceil(rowHeight * VISIBLE_PAGE_ROWS + rowGap * (VISIBLE_PAGE_ROWS - 1)));
+    };
+    measure();
+    const observer = new ResizeObserver(measure);
+    observer.observe(grid);
+    if (grid.firstElementChild) observer.observe(grid.firstElementChild);
+    return () => observer.disconnect();
+  }, [file.pages]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
     {
-      page,
-      fileId: file.id,
-      index,
-      isSelected: selectedPageIds.includes(page.id),
-      onSingleSelect: onSingleSelectPage,
-      onToggleSelect: onTogglePageSelect,
-      onRangeSelect: onRangeSelectPage,
-      movePageInFile,
-      isDraggingPageRef
-    },
-    page.id
-  )) });
+      ref: gridRef,
+      className: "grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-6 gap-4 overflow-y-auto overflow-x-hidden",
+      style: { maxHeight },
+      children: file.pages.map((page, index) => /* @__PURE__ */ jsxRuntime.jsx(
+        DraggablePageThumbnail,
+        {
+          page,
+          fileId: file.id,
+          index,
+          isSelected: selectedPageIds.includes(page.id),
+          onSingleSelect: onSingleSelectPage,
+          onToggleSelect: onTogglePageSelect,
+          onRangeSelect: onRangeSelectPage,
+          movePageInFile,
+          isDraggingPageRef
+        },
+        page.id
+      ))
+    }
+  );
 };
 var FileDropZone = ({
   targetIndex,
@@ -1118,6 +2526,7 @@ var FileCard = ({
   const [newName, setNewName] = React7.useState(file.name);
   const fileSelectedPages = file.pages.filter((p) => selectedPageIds.includes(p.id));
   const allPagesSelected = file.pages.length > 0 && fileSelectedPages.length === file.pages.length;
+  const pendingDropdownAction = React7.useRef(null);
   const [{ isDraggingFile }, dragFile] = reactDnd.useDrag({
     type: DND_TYPES.FILE,
     item: () => {
@@ -1222,23 +2631,38 @@ var FileCard = ({
             ] }) }),
             /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu, { children: [
               /* @__PURE__ */ jsxRuntime.jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(Button, { type: "button", variant: "ghost", size: "sm", className: "hover:bg-gray-100 rounded-lg", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.MoreHorizontal, { className: "h-4 w-4" }) }) }),
-              /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenuContent, { align: "end", className: "w-52", children: [
-                /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenuItem, { onClick: () => setIsRenaming(true), children: [
-                  /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "h-4 w-4 mr-2", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z" }) }),
-                  "Rename File"
-                ] }),
-                /* @__PURE__ */ jsxRuntime.jsxs(
-                  DropdownMenuItem,
-                  {
-                    onClick: () => onRemoveFile(file.id),
-                    className: "text-red-600 hover:text-red-700 hover:bg-red-50 focus:text-red-700 focus:bg-red-50",
-                    children: [
-                      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Trash2, { className: "h-4 w-4 mr-2" }),
-                      "Remove File"
-                    ]
-                  }
-                )
-              ] })
+              /* @__PURE__ */ jsxRuntime.jsxs(
+                DropdownMenuContent,
+                {
+                  align: "end",
+                  className: "w-52",
+                  onCloseAutoFocus: () => {
+                    pendingDropdownAction.current?.();
+                    pendingDropdownAction.current = null;
+                  },
+                  children: [
+                    /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenuItem, { onSelect: () => {
+                      pendingDropdownAction.current = () => setIsRenaming(true);
+                    }, children: [
+                      /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "h-4 w-4 mr-2", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z" }) }),
+                      "Rename File"
+                    ] }),
+                    /* @__PURE__ */ jsxRuntime.jsxs(
+                      DropdownMenuItem,
+                      {
+                        onSelect: () => {
+                          pendingDropdownAction.current = () => onRemoveFile(file.id);
+                        },
+                        className: "text-red-600 hover:text-red-700 hover:bg-red-50 focus:text-red-700 focus:bg-red-50",
+                        children: [
+                          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Trash2, { className: "h-4 w-4 mr-2" }),
+                          "Remove File"
+                        ]
+                      }
+                    )
+                  ]
+                }
+              )
             ] })
           ] })
         ] }) }),
@@ -1290,7 +2714,7 @@ var BulkActionBar = ({
           /* @__PURE__ */ jsxRuntime.jsx(TooltipContent, { children: /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Move selected pages to another file" }) })
         ] }) }),
         /* @__PURE__ */ jsxRuntime.jsxs(Select, { onValueChange: onMovePages, children: [
-          /* @__PURE__ */ jsxRuntime.jsx(SelectTrigger, { id: "move-select", className: "w-48 bg-white", children: /* @__PURE__ */ jsxRuntime.jsx(SelectValue, { placeholder: "Choose file..." }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(SelectTrigger, { id: "move-select", className: "w-48 bg-card", children: /* @__PURE__ */ jsxRuntime.jsx(SelectValue, { placeholder: "Choose file..." }) }),
           /* @__PURE__ */ jsxRuntime.jsx(SelectContent, { children: files.map((file) => /* @__PURE__ */ jsxRuntime.jsx(SelectItem, { value: file.id, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
             file.type === "pdf" ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileText, { className: "h-4 w-4" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Image, { className: "h-4 w-4" }),
             /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: file.name })
@@ -1319,7 +2743,7 @@ var BulkActionBar = ({
           variant: "outline",
           size: "sm",
           onClick: onClearSelection,
-          className: "bg-white",
+          className: "bg-card",
           children: "Clear Selection"
         }
       )
@@ -1347,6 +2771,7 @@ var PageAssembler = React7.forwardRef(
     );
     const [isLoading, setIsLoading] = React7.useState(false);
     const [processingStatus, setProcessingStatus] = React7.useState("");
+    const [uploadError, setUploadError] = React7.useState(null);
     const [showDeleteConfirm, setShowDeleteConfirm] = React7.useState(false);
     const [showRemoveFileConfirm, setShowRemoveFileConfirm] = React7.useState(false);
     const [fileToRemove, setFileToRemove] = React7.useState(null);
@@ -1354,6 +2779,7 @@ var PageAssembler = React7.forwardRef(
     const processedInitialPdfRef = React7.useRef(null);
     const isDraggingPage = React7.useRef(false);
     const onChangeRef = React7.useRef(onChange);
+    const originalBytesCache = React7.useRef(/* @__PURE__ */ new Map());
     const summary = React7.useMemo(() => ({
       totalFiles: state.files.length,
       totalPages: state.files.reduce((sum, file) => sum + file.pages.length, 0)
@@ -1387,6 +2813,7 @@ var PageAssembler = React7.forwardRef(
         } else {
           pdfBytes = new Uint8Array(pdf);
         }
+        pdfBytes = await normalizeUploadedPdfBytes(pdfBytes);
         const defensiveCopy = new Uint8Array(pdfBytes);
         const pages = await pdfToImages(defensiveCopy, { hideFormFields: true });
         if (pages.length === 0) {
@@ -1423,6 +2850,7 @@ var PageAssembler = React7.forwardRef(
             originalFileId: fileId
           }))
         };
+        originalBytesCache.current.set(fileId, originalBytes);
         dispatch({ type: "ADD_FILE", payload: file });
       } catch (error) {
         console.error("Error processing initial PDF:", error);
@@ -1431,8 +2859,9 @@ var PageAssembler = React7.forwardRef(
         setProcessingStatus("");
       }
     }, []);
+    const hasRestorableState = !!initialState && initialState.files.length > 0;
     React7.useEffect(() => {
-      if (initialPdf && !initialState) {
+      if (initialPdf && state.files.length === 0 && !hasRestorableState) {
         const pdfIdentifier = initialPdf instanceof Uint8Array ? `uint8array-${initialPdf.length}-${initialPdf[0]}-${initialPdf[initialPdf.length - 1]}` : `${initialPdf.constructor.name}-${initialPdf.size || initialPdf.byteLength}`;
         if (processedInitialPdfRef.current === pdfIdentifier) {
           return;
@@ -1440,15 +2869,16 @@ var PageAssembler = React7.forwardRef(
         processedInitialPdfRef.current = pdfIdentifier;
         processInitialPdf(initialPdf);
       }
-    }, [initialPdf, initialState, processInitialPdf]);
+    }, [initialPdf, state.files.length, hasRestorableState, processInitialPdf]);
     React7.useEffect(() => {
-      if (initialState) {
+      if (initialState && initialState.files.length > 0) {
         dispatch({ type: "RESET", payload: initialState });
       }
     }, [initialState]);
     const processFiles = React7.useCallback(async (files) => {
       const fileArray = Array.from(files);
       const maxFileSize = (limits?.maxFileSizeMB || 10) * 1024 * 1024;
+      setUploadError(null);
       setIsLoading(true);
       setProcessingStatus(`Processing ${fileArray.length} file${fileArray.length !== 1 ? "s" : ""}...`);
       for (const file of fileArray) {
@@ -1473,8 +2903,9 @@ var PageAssembler = React7.forwardRef(
           if (file.type === "application/pdf") {
             setProcessingStatus(`Processing PDF: ${file.name}`);
             const arrayBuffer = await file.arrayBuffer();
-            const pdfBytes = new Uint8Array(arrayBuffer);
+            const pdfBytes = await normalizeUploadedPdfBytes(new Uint8Array(arrayBuffer));
             fileInfo.originalBytes = new Uint8Array(pdfBytes);
+            originalBytesCache.current.set(fileInfo.id, fileInfo.originalBytes);
             const defensiveCopy = new Uint8Array(pdfBytes);
             const pages = await pdfToImages(defensiveCopy, { hideFormFields: true });
             fileInfo.pages = pages.map((page, index) => ({
@@ -1491,6 +2922,7 @@ var PageAssembler = React7.forwardRef(
             const arrayBuffer = await file.arrayBuffer();
             const imageBytes = new Uint8Array(arrayBuffer);
             fileInfo.originalBytes = new Uint8Array(imageBytes);
+            originalBytesCache.current.set(fileInfo.id, fileInfo.originalBytes);
             const thumbUrl = URL.createObjectURL(file);
             const img = new Image();
             const dimensions = await new Promise((resolve) => {
@@ -1521,6 +2953,11 @@ var PageAssembler = React7.forwardRef(
           dispatch({ type: "ADD_FILE", payload: fileInfo });
         } catch (error) {
           console.error(`Error processing file ${file.name}:`, error);
+          if (error instanceof PdfPasswordRequiredError2) {
+            setUploadError(`${file.name}: ${error.userMessage}`);
+          } else {
+            setUploadError(`Failed to process "${file.name}". The file may be corrupted or unsupported.`);
+          }
         }
       }
       setIsLoading(false);
@@ -1618,21 +3055,207 @@ var PageAssembler = React7.forwardRef(
         setIsLoading(true);
         setProcessingStatus("Assembling PDF...");
         try {
-          const { PDFDocument: PDFDocument2 } = await import('pdf-lib');
-          const combinedDoc = await PDFDocument2.create();
+          const { PDFDocument: PDFDocument5, PDFName: PDFName4 } = await import('pdf-lib');
           const loadedPdfs = /* @__PURE__ */ new Map();
           const fileMap = /* @__PURE__ */ new Map();
+          const pdfFiles = state.files.filter((f) => f.type === "pdf" && f.originalBytes?.length > 0);
+          const imageFiles = state.files.filter((f) => f.type === "image");
+          const isSinglePdfScenario = pdfFiles.length === 1 && imageFiles.length === 0;
           for (const file of state.files) {
             fileMap.set(file.id, file);
             if (file.type === "pdf" && file.originalBytes && file.originalBytes.length > 0) {
               try {
-                const sourcePdf = await PDFDocument2.load(file.originalBytes);
+                const sourcePdf = await PDFDocument5.load(file.originalBytes);
                 loadedPdfs.set(file.id, sourcePdf);
               } catch (error) {
                 console.error(`Error loading PDF for file ${file.id}:`, error);
               }
             }
           }
+          const referencedFileIds = /* @__PURE__ */ new Set();
+          for (const file of state.files) {
+            for (const page of file.pages) {
+              const originalFileId = page.originalFileId || file.id;
+              if (!loadedPdfs.has(originalFileId)) {
+                referencedFileIds.add(originalFileId);
+              }
+            }
+          }
+          for (const fileId of referencedFileIds) {
+            const cachedBytes = originalBytesCache.current.get(fileId);
+            if (cachedBytes && cachedBytes.length > 0) {
+              try {
+                console.log(`[PageAssembler] Loading PDF from cache for deleted file ${fileId}`);
+                const sourcePdf = await PDFDocument5.load(cachedBytes);
+                loadedPdfs.set(fileId, sourcePdf);
+              } catch (error) {
+                console.error(`Error loading cached PDF for file ${fileId}:`, error);
+              }
+            }
+          }
+          console.log("[PageAssembler] Checking single PDF scenario:", {
+            isSinglePdfScenario,
+            pdfFilesCount: pdfFiles.length,
+            imageFilesCount: imageFiles.length
+          });
+          if (isSinglePdfScenario && pdfFiles[0]) {
+            const sourceFile = pdfFiles[0];
+            const sourcePdf = loadedPdfs.get(sourceFile.id);
+            console.log("[PageAssembler] Single PDF check:", {
+              sourcePdfLoaded: !!sourcePdf,
+              pagesCount: sourceFile.pages.length,
+              originalBytesLength: sourceFile.originalBytes?.length
+            });
+            if (sourcePdf) {
+              const desiredPageIndices = sourceFile.pages.map((p) => p.srcIndex);
+              const originalPageCount = sourcePdf.getPageCount();
+              const allPagesFromSameFile = sourceFile.pages.every(
+                (p) => (p.originalFileId || sourceFile.id) === sourceFile.id
+              );
+              const isOriginalOrder = desiredPageIndices.length === originalPageCount && desiredPageIndices.every((idx, i) => idx === i);
+              console.log("[PageAssembler] Original bytes check:", {
+                allPagesFromSameFile,
+                isOriginalOrder,
+                desiredPageIndices,
+                originalPageCount
+              });
+              if (allPagesFromSameFile && isOriginalOrder) {
+                console.log("[PageAssembler] \u2705 Returning ORIGINAL bytes (form fields preserved)");
+                const arrayBuffer2 = sourceFile.originalBytes.buffer.slice(
+                  sourceFile.originalBytes.byteOffset,
+                  sourceFile.originalBytes.byteOffset + sourceFile.originalBytes.byteLength
+                );
+                const blob2 = new Blob([arrayBuffer2], { type: "application/pdf" });
+                return blob2;
+              } else {
+                console.log("[PageAssembler] \u26A0\uFE0F Pages modified, will use copyPages (form fields may be lost)");
+              }
+            }
+          }
+          console.log("[PageAssembler] Starting multi-PDF assembly with field preservation");
+          const allExtractedFields = [];
+          const metadataSources = [];
+          const filePageUsage = /* @__PURE__ */ new Map();
+          for (const file of state.files) {
+            for (const page of file.pages) {
+              const originalFileId = page.originalFileId || file.id;
+              if (!filePageUsage.has(originalFileId)) {
+                filePageUsage.set(originalFileId, /* @__PURE__ */ new Map());
+              }
+              const pageUsage = filePageUsage.get(originalFileId);
+              if (!pageUsage.has(page.srcIndex)) {
+                pageUsage.set(page.srcIndex, []);
+              }
+              pageUsage.get(page.srcIndex).push(page);
+            }
+          }
+          let combinedPageIndex = 0;
+          const pageIdToNewPageNumber = /* @__PURE__ */ new Map();
+          for (const file of state.files) {
+            for (const page of file.pages) {
+              combinedPageIndex++;
+              pageIdToNewPageNumber.set(page.id, combinedPageIndex);
+            }
+          }
+          console.log("[PageAssembler] Page mapping:", Object.fromEntries(pageIdToNewPageNumber));
+          const extractAndMapFields = async (fileId, fileName, pdfBytes2, sourcePdf) => {
+            const sourceMetadata = sourcePdf ? getSigniphiMetadata(sourcePdf) : null;
+            if (sourcePdf && !sourceMetadata) {
+              console.warn(`[PageAssembler] No readable SigniphiMetadata in "${fileName}"`);
+            }
+            const pageUsageForFile = filePageUsage.get(fileId) || /* @__PURE__ */ new Map();
+            const placements = [];
+            const pageLandings = [];
+            for (const [srcIndex, pageInstances] of pageUsageForFile) {
+              for (const pageInstance of pageInstances) {
+                const combined = pageIdToNewPageNumber.get(pageInstance.id);
+                if (combined !== void 0) pageLandings.push({ source: srcIndex + 1, combined });
+              }
+            }
+            metadataSources.push({ metadata: sourceMetadata, fields: placements, pages: pageLandings });
+            console.log(`[PageAssembler] Extracting fields from "${fileName}"`);
+            const extractedFields = await extractFieldsFromPdf(pdfBytes2);
+            console.log(`[PageAssembler] Found ${extractedFields.length} fields in "${fileName}"`);
+            for (const field of extractedFields) {
+              const originalPage = field.page;
+              const srcIndex = originalPage - 1;
+              const pageInstances = pageUsageForFile.get(srcIndex) || [];
+              for (const pageInstance of pageInstances) {
+                const newPageNumber = pageIdToNewPageNumber.get(pageInstance.id);
+                if (newPageNumber !== void 0) {
+                  const trackedField = {
+                    name: field.name,
+                    type: field.type,
+                    position: {
+                      x: field.x,
+                      y: field.y,
+                      width: field.width,
+                      height: field.height,
+                      page: newPageNumber
+                      // Updated to new page number
+                    },
+                    pageId: pageInstance.id,
+                    originalFileId: fileId,
+                    label: field.label,
+                    required: field.required,
+                    options: field.options,
+                    optionPositions: field.optionPositions,
+                    placeholder: field.placeholder,
+                    fieldId: field.fieldId,
+                    assignedSignerEmail: field.signer
+                  };
+                  allExtractedFields.push(trackedField);
+                  console.log(`[PageAssembler] Mapped field "${field.name}" from page ${originalPage} to page ${newPageNumber}`);
+                  placements.push({ name: field.name, page: newPageNumber });
+                }
+              }
+            }
+          };
+          const processedFileIds = /* @__PURE__ */ new Set();
+          for (const file of state.files) {
+            if (file.type !== "pdf" || !file.originalBytes || file.originalBytes.length === 0) continue;
+            try {
+              await extractAndMapFields(file.id, file.name, file.originalBytes, loadedPdfs.get(file.id));
+              processedFileIds.add(file.id);
+            } catch (extractError) {
+              console.error(`Error extracting fields from ${file.name}:`, extractError);
+            }
+          }
+          for (const fileId of referencedFileIds) {
+            if (processedFileIds.has(fileId)) continue;
+            const cachedBytes = originalBytesCache.current.get(fileId);
+            if (cachedBytes && cachedBytes.length > 0) {
+              try {
+                console.log(`[PageAssembler] Extracting fields from cached file ${fileId}`);
+                await extractAndMapFields(fileId, `Cached file ${fileId}`, cachedBytes, loadedPdfs.get(fileId));
+              } catch (extractError) {
+                console.error(`Error extracting fields from cached file ${fileId}:`, extractError);
+              }
+            }
+          }
+          console.log(`[PageAssembler] Total extracted fields: ${allExtractedFields.length}`);
+          console.log(`[PageAssembler] Field names:`, allExtractedFields.map((f) => `${f.name} (page ${f.position.page})`));
+          const combinedDoc = await PDFDocument5.create();
+          const copyOrderBySource = /* @__PURE__ */ new Map();
+          for (const file of state.files) {
+            for (const page of file.pages) {
+              const originalFileId = page.originalFileId || file.id;
+              const sourcePdf = fileMap.get(originalFileId)?.type === "pdf" ? loadedPdfs.get(originalFileId) : void 0;
+              if (!sourcePdf || page.srcIndex < 0 || page.srcIndex >= sourcePdf.getPageCount()) continue;
+              const order = copyOrderBySource.get(originalFileId) ?? [];
+              order.push(page.srcIndex);
+              copyOrderBySource.set(originalFileId, order);
+            }
+          }
+          const copiedPagesBySource = /* @__PURE__ */ new Map();
+          for (const [fileId, order] of copyOrderBySource) {
+            try {
+              copiedPagesBySource.set(fileId, await combinedDoc.copyPages(loadedPdfs.get(fileId), order));
+            } catch (copyError) {
+              console.error(`Error copying pages from ${fileId}:`, copyError);
+              throw new Error(`Failed to copy page: ${copyError instanceof Error ? copyError.message : String(copyError)}`);
+            }
+          }
           for (const file of state.files) {
             if (file.pages.length === 0) continue;
             for (const page of file.pages) {
@@ -1650,18 +3273,21 @@ var PageAssembler = React7.forwardRef(
                 }
                 const sourcePageCount = sourcePdf.getPageCount();
                 if (page.srcIndex >= 0 && page.srcIndex < sourcePageCount) {
+                  const copiedPage = copiedPagesBySource.get(originalFileId).shift();
                   try {
-                    const copiedPages = await combinedDoc.copyPages(sourcePdf, [page.srcIndex]);
-                    copiedPages.forEach((copiedPage) => combinedDoc.addPage(copiedPage));
-                  } catch (copyError) {
-                    console.error(`Error copying page ${page.srcIndex}:`, copyError);
-                    throw new Error(`Failed to copy page: ${copyError instanceof Error ? copyError.message : String(copyError)}`);
+                    const annotsRef = copiedPage.node.get(PDFName4.of("Annots"));
+                    if (annotsRef) {
+                      copiedPage.node.delete(PDFName4.of("Annots"));
+                    }
+                  } catch (annotError) {
+                    console.warn("Could not remove annotations from copied page:", annotError);
                   }
+                  combinedDoc.addPage(copiedPage);
                 }
               } else if (sourceFile.type === "image" && sourceFile.originalFile) {
                 try {
                   const imagePdfBytes = await imageToPdf(sourceFile.originalFile);
-                  const imagePdf = await PDFDocument2.load(imagePdfBytes);
+                  const imagePdf = await PDFDocument5.load(imagePdfBytes);
                   const copiedPages = await combinedDoc.copyPages(imagePdf, [0]);
                   copiedPages.forEach((copiedPage) => combinedDoc.addPage(copiedPage));
                 } catch (imageError) {
@@ -1671,7 +3297,41 @@ var PageAssembler = React7.forwardRef(
               }
             }
           }
-          const pdfBytes = await combinedDoc.save();
+          const mergedMetadata = mergeSourceMetadata(metadataSources);
+          if (mergedMetadata) {
+            try {
+              setSigniphiMetadata(combinedDoc, mergedMetadata);
+            } catch (metadataError) {
+              console.warn("Could not write merged metadata:", metadataError);
+            }
+          } else {
+            console.warn("[PageAssembler] No source metadata survived the merge; the assembled document will read as unprepared downstream");
+          }
+          let pdfBytes = await combinedDoc.save();
+          if (allExtractedFields.length > 0) {
+            console.log(`[PageAssembler] Re-adding ${allExtractedFields.length} fields to combined document`);
+            const fieldsForPdf = allExtractedFields.map((field) => ({
+              name: field.name,
+              type: field.type,
+              position: field.position,
+              label: field.label,
+              required: field.required,
+              options: field.options,
+              optionPositions: field.optionPositions,
+              placeholder: field.placeholder,
+              assignedSignerEmail: field.assignedSignerEmail
+            }));
+            try {
+              pdfBytes = await addFormFieldsToPdf(pdfBytes, fieldsForPdf, {
+                removeExistingFields: true,
+                // Remove any orphaned field references
+                drawLabels: false
+              });
+              console.log("[PageAssembler] \u2705 Successfully re-added form fields to combined PDF");
+            } catch (addFieldsError) {
+              console.error("[PageAssembler] Error re-adding fields:", addFieldsError);
+            }
+          }
           const arrayBuffer = pdfBytes.buffer.slice(pdfBytes.byteOffset, pdfBytes.byteOffset + pdfBytes.byteLength);
           const blob = new Blob([arrayBuffer], { type: "application/pdf" });
           return blob;
@@ -1726,6 +3386,10 @@ var PageAssembler = React7.forwardRef(
         /* @__PURE__ */ jsxRuntime.jsx("div", { className: "animate-spin rounded-full h-4 w-4 border-b-2 border-primary" }),
         /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm", children: processingStatus })
       ] }) }),
+      uploadError && !isLoading && /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-4 border-destructive/50 bg-destructive/5", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { className: "h-4 w-4 text-destructive flex-shrink-0" }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-destructive", children: uploadError })
+      ] }) }),
       /* @__PURE__ */ jsxRuntime.jsx(
         BulkActionBar,
         {
@@ -1860,14 +3524,24 @@ function debounce(func, wait) {
     timeout = setTimeout(() => func(...args), wait);
   });
 }
-var PageAssembler_default = PageAssembler;
 
 exports.Button = Button;
+exports.FormFieldType = FormFieldType;
 exports.PageAssembler = PageAssembler;
+exports.PdfPasswordRequiredError = PdfPasswordRequiredError2;
+exports.UnsupportedPdfEncryptionError = UnsupportedPdfEncryptionError2;
+exports.addFormFieldsToPdf = addFormFieldsToPdf;
 exports.createPdfBlobUrl = createPdfBlobUrl;
-exports.default = PageAssembler_default;
+exports.decryptPdf = decryptPdf2;
 exports.downloadPdf = downloadPdf;
+exports.extractFieldsFromPdf = extractFieldsFromPdf;
+exports.getSigniphiMetadata = getSigniphiMetadata;
 exports.imageToPdf = imageToPdf;
+exports.mapFieldPositionsAfterAssembly = mapFieldPositionsAfterAssembly;
+exports.normalizePdfEncryption = normalizePdfEncryption2;
+exports.normalizeUploadedPdfBytes = normalizeUploadedPdfBytes;
 exports.pdfToImages = pdfToImages;
+exports.rasterizePdfToPdf = rasterizePdfToPdf;
+exports.setSigniphiMetadata = setSigniphiMetadata;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map