fix: pages-per-sheet.js (N-up combine) silently dropped source PDF's bookmarks

Combining pages onto sheets via PDFDocument.create()+embedPages() never
carried the source's own /Outlines over. Since multiple source pages map
to one output sheet, remap each bookmark to the sheet its source page
landed on (Math.floor((page-1)/count)+1) via the same
readExistingBookmarks/addOutline pattern established in bookmarks.js.

Skipped entirely when the source has zero bookmarks. Verified against the
real vendored pdf-lib: bookmarks correctly remap for both single-per-sheet
and multiple-per-sheet cases, and no /Outlines entry is created when the
source has none.

Author: Antikode

pages-per-sheet.js

@@ -152,6 +152,89 @@ function gridFor(count, orientation) {
   return { sheet, cols, rows };
 }
 
+/**
+ * Reads the source PDF's own top-level /Outlines linked list, if any — combining
+ * pages onto N-up sheets via PDFDocument.create()+embedPages() never carries
+ * /Outlines over, so without this the source's bookmarks are silently dropped.
+ * Only direct [pageRef, ...] /Dest arrays are resolved, matching the same
+ * resolution logic used in bookmarks.js/split-by-bookmarks.js.
+ */
+async function readExistingBookmarks(doc) {
+  const { PDFName } = await getPdfLib();
+  const context = doc.context;
+  const outlinesRef = doc.catalog.get(PDFName.of("Outlines"));
+  if (!outlinesRef) return [];
+  const outlines = context.lookup(outlinesRef);
+  if (!outlines) return [];
+
+  const pageRefs = doc.getPages().map((p) => p.ref);
+  function resolvePage(dest) {
+    if (!dest || typeof dest.get !== "function") return -1;
+    try {
+      const pageRef = dest.get(0);
+      if (!pageRef) return -1;
+      return pageRefs.findIndex(
+        (r) => r.tag === pageRef.tag && r.objectNumber === pageRef.objectNumber
+      );
+    } catch (e) {
+      return -1;
+    }
+  }
+
+  const items = [];
+  let cur = outlines.get(PDFName.of("First"));
+  let guard = 0;
+  while (cur && guard++ < 10000) {
+    const item = context.lookup(cur);
+    if (!item) break;
+    const titleObj = item.get(PDFName.of("Title"));
+    const title = titleObj && titleObj.decodeText ? titleObj.decodeText() : "";
+    const dest = item.get(PDFName.of("Dest"));
+    const pageIndex = resolvePage(dest);
+    if (title && pageIndex >= 0) items.push({ title, page: pageIndex + 1 });
+    cur = item.get(PDFName.of("Next"));
+  }
+  return items;
+}
+
+/**
+ * Builds a flat PDF outline (bookmark) tree from a list of {title, page}
+ * entries via pdf-lib's low-level context API — same construction used in
+ * bookmarks.js. Entries are expected to already point at valid pages in `doc`.
+ */
+async function addOutline(doc, entries) {
+  const { PDFName, PDFString, PDFNumber } = await getPdfLib();
+  const context = doc.context;
+  const sorted = [...entries].sort((a, b) => a.page - b.page);
+
+  const outlineRef = context.nextRef();
+  const itemRefs = sorted.map(() => context.nextRef());
+
+  sorted.forEach((entry, i) => {
+    const page = doc.getPage(entry.page - 1);
+    const dict = {
+      Title: PDFString.of(entry.title),
+      Parent: outlineRef,
+      Dest: context.obj([page.ref, PDFName.of("Fit")]),
+    };
+    if (i > 0) dict.Prev = itemRefs[i - 1];
+    if (i < itemRefs.length - 1) dict.Next = itemRefs[i + 1];
+    context.assign(itemRefs[i], context.obj(dict));
+  });
+
+  context.assign(
+    outlineRef,
+    context.obj({
+      Type: PDFName.of("Outlines"),
+      First: itemRefs[0],
+      Last: itemRefs[itemRefs.length - 1],
+      Count: PDFNumber.of(itemRefs.length),
+    })
+  );
+
+  doc.catalog.set(PDFName.of("Outlines"), outlineRef);
+}
+
 async function nupPdf() {
   const { PDFDocument, degrees } = await getPdfLib();
   const count = currentCount();
@@ -163,6 +246,10 @@ async function nupPdf() {
   // embedPages() discards each page's own /Rotate — capture it before embedding,
   // or a rotated source page (e.g. a phone-scanned PDF) draws sideways on the sheet.
   const srcRotations = srcPages.map((p) => (((p.getRotation().angle % 360) + 360) % 360));
+  // Combining pages onto sheets via embedPages()/addPage() never carries the
+  // source's own bookmarks over — remap each one to the sheet its source page
+  // landed on (many-to-one, since several source pages share one output sheet).
+  const srcBookmarks = await readExistingBookmarks(srcDoc);
   const outDoc = await PDFDocument.create();
   const embedded = await outDoc.embedPages(srcPages);
 
@@ -200,6 +287,14 @@ async function nupPdf() {
     sheetsMade++;
   }
 
+  if (srcBookmarks.length) {
+    const remapped = srcBookmarks.map((b) => ({
+      title: b.title,
+      page: Math.floor((b.page - 1) / count) + 1,
+    }));
+    await addOutline(outDoc, remapped);
+  }
+
   const bytes = await outDoc.save();
   return {
     blob: new Blob([bytes], { type: "application/pdf" }),