@signiphi/page-assembly 0.2.0-beta.1 → 0.2.0-beta.11

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');
@@ -576,6 +574,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 +1262,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 +1399,573 @@ function downloadPdf(pdfBytes, filename) {
   a.click();
   URL.revokeObjectURL(url);
 }
+function getSigniphiMetadata(pdfDoc) {
+  try {
+    const infoRef = pdfDoc.context.trailerInfo.Info;
+    if (!infoRef) {
+      return null;
+    }
+    const infoObj = pdfDoc.context.lookup(infoRef);
+    if (!infoObj || typeof infoObj.get !== "function") {
+      return null;
+    }
+    const infoDict = infoObj;
+    const metadataObj = infoDict.get(pdfLib.PDFName.of("SigniphiMetadata"));
+    if (!metadataObj) {
+      return null;
+    }
+    const metadataStr = metadataObj.toString();
+    let jsonStr = metadataStr;
+    if (metadataStr.startsWith("(") && metadataStr.endsWith(")")) {
+      jsonStr = metadataStr.slice(1, -1);
+    } else if (metadataStr.startsWith("<") && metadataStr.endsWith(">")) {
+      jsonStr = metadataStr.slice(1, -1);
+    }
+    const metadata = JSON.parse(jsonStr);
+    return metadata;
+  } catch (error) {
+    console.error("Failed to load Signiphi metadata:", error);
+    return null;
+  }
+}
+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 getSignerFromFieldName(encodedName) {
+  if (encodedName.includes("__SIGNER__")) {
+    const parts = encodedName.split("__SIGNER__");
+    if (parts[1]) {
+      return parts[1].split("__")[0] || parts[1];
+    }
+  }
+  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();
+  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`);
+    }
+    for (const widget of widgets) {
+      const rect = widget.getRectangle();
+      const pageRef = widget.P();
+      let pageNumber = 1;
+      if (pageRef) {
+        const pages = pdfDoc.getPages();
+        for (let i = 0; i < pages.length; i++) {
+          if (pages[i].ref === pageRef) {
+            pageNumber = i + 1;
+            break;
+          }
+        }
+      }
+      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 page = pdfDoc.getPage(pageNumber - 1);
+      const pageHeight = page.getHeight();
+      const extractedField = {
+        name: baseName,
+        // Use clean base name without __SIGNER__ encoding (signer stored in signer property)
+        type: determineFieldType(fieldName, widgetType),
+        // Uses base name internally
+        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 (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 {
+    const infoRef = pdfDoc.context.trailerInfo.Info;
+    const infoObj = pdfDoc.context.lookup(infoRef);
+    if (!infoObj || typeof infoObj.set !== "function") {
+      throw new Error("Info object is not a PDFDict or does not have set method");
+    }
+    const infoDict = infoObj;
+    const metadataString = JSON.stringify(metadata);
+    infoDict.set(pdfLib.PDFName.of("SigniphiMetadata"), pdfLib.PDFString.of(metadataString));
+  } catch (error) {
+    console.error("Failed to set Signiphi metadata:", error);
+    throw error;
+  }
+}
+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";
+  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 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.min(12, field.position.height * 0.6);
+              const labelX = pdfX + field.position.width + 5;
+              const labelY = pdfY + (field.position.height - fontSize) / 2;
+              page.drawText(field.label, { x: labelX, y: labelY, size: fontSize, font, color: pdfLib.rgb(0, 0, 0) });
+            }
+          }
+          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;
+        }
+        case "date" /* DATE */: {
+          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) {
+            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);
+    }
+  }
+  return await pdfDoc.save();
+}
+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 isMultiSelectModifier = (event) => {
   return event.ctrlKey || event.metaKey;
 };
@@ -1118,6 +2362,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 +2467,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"
+                        ]
+                      }
+                    )
+                  ]
+                }
+              )
             ] })
           ] })
         ] }) }),
@@ -1347,6 +2607,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 +2615,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 +2649,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 +2686,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 +2695,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 +2705,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 +2739,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 +2758,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 +2789,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 +2891,205 @@ 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, PDFString: PDFString4 } = 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) {
+            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 mergedMetadata = {
+            version: "1.0",
+            fields: {},
+            fieldIdIndex: {}
+          };
+          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) => {
+            let sourceMetadata = null;
+            if (sourcePdf) {
+              try {
+                const sourceInfoRef = sourcePdf.context.trailerInfo.Info;
+                if (sourceInfoRef) {
+                  const sourceInfoDict = sourcePdf.context.lookup(sourceInfoRef);
+                  if (sourceInfoDict && typeof sourceInfoDict.get === "function") {
+                    const metadataObj = sourceInfoDict.get(PDFName4.of("SigniphiMetadata"));
+                    if (metadataObj) {
+                      const metadataStr = metadataObj.toString();
+                      let jsonStr = metadataStr;
+                      if (metadataStr.startsWith("(") && metadataStr.endsWith(")")) {
+                        jsonStr = metadataStr.slice(1, -1);
+                      }
+                      sourceMetadata = JSON.parse(jsonStr);
+                    }
+                  }
+                }
+              } catch (metadataError) {
+                console.warn(`Could not read metadata from PDF ${fileName}:`, metadataError);
+              }
+            }
+            console.log(`[PageAssembler] Extracting fields from "${fileName}"`);
+            const extractedFields = await extractFieldsFromPdf(pdfBytes2);
+            console.log(`[PageAssembler] Found ${extractedFields.length} fields in "${fileName}"`);
+            const pageUsageForFile = filePageUsage.get(fileId) || /* @__PURE__ */ new Map();
+            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,
+                    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}`);
+                  const metadataKey = `${field.name}_p${newPageNumber}`;
+                  if (sourceMetadata?.fields?.[field.name]) {
+                    mergedMetadata.fields[metadataKey] = sourceMetadata.fields[field.name];
+                  }
+                  if (sourceMetadata?.fieldIdIndex?.[field.name]) {
+                    mergedMetadata.fieldIdIndex[metadataKey] = sourceMetadata.fieldIdIndex[field.name];
+                  }
+                }
+              }
+            }
+          };
+          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();
           for (const file of state.files) {
             if (file.pages.length === 0) continue;
             for (const page of file.pages) {
@@ -1652,7 +3109,17 @@ var PageAssembler = React7.forwardRef(
                 if (page.srcIndex >= 0 && page.srcIndex < sourcePageCount) {
                   try {
                     const copiedPages = await combinedDoc.copyPages(sourcePdf, [page.srcIndex]);
-                    copiedPages.forEach((copiedPage) => combinedDoc.addPage(copiedPage));
+                    copiedPages.forEach((copiedPage) => {
+                      try {
+                        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);
+                    });
                   } catch (copyError) {
                     console.error(`Error copying page ${page.srcIndex}:`, copyError);
                     throw new Error(`Failed to copy page: ${copyError instanceof Error ? copyError.message : String(copyError)}`);
@@ -1661,7 +3128,7 @@ var PageAssembler = React7.forwardRef(
               } 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,8 +3138,48 @@ var PageAssembler = React7.forwardRef(
               }
             }
           }
-          const pdfBytes = await combinedDoc.save();
-          const blob = new Blob([pdfBytes.buffer], { type: "application/pdf" });
+          if (Object.keys(mergedMetadata.fields).length > 0) {
+            try {
+              const newInfoRef = combinedDoc.context.trailerInfo.Info;
+              if (newInfoRef) {
+                const newInfoDict = combinedDoc.context.lookup(newInfoRef);
+                if (newInfoDict && typeof newInfoDict.set === "function") {
+                  newInfoDict.set(
+                    PDFName4.of("SigniphiMetadata"),
+                    PDFString4.of(JSON.stringify(mergedMetadata))
+                  );
+                }
+              }
+            } catch (metadataError) {
+              console.warn("Could not write merged metadata:", metadataError);
+            }
+          }
+          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,
+              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;
         } catch (error) {
           console.error("Error assembling PDF:", error);
@@ -1686,7 +3193,7 @@ var PageAssembler = React7.forwardRef(
       isBusy: () => isLoading,
       getState: () => state
     }), [state, summary, isLoading]);
-    return /* @__PURE__ */ jsxRuntime.jsx(TooltipProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(reactDnd.DndProvider, { backend: reactDndHtml5Backend.HTML5Backend, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("space-y-6 pb-6", className), children: [
+    return /* @__PURE__ */ jsxRuntime.jsx(TooltipProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(reactDnd.DndProvider, { backend: reactDndHtml5Backend.HTML5Backend, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("space-y-3", className), children: [
       /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
         /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
           /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-medium", children: "Page Assembly" }),
@@ -1725,6 +3232,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,
         {
@@ -1777,9 +3288,9 @@ var PageAssembler = React7.forwardRef(
           ]
         }
       ) : !disableFileUpload && /* @__PURE__ */ jsxRuntime.jsx(
-        Card,
+        "div",
         {
-          className: "p-12 border-dashed border-2 border-gray-300 hover:border-gray-400 transition-colors cursor-pointer",
+          className: "p-12 rounded-lg bg-card text-card-foreground cursor-pointer transition-all border-2 border-dashed border-border hover:border-primary/60 hover:bg-primary/10",
           onClick: handleFileUpload,
           onDrop: handleDrop,
           onDragOver: handleDragOver,
@@ -1859,14 +3370,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