@signiphi/page-assembly 0.2.0-beta.8 → 0.2.0-beta.9

package/dist/index.mjs

@@ -2,7 +2,7 @@ import * as React7 from 'react';
 import { forwardRef, useReducer, useState, useRef, useMemo, useEffect, useCallback, useImperativeHandle } from 'react';
 import { DndProvider, useDrop, useDrag } from 'react-dnd';
 import { HTML5Backend } from 'react-dnd-html5-backend';
-import { ChevronDown, ChevronUp, Check, ChevronRight, Circle, Upload, FolderOpen, FileText, Image as Image$1, Trash2, X, MoreHorizontal, GripVertical } from 'lucide-react';
+import { ChevronDown, ChevronUp, Check, ChevronRight, Circle, Upload, X, FolderOpen, FileText, Image as Image$1, Trash2, MoreHorizontal, GripVertical } from 'lucide-react';
 import { Slot } from '@radix-ui/react-slot';
 import { cva } from 'class-variance-authority';
 import { clsx } from 'clsx';
@@ -14,9 +14,11 @@ import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
 import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
 import * as TooltipPrimitive from '@radix-ui/react-tooltip';
 import * as pdfjsLib from 'pdfjs-dist';
-import { PDFDocument, PDFTextField, PDFCheckBox, PDFDropdown, PDFRadioGroup, StandardFonts, rgb, PDFName, PDFString } from 'pdf-lib';
+import { PDFDocument, PDFTextField, PDFCheckBox, PDFDropdown, PDFRadioGroup, StandardFonts, rgb, PDFName, PDFString, PDFDict, PDFArray, PDFHexString, PDFRawStream, PDFRef, PDFBool, PDFNumber, EncryptedPDFError } from 'pdf-lib';
 
-// src/components/PageAssembler.tsx
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 function cn(...inputs) {
   return twMerge(clsx(inputs));
 }
@@ -547,6 +549,528 @@ var TooltipContent = React7.forwardRef(({ className, sideOffset = 4, ...props },
   }
 ));
 TooltipContent.displayName = TooltipPrimitive.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);
+    __publicField(this, "code", "PDF_PASSWORD_REQUIRED");
+    __publicField(this, "recoverable", true);
+    __publicField(this, "userMessage");
+    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";
+  }
+};
+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) => a.length === b.length && a.every((v, i) => v === b[i]);
+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;
+  const { revision, keyLen } = params;
+  let h = md5(PAD);
+  if (revision >= 3) for (let i = 0; i < 50; i++) h = md5(h);
+  const ownerKey = h.slice(0, keyLen);
+  let recovered = params.O.slice(0, 32);
+  if (revision === 2) {
+    recovered = rc4(ownerKey, recovered);
+  } else {
+    for (let i = 19; i >= 0; i--) recovered = rc4(ownerKey.map((b) => b ^ i), recovered);
+  }
+  const viaOwner = legacyFileKey(recovered, params);
+  if (legacyUMatches(viaOwner, params)) return viaOwner;
+  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, O, UE, OE) {
+  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));
+  }
+  const u48 = U.slice(0, 48);
+  const ownerHash = await hash(O.slice(32, 40), u48);
+  if (bytesEqual(ownerHash, O.slice(0, 32))) {
+    const intermediate = await hash(O.slice(40, 48), u48);
+    return aesCbcDecryptNoPad(intermediate, zeroIv, OE.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(PDFName.of(key));
+  return value instanceof PDFNumber ? value.asNumber() : void 0;
+}
+function dictBytes(dict, key) {
+  const value = dict.lookup(PDFName.of(key));
+  return value instanceof PDFString || value instanceof PDFHexString ? value.asBytes() : void 0;
+}
+async function buildDocumentCiphers(encDict, id0) {
+  const filter = encDict.lookup(PDFName.of("Filter"));
+  if (filter !== 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(PDFName.of("EncryptMetadata"));
+  const encryptMetadata = metadataValue instanceof 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(PDFName.of("CF"));
+    const cfmOf = (filterKey) => {
+      const streamFilter = encDict.lookup(PDFName.of(filterKey));
+      if (!(streamFilter instanceof PDFName) || streamFilter === PDFName.of("Identity")) return void 0;
+      if (!(cf instanceof PDFDict)) throw new UnsupportedPdfEncryptionError("missing /CF");
+      const cfDict = cf.lookup(streamFilter);
+      if (!(cfDict instanceof PDFDict)) throw new UnsupportedPdfEncryptionError(`missing crypt filter ${streamFilter.toString()}`);
+      const cfm = cfDict.lookup(PDFName.of("CFM"));
+      return cfm instanceof PDFName ? cfm : void 0;
+    };
+    let fileKey;
+    if (V === 5) {
+      const UE = dictBytes(encDict, "UE");
+      const OE = dictBytes(encDict, "OE");
+      if (!UE || !OE) throw new UnsupportedPdfEncryptionError("missing /UE or /OE");
+      fileKey = await v5AuthenticateEmptyPassword(R, U, O, UE, OE);
+    } else {
+      const keyLen = (dictNumber(encDict, "Length") ?? 40) / 8;
+      fileKey = legacyAuthenticateEmptyPassword({ revision: R, keyLen, O, U, P, id0, encryptMetadata });
+    }
+    const cipherFor = (cfm) => {
+      if (!cfm || cfm === PDFName.of("Identity")) return identityCipher;
+      if (cfm === PDFName.of("V2")) return rc4ObjectCipher(fileKey);
+      if (cfm === PDFName.of("AESV2")) return aes128ObjectCipher(fileKey);
+      if (cfm === 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 PDFHexString(hex.toUpperCase());
+};
+function filterIncludesCrypt(dict) {
+  const filter = dict.lookup(PDFName.of("Filter"));
+  if (filter === PDFName.of("Crypt")) return true;
+  if (filter instanceof PDFArray) {
+    for (let i = 0; i < filter.size(); i++) {
+      if (filter.get(i) === PDFName.of("Crypt")) return true;
+    }
+  }
+  return false;
+}
+async function decryptStringsWithin(obj, ref, stringCipher) {
+  if (obj instanceof PDFDict) {
+    const isSignature = obj.lookup(PDFName.of("Type")) === PDFName.of("Sig");
+    for (const [key, value] of obj.entries()) {
+      if (value instanceof PDFString || value instanceof PDFHexString) {
+        if (isSignature && key === PDFName.of("Contents")) continue;
+        obj.set(key, toHexString(await stringCipher(value.asBytes(), ref)));
+      } else {
+        await decryptStringsWithin(value, ref, stringCipher);
+      }
+    }
+  } else if (obj instanceof PDFArray) {
+    for (let i = 0; i < obj.size(); i++) {
+      const value = obj.get(i);
+      if (value instanceof PDFString || value instanceof 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 PDFDict)) {
+    throw new UnsupportedPdfEncryptionError("malformed /Encrypt dictionary");
+  }
+  const idArray = context.lookup(context.trailerInfo.ID);
+  const idFirst = idArray instanceof PDFArray ? idArray.get(0) : void 0;
+  const id0 = idFirst instanceof PDFString || idFirst instanceof PDFHexString ? idFirst.asBytes() : new Uint8Array(0);
+  const { stringCipher, streamCipher, encryptMetadata } = await buildDocumentCiphers(encDict, id0);
+  for (const [ref, obj] of context.enumerateIndirectObjects()) {
+    if (ref === encryptRef || obj === encDict) continue;
+    if (obj instanceof PDFRawStream) {
+      const type = obj.dict.lookup(PDFName.of("Type"));
+      const isXrefStream = type === PDFName.of("XRef");
+      const isSkippedMetadata = !encryptMetadata && type === PDFName.of("Metadata");
+      if (!isXrefStream && !isSkippedMetadata && !filterIncludesCrypt(obj.dict)) {
+        const decrypted = await streamCipher(obj.contents, ref);
+        context.assign(ref, PDFRawStream.of(obj.dict, decrypted));
+      }
+      await decryptStringsWithin(obj.dict, ref, stringCipher);
+    } else if (obj instanceof PDFString || obj instanceof PDFHexString) {
+      context.assign(ref, toHexString(await stringCipher(obj.asBytes(), ref)));
+    } else {
+      await decryptStringsWithin(obj, ref, stringCipher);
+    }
+  }
+  delete context.trailerInfo.Encrypt;
+  if (encryptRef instanceof PDFRef) context.delete(encryptRef);
+  return doc.save({ useObjectStreams: false });
+}
+async function decryptPdf(pdfBytes) {
+  const doc = await PDFDocument.load(pdfBytes.slice(), {
+    ignoreEncryption: true,
+    updateMetadata: false
+  });
+  if (!doc.isEncrypted) return pdfBytes;
+  return decryptLoadedDocument(doc);
+}
+var ENCRYPT_MARKER = new Uint8Array([47, 69, 110, 99, 114, 121, 112, 116]);
+function containsEncryptMarker(bytes) {
+  const last = bytes.length - ENCRYPT_MARKER.length;
+  outer: for (let i = 0; i <= last; i++) {
+    for (let j = 0; j < ENCRYPT_MARKER.length; j++) {
+      if (bytes[i + j] !== ENCRYPT_MARKER[j]) continue outer;
+    }
+    return true;
+  }
+  return false;
+}
+function isEncryptedPdfError(error) {
+  return error instanceof EncryptedPDFError || error instanceof Error && error.message.includes("is encrypted");
+}
+async function normalizePdfEncryption(pdfBytes) {
+  if (!containsEncryptMarker(pdfBytes)) return pdfBytes;
+  const doc = await PDFDocument.load(pdfBytes.slice(), {
+    ignoreEncryption: true,
+    updateMetadata: false
+  });
+  if (!doc.isEncrypted) return pdfBytes;
+  console.info("[PageAssembler] Encrypted PDF detected during ingestion; decrypting");
+  return decryptLoadedDocument(doc);
+}
+
+// src/utils/pdf-helpers.ts
 if (typeof window !== "undefined") {
   pdfjsLib.GlobalWorkerOptions.workerSrc = "/pdfjs/build/pdf.worker.mjs";
 }
@@ -618,6 +1142,53 @@ async function pdfToImages(pdfBytes, options) {
     throw error;
   }
 }
+async function rasterizePdfToPdf(pdfBytes) {
+  if (typeof window !== "undefined") {
+    pdfjsLib.GlobalWorkerOptions.workerSrc = "/pdfjs/build/pdf.worker.mjs";
+  }
+  let sourceDoc;
+  try {
+    sourceDoc = await pdfjsLib.getDocument({ data: pdfBytes.slice(0), verbosity: 0 }).promise;
+  } catch (error) {
+    if (error?.name === "PasswordException") {
+      throw new PdfPasswordRequiredError();
+    }
+    throw error;
+  }
+  try {
+    const outDoc = await PDFDocument.create();
+    for (let pageNum = 1; pageNum <= sourceDoc.numPages; pageNum++) {
+      const page = await sourceDoc.getPage(pageNum);
+      const viewport = page.getViewport({ scale: 2 });
+      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 pageWidth = viewport.width / 2;
+      const pageHeight = viewport.height / 2;
+      const outPage = outDoc.addPage([pageWidth, pageHeight]);
+      outPage.drawImage(png, { x: 0, y: 0, width: pageWidth, height: pageHeight });
+    }
+    return new Uint8Array(await outDoc.save({ useObjectStreams: false }));
+  } finally {
+    await sourceDoc.destroy();
+  }
+}
+async function normalizeUploadedPdfBytes(pdfBytes) {
+  try {
+    const normalized = await normalizePdfEncryption(pdfBytes);
+    return normalized === pdfBytes ? pdfBytes : new Uint8Array(normalized);
+  } catch (error) {
+    if (error instanceof PdfPasswordRequiredError) 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();
@@ -1901,6 +2472,7 @@ var PageAssembler = forwardRef(
     );
     const [isLoading, setIsLoading] = useState(false);
     const [processingStatus, setProcessingStatus] = useState("");
+    const [uploadError, setUploadError] = useState(null);
     const [showDeleteConfirm, setShowDeleteConfirm] = useState(false);
     const [showRemoveFileConfirm, setShowRemoveFileConfirm] = useState(false);
     const [fileToRemove, setFileToRemove] = useState(null);
@@ -1942,6 +2514,7 @@ var PageAssembler = 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) {
@@ -2006,6 +2579,7 @@ var PageAssembler = forwardRef(
     const processFiles = 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) {
@@ -2030,7 +2604,7 @@ var PageAssembler = 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);
@@ -2080,6 +2654,11 @@ var PageAssembler = forwardRef(
           dispatch({ type: "ADD_FILE", payload: fileInfo });
         } catch (error) {
           console.error(`Error processing file ${file.name}:`, error);
+          if (error instanceof PdfPasswordRequiredError) {
+            setUploadError(`${file.name}: ${error.userMessage}`);
+          } else {
+            setUploadError(`Failed to process "${file.name}". The file may be corrupted or unsupported.`);
+          }
         }
       }
       setIsLoading(false);
@@ -2177,7 +2756,7 @@ var PageAssembler = forwardRef(
         setIsLoading(true);
         setProcessingStatus("Assembling PDF...");
         try {
-          const { PDFDocument: PDFDocument4, PDFName: PDFName3, PDFString: PDFString3 } = await import('pdf-lib');
+          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);
@@ -2187,7 +2766,7 @@ var PageAssembler = forwardRef(
             fileMap.set(file.id, file);
             if (file.type === "pdf" && file.originalBytes && file.originalBytes.length > 0) {
               try {
-                const sourcePdf = await PDFDocument4.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);
@@ -2208,7 +2787,7 @@ var PageAssembler = forwardRef(
             if (cachedBytes && cachedBytes.length > 0) {
               try {
                 console.log(`[PageAssembler] Loading PDF from cache for deleted file ${fileId}`);
-                const sourcePdf = await PDFDocument4.load(cachedBytes);
+                const sourcePdf = await PDFDocument5.load(cachedBytes);
                 loadedPdfs.set(fileId, sourcePdf);
               } catch (error) {
                 console.error(`Error loading cached PDF for file ${fileId}:`, error);
@@ -2292,7 +2871,7 @@ var PageAssembler = forwardRef(
                 if (sourceInfoRef) {
                   const sourceInfoDict = sourcePdf.context.lookup(sourceInfoRef);
                   if (sourceInfoDict && typeof sourceInfoDict.get === "function") {
-                    const metadataObj = sourceInfoDict.get(PDFName3.of("SigniphiMetadata"));
+                    const metadataObj = sourceInfoDict.get(PDFName4.of("SigniphiMetadata"));
                     if (metadataObj) {
                       const metadataStr = metadataObj.toString();
                       let jsonStr = metadataStr;
@@ -2375,7 +2954,7 @@ var PageAssembler = forwardRef(
           }
           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 PDFDocument4.create();
+          const combinedDoc = await PDFDocument5.create();
           for (const file of state.files) {
             if (file.pages.length === 0) continue;
             for (const page of file.pages) {
@@ -2397,9 +2976,9 @@ var PageAssembler = forwardRef(
                     const copiedPages = await combinedDoc.copyPages(sourcePdf, [page.srcIndex]);
                     copiedPages.forEach((copiedPage) => {
                       try {
-                        const annotsRef = copiedPage.node.get(PDFName3.of("Annots"));
+                        const annotsRef = copiedPage.node.get(PDFName4.of("Annots"));
                         if (annotsRef) {
-                          copiedPage.node.delete(PDFName3.of("Annots"));
+                          copiedPage.node.delete(PDFName4.of("Annots"));
                         }
                       } catch (annotError) {
                         console.warn("Could not remove annotations from copied page:", annotError);
@@ -2414,7 +2993,7 @@ var PageAssembler = forwardRef(
               } else if (sourceFile.type === "image" && sourceFile.originalFile) {
                 try {
                   const imagePdfBytes = await imageToPdf(sourceFile.originalFile);
-                  const imagePdf = await PDFDocument4.load(imagePdfBytes);
+                  const imagePdf = await PDFDocument5.load(imagePdfBytes);
                   const copiedPages = await combinedDoc.copyPages(imagePdf, [0]);
                   copiedPages.forEach((copiedPage) => combinedDoc.addPage(copiedPage));
                 } catch (imageError) {
@@ -2431,8 +3010,8 @@ var PageAssembler = forwardRef(
                 const newInfoDict = combinedDoc.context.lookup(newInfoRef);
                 if (newInfoDict && typeof newInfoDict.set === "function") {
                   newInfoDict.set(
-                    PDFName3.of("SigniphiMetadata"),
-                    PDFString3.of(JSON.stringify(mergedMetadata))
+                    PDFName4.of("SigniphiMetadata"),
+                    PDFString4.of(JSON.stringify(mergedMetadata))
                   );
                 }
               }
@@ -2518,6 +3097,10 @@ var PageAssembler = forwardRef(
         /* @__PURE__ */ jsx("div", { className: "animate-spin rounded-full h-4 w-4 border-b-2 border-primary" }),
         /* @__PURE__ */ jsx("span", { className: "text-sm", children: processingStatus })
       ] }) }),
+      uploadError && !isLoading && /* @__PURE__ */ jsx(Card, { className: "p-4 border-destructive/50 bg-destructive/5", children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsx(X, { className: "h-4 w-4 text-destructive flex-shrink-0" }),
+        /* @__PURE__ */ jsx("span", { className: "text-sm text-destructive", children: uploadError })
+      ] }) }),
       /* @__PURE__ */ jsx(
         BulkActionBar,
         {
@@ -2653,6 +3236,6 @@ function debounce(func, wait) {
   });
 }
 
-export { Button, FormFieldType, PageAssembler, addFormFieldsToPdf, createPdfBlobUrl, downloadPdf, extractFieldsFromPdf, getSigniphiMetadata, imageToPdf, mapFieldPositionsAfterAssembly, pdfToImages, setSigniphiMetadata };
+export { Button, FormFieldType, PageAssembler, PdfPasswordRequiredError, UnsupportedPdfEncryptionError, addFormFieldsToPdf, createPdfBlobUrl, decryptPdf, downloadPdf, extractFieldsFromPdf, getSigniphiMetadata, imageToPdf, isEncryptedPdfError, mapFieldPositionsAfterAssembly, normalizePdfEncryption, normalizeUploadedPdfBytes, pdfToImages, rasterizePdfToPdf, setSigniphiMetadata };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map