av6-pdf-engine 2.0.0 → 3.0.0

package/dist/index.mjs

@@ -223,12 +223,11 @@ var processImageBlock = (doc, ctx, block, y, env, ensureSpaceFor, defaultImage)
   const availableWidth = Math.max(env.innerWidth - localLeft - localRight, 1);
   const mt = block.marginTop ?? 0;
   const mb = block.marginBottom ?? 0;
-  const baseY = y ?? ctx.currentY;
-  const startY = baseY + mt;
   const heightNeeded = mt + imgHeight + mb;
   if (y === null) {
     ensureSpaceFor(heightNeeded, env);
   }
+  const startY = (y ?? ctx.currentY) + mt;
   let x = baseLeft;
   if (block.align === "center") {
     x = baseLeft + (availableWidth - imgWidth) / 2;
@@ -304,7 +303,7 @@ var processKeyValueGridBlock = (doc, ctx, styles, block, y, env, computeColumnPi
     ...base,
     style: styleNames
   });
-  const measureTextHeight = (tb, width) => {
+  const measureTextHeight2 = (tb, width) => {
     const fontName = getFontNameForText(tb);
     doc.font(fontName);
     doc.fontSize(tb.fontSize ?? 10);
@@ -337,10 +336,10 @@ var processKeyValueGridBlock = (doc, ctx, styles, block, y, env, computeColumnPi
         const valueStyleNames = item.valueStyle ?? block.valueStyle ?? void 0;
         const keyBase = buildKeyBlock(item);
         const keyResolved = resolveStyled(keyBase, keyStyleNames);
-        const keyHeight = measureTextHeight(keyResolved, colWidth);
+        const keyHeight = measureTextHeight2(keyResolved, colWidth);
         const valueBase = buildValueBlock(item);
         const valueResolved = resolveStyled(valueBase, valueStyleNames);
-        const valueHeight = measureTextHeight(valueResolved, colWidth);
+        const valueHeight = measureTextHeight2(valueResolved, colWidth);
         const rowHeight = keyHeight + keyValueGap + valueHeight;
         colHeight += rowHeight + rowGap;
       }
@@ -360,12 +359,12 @@ var processKeyValueGridBlock = (doc, ctx, styles, block, y, env, computeColumnPi
         const valueStyleNames = item.valueStyle ?? block.valueStyle ?? void 0;
         const keyBase = buildKeyBlock(item);
         const keyResolved = resolveStyled(keyBase, keyStyleNames);
-        const keyHeight = measureTextHeight(keyResolved, keyWidthPx);
+        const keyHeight = measureTextHeight2(keyResolved, keyWidthPx);
         const valueBase = buildValueBlock(item);
         const valueResolved = resolveStyled(valueBase, valueStyleNames);
         const valueXInsideCol = keyWidthPx + (separatorText ? sepBoxWidth + 4 : 4);
         const valueWidth = Math.max(colWidth - valueXInsideCol, 1);
-        const valueHeight = measureTextHeight(valueResolved, valueWidth);
+        const valueHeight = measureTextHeight2(valueResolved, valueWidth);
         const cellHeight = Math.max(keyHeight, valueHeight);
         if (cellHeight > rowHeight) rowHeight = cellHeight;
       }
@@ -393,12 +392,12 @@ var processKeyValueGridBlock = (doc, ctx, styles, block, y, env, computeColumnPi
         const valueStyleNames = item.valueStyle ?? block.valueStyle ?? void 0;
         const keyBlock = buildKeyBlock(item);
         const keyResolved = resolveStyled(keyBlock, keyStyleNames);
-        const keyHeight = measureTextHeight(keyResolved, colWidth);
+        const keyHeight = measureTextHeight2(keyResolved, colWidth);
         drawStyledText(doc, keyResolved, colX, colY, colWidth);
         colY += keyHeight + keyValueGap;
         const valueBlock = buildValueBlock(item);
         const valueResolved = resolveStyled(valueBlock, valueStyleNames);
-        const valueHeight = measureTextHeight(valueResolved, colWidth);
+        const valueHeight = measureTextHeight2(valueResolved, colWidth);
         drawStyledText(doc, valueResolved, colX, colY, colWidth);
         colY += valueHeight + rowGap;
       }
@@ -418,12 +417,12 @@ var processKeyValueGridBlock = (doc, ctx, styles, block, y, env, computeColumnPi
         const valueStyleNames = item.valueStyle ?? block.valueStyle ?? void 0;
         const keyBase = buildKeyBlock(item);
         const keyResolved = resolveStyled(keyBase, keyStyleNames);
-        const keyHeight = measureTextHeight(keyResolved, keyWidthPx);
+        const keyHeight = measureTextHeight2(keyResolved, keyWidthPx);
         const valueBase = buildValueBlock(item);
         const valueResolved = resolveStyled(valueBase, valueStyleNames);
         const valueXInsideCol = keyWidthPx + (separatorText ? sepBoxWidth + 4 : 4);
         const valueWidth = Math.max(colWidth - valueXInsideCol, 1);
-        const valueHeight = measureTextHeight(valueResolved, valueWidth);
+        const valueHeight = measureTextHeight2(valueResolved, valueWidth);
         const cellHeight = Math.max(keyHeight, valueHeight);
         if (cellHeight > rowHeight) rowHeight = cellHeight;
       }
@@ -464,6 +463,149 @@ var processKeyValueGridBlock = (doc, ctx, styles, block, y, env, computeColumnPi
   return endY;
 };
 
+// src/renderer-engine/blocks/list.ts
+var DEFAULT_BULLET = "\u2022";
+var DEFAULT_MARKER_GAP = 6;
+var DEFAULT_ITEM_GAP = 4;
+var MARKER_PADDING = 2;
+var normalizeListItem = (item) => typeof item === "string" ? { text: item } : item;
+var buildTextBlock = (list, item) => ({
+  type: "text",
+  text: item.text ?? "",
+  fontSize: item.fontSize ?? list.fontSize,
+  lineGap: item.lineGap ?? list.lineGap,
+  color: item.color ?? list.color,
+  bold: item.bold,
+  italic: item.italic,
+  underline: item.underline,
+  strike: item.strike,
+  link: item.link,
+  font: item.font,
+  style: item.style ?? list.style
+});
+var getMarker = (list, index) => {
+  if ((list.listStyle ?? "bullet") === "number") {
+    const start = list.start ?? 1;
+    return `${start + index}.`;
+  }
+  return list.bullet ?? DEFAULT_BULLET;
+};
+var applyTextOptions = (doc, tb) => {
+  doc.fontSize(tb.fontSize ?? 10);
+  doc.font(getFontNameForText(tb));
+  if (tb.color) doc.fillColor(tb.color);
+  else doc.fillColor("black");
+};
+var measureTextHeight = (doc, tb, width) => {
+  applyTextOptions(doc, tb);
+  const lineGap = tb.lineGap ?? 4;
+  return doc.heightOfString(tb.text ?? "", { width, lineGap });
+};
+var measureMarkerWidth = (doc, marker, tb) => {
+  applyTextOptions(doc, tb);
+  return doc.widthOfString(marker) + MARKER_PADDING;
+};
+var computeMarkerWidth = (doc, list, items, tbSample) => {
+  if (list.markerWidth !== void 0) return list.markerWidth;
+  let maxW = 0;
+  for (let i = 0; i < items.length; i++) {
+    const marker = getMarker(list, i);
+    const w = measureMarkerWidth(doc, marker, tbSample);
+    if (w > maxW) maxW = w;
+  }
+  return maxW;
+};
+var measureItemHeight = (doc, list, item, index, markerWidth, textWidth, styles) => {
+  const tb = resolveTextBlock(styles, buildTextBlock(list, item));
+  const marker = getMarker(list, index);
+  const markerTb = { ...tb, text: marker, underline: false, strike: false, link: void 0 };
+  const markerH = measureTextHeight(doc, markerTb, markerWidth);
+  const textH = measureTextHeight(doc, tb, textWidth);
+  const lineGap = tb.lineGap ?? 4;
+  return Math.max(markerH, textH) + lineGap;
+};
+var measureListHeight = (doc, styles, block, env) => {
+  const items = (block.items ?? []).map(normalizeListItem);
+  const mt = block.marginTop ?? 0;
+  const mb = block.marginBottom ?? 0;
+  const itemGap = block.itemGap ?? DEFAULT_ITEM_GAP;
+  const markerGap = block.markerGap ?? DEFAULT_MARKER_GAP;
+  if (!items.length) return mt + mb;
+  const localLeft = block.marginLeft ?? 0;
+  const localRight = block.marginRight ?? 0;
+  const innerWidth = Math.max(env.innerWidth - localLeft - localRight, 1);
+  const firstResolved = resolveTextBlock(styles, buildTextBlock(block, items[0]));
+  const markerWidth = computeMarkerWidth(doc, block, items, firstResolved);
+  const textWidth = Math.max(innerWidth - markerWidth - markerGap, 1);
+  let total = mt;
+  for (let i = 0; i < items.length; i++) {
+    total += measureItemHeight(doc, block, items[i], i, markerWidth, textWidth, styles);
+    if (i < items.length - 1) total += itemGap;
+  }
+  return total + mb;
+};
+var drawListText = (doc, tb, x, y, width) => {
+  applyTextOptions(doc, tb);
+  const lineGap = tb.lineGap ?? 4;
+  doc.text(tb.text ?? "", x, y, {
+    width,
+    align: tb.align ?? "left",
+    underline: !!tb.underline,
+    strike: !!tb.strike,
+    link: tb.link,
+    lineGap
+  });
+};
+var processListBlock = (doc, ctx, styles, block, y, env, ensureSpaceFor) => {
+  const items = (block.items ?? []).map(normalizeListItem);
+  const mt = block.marginTop ?? 0;
+  const mb = block.marginBottom ?? 0;
+  const itemGap = block.itemGap ?? DEFAULT_ITEM_GAP;
+  const markerGap = block.markerGap ?? DEFAULT_MARKER_GAP;
+  const localLeft = block.marginLeft ?? 0;
+  const localRight = block.marginRight ?? 0;
+  const xLeft = env.marginLeft + localLeft;
+  const innerWidth = Math.max(env.innerWidth - localLeft - localRight, 1);
+  if (!items.length) {
+    const endY2 = (y ?? ctx.currentY) + mt + mb;
+    if (y === null) ctx.currentY = endY2;
+    return endY2;
+  }
+  const firstResolved = resolveTextBlock(styles, buildTextBlock(block, items[0]));
+  const markerWidth = computeMarkerWidth(doc, block, items, firstResolved);
+  const textX = xLeft + markerWidth + markerGap;
+  const textWidth = Math.max(innerWidth - markerWidth - markerGap, 1);
+  if (y !== null) {
+    let drawY = y + mt;
+    for (let i = 0; i < items.length; i++) {
+      if (i > 0) drawY += itemGap;
+      const tb = resolveTextBlock(styles, buildTextBlock(block, items[i]));
+      const marker = getMarker(block, i);
+      const markerTb = { ...tb, text: marker, underline: false, strike: false, link: void 0 };
+      const itemHeight = measureItemHeight(doc, block, items[i], i, markerWidth, textWidth, styles);
+      drawListText(doc, markerTb, xLeft, drawY, markerWidth);
+      drawListText(doc, tb, textX, drawY, textWidth);
+      drawY += itemHeight;
+    }
+    return drawY + mb;
+  }
+  for (let i = 0; i < items.length; i++) {
+    const leading = i === 0 ? mt : itemGap;
+    const itemHeight = measureItemHeight(doc, block, items[i], i, markerWidth, textWidth, styles);
+    ensureSpaceFor(leading + itemHeight, env);
+    const drawY = ctx.currentY + leading;
+    const tb = resolveTextBlock(styles, buildTextBlock(block, items[i]));
+    const marker = getMarker(block, i);
+    const markerTb = { ...tb, text: marker, underline: false, strike: false, link: void 0 };
+    drawListText(doc, markerTb, xLeft, drawY, markerWidth);
+    drawListText(doc, tb, textX, drawY, textWidth);
+    ctx.currentY = drawY + itemHeight;
+  }
+  const endY = ctx.currentY + mb;
+  ctx.currentY = endY;
+  return endY;
+};
+
 // src/renderer-engine/blocks/line.ts
 var processLineBlock = (doc, ctx, block, y, env, ensureSpaceFor) => {
   const localLeft = block.marginLeft ?? 0;
@@ -472,13 +614,12 @@ var processLineBlock = (doc, ctx, block, y, env, ensureSpaceFor) => {
   const width = Math.max(env.innerWidth - localLeft - localRight, 1);
   const mt = block.marginTop ?? 0;
   const mb = block.marginBottom ?? 0;
-  const baseY = y ?? ctx.currentY;
-  const startY = baseY + mt;
   const lineWidth = block.lineWidth ?? 1;
   const heightNeeded = mt + lineWidth + mb;
   if (y === null) {
     ensureSpaceFor(heightNeeded, env);
   }
+  const startY = (y ?? ctx.currentY) + mt;
   doc.save();
   if (block.color) {
     doc.strokeColor(block.color);
@@ -491,7 +632,99 @@ var processLineBlock = (doc, ctx, block, y, env, ensureSpaceFor) => {
   return newY;
 };
 
+// src/renderer-engine/blocks/shape.ts
+var processShapeBlock = (doc, ctx, block, y, env, ensureSpaceFor) => {
+  const mt = block.marginTop ?? 0;
+  const mb = block.marginBottom ?? 0;
+  const ml = block.marginLeft ?? 0;
+  const mr = block.marginRight ?? 0;
+  const lineWidth = block.lineWidth ?? 1;
+  const width = block.width ?? Math.max(env.innerWidth - ml - mr, 1);
+  const height = block.height ?? lineWidth;
+  const heightNeeded = mt + height + mb;
+  if (y === null) {
+    ensureSpaceFor(heightNeeded, env);
+  }
+  const startY = (y ?? ctx.currentY) + mt;
+  const availableWidth = Math.max(env.innerWidth - ml - mr, 1);
+  let x = env.marginLeft + ml;
+  if (block.align === "center") {
+    x = env.marginLeft + ml + (availableWidth - width) / 2;
+  } else if (block.align === "right") {
+    x = env.marginLeft + ml + availableWidth - width;
+  }
+  const drawY = startY;
+  doc.save();
+  if (typeof block.opacity === "number") {
+    doc.opacity(block.opacity);
+  }
+  doc.lineWidth(lineWidth);
+  if (block.strokeColor) {
+    doc.strokeColor(block.strokeColor);
+  }
+  if (block.fillColor) {
+    doc.fillColor(block.fillColor);
+  }
+  switch (block.shape) {
+    case "rect":
+      doc.rect(x, drawY, width, height);
+      break;
+    case "roundedRect":
+      doc.roundedRect(x, drawY, width, height, block.radius ?? 6);
+      break;
+    case "circle": {
+      const radius = block.radius ?? Math.min(width, height) / 2;
+      doc.circle(x + radius, drawY + radius, radius);
+      break;
+    }
+    case "ellipse":
+      doc.ellipse(x + width / 2, drawY + height / 2, width / 2, height / 2);
+      break;
+    case "line":
+      doc.moveTo(x, drawY).lineTo(x + width, drawY);
+      break;
+    case "polygon":
+      if (block.points?.length) {
+        const [first, ...rest] = block.points;
+        doc.moveTo(x + first.x, drawY + first.y);
+        rest.forEach((point) => {
+          doc.lineTo(x + point.x, drawY + point.y);
+        });
+        doc.closePath();
+      }
+      break;
+    case "path":
+      if (block.path) {
+        const safePath = block.path.trim().replace(/[\n\r\t]+/g, " ").replace(/\s+/g, " ");
+        if (safePath.includes("undefined") || safePath.includes("NaN")) {
+          throw new Error(`Invalid shape path: ${safePath}`);
+        }
+        doc.translate(x, drawY);
+        doc.path(safePath);
+      }
+      break;
+  }
+  if (block.fillColor && block.strokeColor) {
+    doc.fillAndStroke(block.fillColor, block.strokeColor);
+  } else if (block.fillColor) {
+    doc.fill(block.fillColor);
+  } else {
+    doc.stroke();
+  }
+  doc.restore();
+  const newY = startY + height + mb;
+  if (y === null) {
+    ctx.currentY = newY;
+  }
+  return newY;
+};
+
 // src/renderer-engine/blocks/table.ts
+var shouldSkipHeaderOnlyTable = (table, rows) => {
+  const headerRows = table.headerRows ?? 0;
+  if (headerRows <= 0) return false;
+  return rows.length <= headerRows;
+};
 var normalizeSpan = (value) => {
   if (!value || value < 1) return 1;
   return Math.floor(value);
@@ -646,6 +879,9 @@ var measureTableHeight = (doc, table, env, styles, computeColumnPixelWidths2, me
   const localRight = table.marginRight ?? 0;
   const width = Math.max(env.innerWidth - localLeft - localRight, 1);
   const rows = normalizeTableRows(table);
+  if (shouldSkipHeaderOnlyTable(table, rows)) {
+    return 0;
+  }
   const totalCols = table.widths.length;
   const colWidths = computeColumnPixelWidths2(table.widths, width);
   const rowHeights = [];
@@ -722,6 +958,9 @@ var processTableBlock = (doc, ctx, styles, table, y, env, computeColumnPixelWidt
   };
   const headerRows = table.headerRows ?? 0;
   const rows = normalizeTableRows(table);
+  if (shouldSkipHeaderOnlyTable(table, rows)) {
+    return baseY;
+  }
   const buildPlacementAndHeights = (rows2) => {
     const placedRows = [];
     const rowHeights = [];
@@ -1001,12 +1240,12 @@ var drawCellBorder = (doc, border, x, y, width, height) => {
 // src/renderer-engine/blocks/text.ts
 var processTextBlock = (doc, ctx, styles, block, y, env, ensureSpaceFor) => {
   const tb = resolveTextBlock(styles, block);
+  const mt = tb.marginTop ?? 0;
+  const mb = tb.marginBottom ?? 0;
   const localLeft = tb.marginLeft ?? 0;
   const localRight = tb.marginRight ?? 0;
   const xLeft = env.marginLeft + localLeft;
   const width = Math.max(env.innerWidth - localLeft - localRight, 1);
-  const baseY = y ?? ctx.currentY;
-  const startY = baseY;
   doc.fontSize(tb.fontSize ?? 10);
   const isBold = !!tb.bold;
   const isItalic = !!tb.italic;
@@ -1020,11 +1259,12 @@ var processTextBlock = (doc, ctx, styles, block, y, env, ensureSpaceFor) => {
   doc.font(fontName);
   if (tb.color) doc.fillColor(tb.color);
   else doc.fillColor("black");
-  const textHeight = doc.heightOfString(tb.text, { width });
+  const lineGap = tb.lineGap ?? 4;
+  const textHeight = doc.heightOfString(tb.text, { width, lineGap });
   if (y === null) {
-    const gapCheck = tb.lineGap ?? 4;
-    ensureSpaceFor(textHeight + gapCheck, env);
+    ensureSpaceFor(mt + textHeight + lineGap + mb, env);
   }
+  const startY = (y ?? ctx.currentY) + mt;
   doc.text(tb.text, xLeft, startY, {
     width,
     align: tb.align ?? "left",
@@ -1032,414 +1272,82 @@ var processTextBlock = (doc, ctx, styles, block, y, env, ensureSpaceFor) => {
     strike: !!tb.strike,
     link: tb.link
   });
-  const gap = tb.lineGap ?? 4;
-  const newY = startY + textHeight + gap;
+  const newY = doc.y + lineGap + mb;
   if (y === null) ctx.currentY = newY;
   return newY;
 };
 
-// src/renderer-engine/utils/block-renderer.ts
-function createBlockRenderer(deps) {
-  const { doc, ctx, styles, computeColumnPixelWidths: computeColumnPixelWidths2, finishPage: finishPage2, processSignatureBlock, defaultImage } = deps;
-  const bottomLimitForContent = createBottomLimitForContent(doc, ctx);
-  const ensureSpaceFor = createEnsureSpaceFor(ctx, bottomLimitForContent, finishPage2);
-  const measureBlockHeight = createMeasureBlockHeight({
-    doc,
-    styles,
-    computeColumnPixelWidths: computeColumnPixelWidths2
-  });
-  const renderBlock = (block, y, env) => {
-    if (block.visible === false) {
-      return y ?? ctx.currentY;
-    }
-    if ((block.backgroundColor || block.backgroundImage) && block.type !== "pageBreak" && block.type !== "signature") {
-      const startY = y ?? ctx.currentY;
-      const blockHeight = measureBlockHeight(block, env);
-      const opacity = block.backgroundOpacity ?? 1;
-      doc.save();
-      if (block.backgroundColor) {
-        doc.fillOpacity(opacity).rect(env.marginLeft, startY, env.innerWidth, blockHeight).fill(block.backgroundColor);
-        doc.fillOpacity(1);
-      }
-      if (block.backgroundImage) {
-        try {
-          doc.image(block.backgroundImage, env.marginLeft, startY, {
-            width: env.innerWidth,
-            height: blockHeight
-          });
-        } catch (_) {
-        }
-      }
-      doc.restore();
-    }
-    switch (block.type) {
-      case "text":
-        return processTextBlock(doc, ctx, styles, block, y, env, ensureSpaceFor);
-      case "image":
-        return processImageBlock(doc, ctx, block, y, env, ensureSpaceFor, defaultImage);
-      case "qr": {
-        const qb = block;
-        const imageLike = {
-          type: "image",
-          src: qb.src,
-          width: qb.size,
-          height: qb.size,
-          align: qb.align,
-          marginTop: qb.marginTop,
-          marginBottom: qb.marginBottom,
-          marginLeft: qb.marginLeft,
-          marginRight: qb.marginRight
-        };
-        return processImageBlock(doc, ctx, imageLike, y, env, ensureSpaceFor, defaultImage);
-      }
-      case "barcode":
-        return processBarcodeBlock(doc, ctx, block, y, env, ensureSpaceFor);
-      case "line":
-        return processLineBlock(doc, ctx, block, y, env, ensureSpaceFor);
-      case "table":
-        return processTableBlock(
-          doc,
-          ctx,
-          styles,
-          block,
-          y,
-          env,
-          computeColumnPixelWidths2,
-          bottomLimitForContent,
-          finishPage2,
-          (b, blockY, blockEnv) => renderBlock(b, blockY, blockEnv),
-          measureBlockHeight
-        );
-      case "columns":
-        return processColumnsBlock(
-          ctx,
-          block,
-          y,
-          env,
-          computeColumnPixelWidths2,
-          renderBlock,
-          ensureSpaceFor,
-          measureBlockHeight
-        );
-      case "keyValueGrid":
-        return processKeyValueGridBlock(
-          doc,
-          ctx,
-          styles,
-          block,
-          y,
-          env,
-          computeColumnPixelWidths2,
-          ensureSpaceFor
-        );
-      case "signature":
-        if (!env.allowPageBreak) {
-          throw new PdfEngineError({
-            code: "PDF_ERROR_SIGNATURE_NOT_IN_MAIN_FLOW" /* PDF_ERROR_SIGNATURE_NOT_IN_MAIN_FLOW */,
-            message: "Signature block is only allowed in main content flow.",
-            statusCode: 400,
-            details: { blockType: "signature" }
-          });
-        }
-        if (y !== null) {
-          throw new PdfEngineError({
-            code: "PDF_ERROR_SIGNATURE_EXPLICIT_Y_FORBIDDEN" /* PDF_ERROR_SIGNATURE_EXPLICIT_Y_FORBIDDEN */,
-            message: "Signature block must be part of main flow, not drawn at explicit Y.",
-            statusCode: 400,
-            details: { blockType: "signature", y }
-          });
-        }
-        processSignatureBlock(block);
-        return ctx.currentY;
-      case "pageBreak":
-        if (!env.allowPageBreak || ctx.inFooter) {
-          return y ?? ctx.currentY;
-        }
-        finishPage2(true);
-        return ctx.currentY;
-      default:
-        return ctx.currentY;
-    }
-  };
-  const renderBlockArray = (blocks, startY, env) => {
-    let localY = startY;
-    for (const block of blocks) {
-      if (block.visible === false) {
-        continue;
-      }
-      localY = renderBlock(block, localY, env);
-    }
-    return localY;
-  };
-  return {
-    renderBlock,
-    renderBlockArray
-  };
-}
-
-// src/renderer-engine/utils/context.ts
-function createInitialContext(doc) {
-  return {
-    pageNumber: 1,
-    currentY: doc.page.margins.top,
-    signatureBlock: null,
-    signatureTopY: null,
-    signatureHeight: 0,
-    signaturePlaced: false,
-    afterSignature: false,
-    inFooter: false
-  };
-}
-
 // src/renderer-engine/utils/ensure-space.ts
-function createEnsureSpaceFor(ctx, bottomLimitForContent, finishPage2) {
+function createEnsureSpaceFor(ctx, doc, bottomLimitForContent, finishPage2) {
   return (heightNeeded, env) => {
     if (!env.allowPageBreak || ctx.inFooter) return;
     const bottomLimit = bottomLimitForContent();
+    const fullContentHeight = bottomLimit - doc.page.margins.top;
+    if (heightNeeded > fullContentHeight) {
+      console.warn(
+        `[pdf-engine] Block height (${Math.round(heightNeeded)}pt) exceeds page content area (${Math.round(fullContentHeight)}pt). Content will overflow.`
+      );
+    }
     if (ctx.currentY + heightNeeded > bottomLimit) {
       finishPage2(true);
     }
   };
 }
 
-// src/renderer-engine/utils/env.ts
-var contentEnv = (doc) => ({
-  marginLeft: doc.page.margins.left,
-  innerWidth: doc.page.width - doc.page.margins.left - doc.page.margins.right,
-  allowPageBreak: true
+// src/renderer-engine/utils/spacing.ts
+var emptySpacing = () => ({
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0
 });
-
-// src/renderer-engine/utils/finish-page.ts
-function finishPage({
-  addNewPage,
-  doc,
-  def,
-  ctx,
-  footerBandHeight,
-  renderBlockArray,
-  startNewPageLayout
-}) {
-  const mode = def.watermark?.mode;
-  if (def.watermark && watermarkUsesLast(mode)) {
-    const isLast = !addNewPage;
-    drawWatermarkForPage(doc, def.watermark, ctx.pageNumber, isLast);
-  }
-  if (ctx.signatureBlock && ctx.signatureTopY !== null) {
-    const env = contentEnv(doc);
-    drawSignatureBlock(doc, ctx.signatureBlock, ctx.signatureTopY, env, renderBlockArray);
+var resolveSpacing = (value, overrides) => {
+  const result = emptySpacing();
+  if (typeof value === "number") {
+    result.top = value;
+    result.right = value;
+    result.bottom = value;
+    result.left = value;
+  } else if (value) {
+    result.top = value.top ?? 0;
+    result.right = value.right ?? 0;
+    result.bottom = value.bottom ?? 0;
+    result.left = value.left ?? 0;
   }
-  drawFooter(doc, def, ctx, footerBandHeight, renderBlockArray);
-  if (addNewPage) {
-    doc.addPage();
-    ctx.pageNumber += 1;
-    startNewPageLayout();
-  }
-}
-
-// src/renderer-engine/utils/footer.ts
-function normalizeFooter(input, ctx, doc) {
-  if (!input) return null;
-  if (typeof input === "function") {
-    const result = input(ctx.pageNumber, {
-      width: doc.page.width,
-      height: doc.page.height
-    });
-    if (!result) return null;
-    return normalizeFooter(result, ctx, doc);
-  }
-  if (input.blocks && Array.isArray(input.blocks)) {
-    const f = input;
-    return {
-      visible: f.visible,
-      blocks: f.blocks,
-      marginTop: f.marginTop,
-      marginBottom: f.marginBottom,
-      marginLeft: f.marginLeft,
-      marginRight: f.marginRight,
-      backgroundColor: f.backgroundColor,
-      backgroundImage: f.backgroundImage
-    };
-  }
-  if (input.type) {
-    return { blocks: [input] };
-  }
-  if (Array.isArray(input)) {
-    return { blocks: input };
-  }
-  return null;
-}
-function drawFooter(doc, def, ctx, footerBandHeight, renderBlockArray) {
-  const footerConfig = def.footer;
-  if (!footerConfig) return;
-  const layout = normalizeFooter(footerConfig, ctx, doc);
-  if (!layout || !layout.blocks.length) return;
-  if (layout.visible === false) return;
-  const bandHeight = footerBandHeight;
-  if (!bandHeight) return;
-  const { marginTop = 4, backgroundColor, backgroundImage, blocks } = layout;
-  const footerMarginLeft = layout.marginLeft ?? 0;
-  const footerMarginRight = layout.marginRight ?? 0;
-  const contentWidth = doc.page.width - footerMarginLeft - footerMarginRight;
-  const footerEnv = {
-    marginLeft: footerMarginLeft,
-    innerWidth: contentWidth,
-    allowPageBreak: false
-  };
-  const pageHeight = doc.page.height;
-  const bandTop = pageHeight - bandHeight;
-  if (backgroundColor) {
-    doc.save();
-    doc.rect(0, bandTop, doc.page.width, bandHeight).fill(backgroundColor);
-    doc.restore();
-  }
-  if (backgroundImage) {
-    try {
-      doc.image(backgroundImage, 0, bandTop, {
-        width: doc.page.width,
-        height: bandHeight
-      });
-    } catch (e) {
-      console.warn("Failed to load footer background image:", e);
-    }
-  }
-  doc.save();
-  doc.rect(footerMarginLeft, bandTop, contentWidth, bandHeight).clip();
-  doc.translate(0, bandTop);
-  ctx.inFooter = true;
-  const localStartY = marginTop;
-  renderBlockArray(blocks, localStartY, footerEnv);
-  ctx.inFooter = false;
-  doc.restore();
-}
-
-// src/renderer-engine/utils/header.ts
-function drawHeader(doc, def, headerBandHeight, header, renderBlockArray) {
-  if (!header || !header.blocks.length) return;
-  if (header.visible === false) return;
-  if (!headerBandHeight) return;
-  const bandTop = 0;
-  const bandHeight = def.margins.top;
-  const headerMarginLeft = header.marginLeft ?? 0;
-  const headerMarginRight = header.marginRight ?? 0;
-  const contentWidth = doc.page.width - headerMarginLeft - headerMarginRight;
-  const headerEnv = {
-    marginLeft: headerMarginLeft,
-    innerWidth: contentWidth,
-    allowPageBreak: false
-  };
-  if (header.backgroundColor) {
-    doc.save();
-    doc.rect(0, bandTop, doc.page.width, bandHeight).fill(header.backgroundColor);
-    doc.restore();
-  }
-  if (header.backgroundImage) {
-    try {
-      doc.image(header.backgroundImage, 0, bandTop, {
-        width: doc.page.width,
-        height: bandHeight
-      });
-    } catch (e) {
-      console.warn("Failed to load header background image:", e);
-    }
-  }
-  doc.save();
-  doc.rect(headerMarginLeft, bandTop, contentWidth, bandHeight).clip();
-  const startY = bandTop + (header.marginTop ?? 0);
-  renderBlockArray(header.blocks, startY, headerEnv);
-  doc.restore();
-}
-
-// src/renderer-engine/utils/image-loader.ts
-import axios from "axios";
-async function normalizeImageSrc(src, fallback) {
-  if (!src) return fallback ?? src;
-  if (Buffer.isBuffer(src)) return src;
-  if (src.startsWith("data:")) {
-    const commaIdx = src.indexOf(",");
-    if (commaIdx !== -1) {
-      return Buffer.from(src.slice(commaIdx + 1), "base64");
-    }
-  }
-  if (src.startsWith("http://") || src.startsWith("https://")) {
-    try {
-      const res = await axios.get(src, { responseType: "arraybuffer" });
-      return Buffer.from(res.data);
-    } catch (e) {
-      if (fallback !== void 0) {
-        console.warn(`Failed to fetch remote image "${src}", using default image.`);
-        return fallback;
-      }
-      throw toPdfEngineError(e, {
-        code: "PDF_ERROR_IMAGE_FETCH_FAILED" /* PDF_ERROR_IMAGE_FETCH_FAILED */,
-        message: "Failed to fetch remote image for PDF.",
-        statusCode: 422,
-        details: { url: src },
-        retryable: false
-      });
-    }
-  }
-  return src;
-}
-async function materializeImagesInBlocks(blocks, fallback) {
-  const out = [];
-  for (const block of blocks) {
-    const blockAny = block;
-    if (blockAny.backgroundImage) {
-      blockAny.backgroundImage = await normalizeImageSrc(blockAny.backgroundImage, fallback);
-    }
-    if (block.type === "image") {
-      const img = { ...block };
-      img.src = await normalizeImageSrc(img.src, fallback);
-      out.push(img);
-    } else if (block.type === "columns") {
-      out.push({
-        ...block,
-        columns: await Promise.all(block.columns.map((col) => materializeImagesInBlocks(col, fallback)))
-      });
-    } else if (block.type === "signature" && block.blocks) {
-      out.push({
-        ...block,
-        blocks: await materializeImagesInBlocks(block.blocks, fallback)
-      });
-    } else if (block.type === "table") {
-      const tb = block;
-      const newBody = await Promise.all(
-        tb.body.map(
-          async (entry) => {
-            const materializeCell = async (cell) => {
-              if (!cell.blocks?.length) return cell;
-              return { ...cell, blocks: await materializeImagesInBlocks(cell.blocks, fallback) };
-            };
-            if (Array.isArray(entry)) {
-              return await Promise.all(entry.map(materializeCell));
-            }
-            if (entry && typeof entry === "object" && "content" in entry && Array.isArray(entry.content)) {
-              return { ...entry, content: await Promise.all(entry.content.map(materializeCell)) };
-            }
-            return entry;
-          }
-        )
-      );
-      out.push({ ...tb, body: newBody });
-    } else {
-      out.push(block);
-    }
-  }
-  return out;
-}
-
-// src/renderer-engine/utils/layout.ts
-function computeColumnPixelWidths(widths, totalWidth) {
-  let fixedTotal = 0;
-  let starCount = 0;
-  widths.forEach((w) => {
-    if (w === "*") starCount++;
-    else fixedTotal += w;
-  });
-  const remaining = Math.max(totalWidth - fixedTotal, 0);
-  const starWidth = starCount > 0 ? remaining / starCount : 0;
-  return widths.map((w) => w === "*" ? starWidth : w);
-}
+  return {
+    top: overrides?.top ?? result.top,
+    right: overrides?.right ?? result.right,
+    bottom: overrides?.bottom ?? result.bottom,
+    left: overrides?.left ?? result.left
+  };
+};
+var resolveBlockPadding = (block) => {
+  return resolveSpacing(block.padding, {
+    top: block.paddingTop,
+    right: block.paddingRight,
+    bottom: block.paddingBottom,
+    left: block.paddingLeft
+  });
+};
+var resolveHeaderPadding = (header) => {
+  return resolveSpacing(header.padding, {
+    top: header.paddingTop,
+    right: header.paddingRight,
+    bottom: header.paddingBottom,
+    left: header.paddingLeft
+  });
+};
+var resolveFooterPadding = (footer) => {
+  return resolveSpacing(footer.padding, {
+    top: footer.paddingTop,
+    right: footer.paddingRight,
+    bottom: footer.paddingBottom,
+    left: footer.paddingLeft
+  });
+};
+var hasPadding = (padding) => {
+  return padding.top > 0 || padding.right > 0 || padding.bottom > 0 || padding.left > 0;
+};
 
 // src/renderer-engine/utils/styles.ts
 function mergeStyleDefs(styles, names) {
@@ -1535,191 +1443,772 @@ var drawStyledText = (doc, tb, x, y, width) => {
 // src/renderer-engine/utils/measure-block-height.ts
 function createMeasureBlockHeight(deps) {
   const { doc, styles, computeColumnPixelWidths: computeColumnPixelWidths2 } = deps;
-  const measureText = (b, env) => {
-    const tb = resolveTextBlock(styles, b);
-    const width = Math.max(env.innerWidth, 1);
+  const measureText = (block, env) => {
+    const tb = resolveTextBlock(styles, block);
+    const mt = tb.marginTop ?? 0;
+    const mb = tb.marginBottom ?? 0;
+    const localLeft = tb.marginLeft ?? 0;
+    const localRight = tb.marginRight ?? 0;
+    const width = Math.max(env.innerWidth - localLeft - localRight, 1);
     doc.font(getFontNameForText(tb));
     doc.fontSize(tb.fontSize ?? 10);
-    const h = doc.heightOfString(tb.text ?? "", { width });
-    const gap = tb.lineGap ?? 4;
-    return h + gap;
+    const lineGap = tb.lineGap ?? 4;
+    const height = doc.heightOfString(tb.text ?? "", { width, lineGap });
+    return mt + height + lineGap + mb;
   };
-  const measureImageLike = (mt, mb, h) => (mt ?? 0) + h + (mb ?? 0);
-  const measureImage = (b) => {
-    const h = b.height ?? 50;
-    return measureImageLike(b.marginTop, b.marginBottom, h);
+  const measureImage = (block) => {
+    return (block.marginTop ?? 0) + (block.height ?? 50) + (block.marginBottom ?? 0);
   };
-  const measureQr = (b) => {
-    const size = b.size ?? 80;
-    return measureImageLike(b.marginTop, b.marginBottom, size);
+  const measureQr = (block) => {
+    return (block.marginTop ?? 0) + (block.size ?? 80) + (block.marginBottom ?? 0);
   };
-  const measureBarcode = (b) => {
-    const h = b.height ?? 40;
-    return measureImageLike(b.marginTop, b.marginBottom, h);
+  const measureBarcode = (block) => {
+    return (block.marginTop ?? 0) + (block.height ?? 40) + (block.marginBottom ?? 0);
   };
-  const measureLine = (b) => {
-    const lw = b.lineWidth ?? 1;
-    const mt = b.marginTop ?? 0;
-    const mb = b.marginBottom ?? 0;
-    return mt + lw + mb;
+  const measureShape = (block) => {
+    return (block.marginTop ?? 0) + (block.height ?? block.lineWidth ?? 1) + (block.marginBottom ?? 0);
   };
-  const measureTable = (b, env) => {
-    const mt = b.marginTop ?? 0;
-    const mb = b.marginBottom ?? 0;
-    const ml = b.marginLeft ?? 0;
-    const mr = b.marginRight ?? 0;
-    const innerWidth = Math.max(env.innerWidth - ml - mr, 1);
-    const fakeEnv = {
-      marginLeft: 0,
-      innerWidth,
-      allowPageBreak: false
-    };
-    const h = measureTableHeight(doc, b, fakeEnv, styles, computeColumnPixelWidths2, measure);
-    return mt + h + mb;
+  const measureLine = (block) => {
+    return (block.marginTop ?? 0) + (block.lineWidth ?? 1) + (block.marginBottom ?? 0);
   };
-  const measureColumns = (b, env) => {
-    const mt = b.marginTop ?? 0;
-    const mb = b.marginBottom ?? 0;
-    const blockLeft = b.marginLeft ?? 0;
-    const blockRight = b.marginRight ?? 0;
+  const measureColumns = (block, env) => {
+    const mt = block.marginTop ?? 0;
+    const mb = block.marginBottom ?? 0;
+    const blockLeft = block.marginLeft ?? 0;
+    const blockRight = block.marginRight ?? 0;
     const totalWidth = Math.max(env.innerWidth - blockLeft - blockRight, 1);
-    const cols = b.columns ?? [];
+    const cols = block.columns ?? [];
     const n = cols.length;
     if (!n) return mt + mb;
     let colWidths;
-    const mode = b.mode ?? "fixedGap";
-    let gap;
+    const mode = block.mode ?? "fixedGap";
     if (mode === "spaceBetween" && n > 1) {
-      if (b.widths && b.widths.length === n) {
-        colWidths = computeColumnPixelWidths2(b.widths, totalWidth);
+      if (block.widths && block.widths.length === n) {
+        colWidths = computeColumnPixelWidths2(block.widths, totalWidth);
       } else {
         colWidths = Array(n).fill(totalWidth / n);
       }
-      const totalColsWidth = colWidths.reduce((a, x) => a + x, 0);
-      const remaining = Math.max(totalWidth - totalColsWidth, 0);
-      gap = remaining / (n - 1);
-      void gap;
     } else {
-      gap = b.gap ?? 20;
+      const gap = block.gap ?? 20;
       const totalGapsWidth = gap * (n - 1);
       const widthForCols = Math.max(totalWidth - totalGapsWidth, 1);
-      if (b.widths && b.widths.length === n) {
-        colWidths = computeColumnPixelWidths2(b.widths, widthForCols);
+      if (block.widths && block.widths.length === n) {
+        colWidths = computeColumnPixelWidths2(block.widths, widthForCols);
       } else {
         colWidths = Array(n).fill(widthForCols / n);
       }
     }
-    const heights = [];
-    for (let i = 0; i < n; i++) {
-      const colBlocks = cols[i] ?? [];
-      const colEnv = {
-        marginLeft: 0,
-        innerWidth: colWidths[i],
-        allowPageBreak: false
-      };
-      let colH = 0;
-      for (const child of colBlocks) {
-        if (!child || child.visible === false) continue;
-        colH += measure(child, colEnv);
-      }
-      heights.push(colH);
+    const heights = [];
+    for (let i = 0; i < n; i++) {
+      const colBlocks = cols[i] ?? [];
+      const colEnv = {
+        marginLeft: 0,
+        innerWidth: colWidths[i],
+        allowPageBreak: false
+      };
+      let colHeight = 0;
+      for (const child of colBlocks) {
+        if (!child || child.visible === false) continue;
+        colHeight += measure(child, colEnv);
+      }
+      heights.push(colHeight);
+    }
+    return mt + Math.max(...heights, 0) + mb;
+  };
+  const measureTable = (block, env) => {
+    const mt = block.marginTop ?? 0;
+    const mb = block.marginBottom ?? 0;
+    const ml = block.marginLeft ?? 0;
+    const mr = block.marginRight ?? 0;
+    const innerWidth = Math.max(env.innerWidth - ml - mr, 1);
+    const fakeEnv = {
+      marginLeft: 0,
+      innerWidth,
+      allowPageBreak: false
+    };
+    const height = measureTableHeight(doc, block, fakeEnv, styles, computeColumnPixelWidths2, measure);
+    return mt + height + mb;
+  };
+  const measureKeyValueGrid = (block, env) => {
+    const mt = block.marginTop ?? 0;
+    const mb = block.marginBottom ?? 0;
+    const ml = block.marginLeft ?? 0;
+    const mr = block.marginRight ?? 0;
+    const totalWidth = Math.max(env.innerWidth - ml - mr, 1);
+    const cols = block.columns ?? [];
+    const colCount = cols.length;
+    if (!colCount) return mt + mb;
+    const rowGap = block.rowGap ?? 4;
+    const keyValueGap = block.verticalKeyValueGap ?? 2;
+    const separatorText = block.separator ?? "";
+    const separatorWidth = separatorText ? doc.widthOfString(separatorText) : 0;
+    let colWidths;
+    if (block.columnWidths && block.columnWidths.length === colCount) {
+      colWidths = computeColumnPixelWidths2(
+        block.columnWidths.map((w) => w ?? "*"),
+        totalWidth
+      );
+    } else {
+      colWidths = Array(colCount).fill(totalWidth / colCount);
+    }
+    const measureTextHeight2 = (text, width) => {
+      doc.fontSize(10);
+      return doc.heightOfString(text ?? "", { width }) + 4;
+    };
+    let totalHeight = mt;
+    if (block.orientation === "vertical") {
+      let maxColHeight = 0;
+      for (let colIndex = 0; colIndex < colCount; colIndex++) {
+        const col = cols[colIndex] ?? [];
+        const colWidth = colWidths[colIndex];
+        let colHeight = 0;
+        for (const item of col) {
+          const keyHeight = measureTextHeight2(item.key ?? "", colWidth);
+          const valueHeight = measureTextHeight2(item.value ?? "", colWidth);
+          colHeight += keyHeight + keyValueGap + valueHeight + rowGap;
+        }
+        maxColHeight = Math.max(maxColHeight, colHeight);
+      }
+      totalHeight += maxColHeight;
+    } else {
+      const maxRows = Math.max(...cols.map((c) => c ? c.length : 0), 0);
+      for (let rowIndex = 0; rowIndex < maxRows; rowIndex++) {
+        let rowHeight = 0;
+        for (let colIndex = 0; colIndex < colCount; colIndex++) {
+          const item = cols[colIndex]?.[rowIndex];
+          if (!item) continue;
+          const colWidth = colWidths[colIndex];
+          const keyWidth = block.keyWidth === "*" ? Math.max(colWidth * 0.35, 20) : block.keyWidth ?? 80;
+          const keyHeight = measureTextHeight2(item.key ?? "", keyWidth);
+          const valueXInsideCol = keyWidth + (separatorText ? separatorWidth + 4 : 4);
+          const valueWidth = Math.max(colWidth - valueXInsideCol, 1);
+          const valueHeight = measureTextHeight2(item.value ?? "", valueWidth);
+          rowHeight = Math.max(rowHeight, keyHeight, valueHeight);
+        }
+        if (rowHeight > 0) {
+          totalHeight += rowHeight + rowGap;
+        }
+      }
+    }
+    return totalHeight + mb;
+  };
+  const stripBoxModelProps = (block) => {
+    return {
+      ...block,
+      marginTop: 0,
+      marginBottom: 0,
+      marginLeft: 0,
+      marginRight: 0,
+      backgroundColor: void 0,
+      backgroundImage: void 0,
+      backgroundOpacity: void 0,
+      backgroundBlocks: void 0,
+      padding: void 0,
+      paddingTop: void 0,
+      paddingRight: void 0,
+      paddingBottom: void 0,
+      paddingLeft: void 0
+    };
+  };
+  const measureRaw = (block, env) => {
+    switch (block.type) {
+      case "text":
+        return measureText(block, env);
+      case "image":
+        return measureImage(block);
+      case "qr":
+        return measureQr(block);
+      case "barcode":
+        return measureBarcode(block);
+      case "line":
+        return measureLine(block);
+      case "shape":
+        return measureShape(block);
+      case "columns":
+        return measureColumns(block, env);
+      case "table":
+        return measureTable(block, env);
+      case "keyValueGrid":
+        return measureKeyValueGrid(block, env);
+      case "list":
+        return measureListHeight(doc, styles, block, env);
+      case "signature":
+        return block.height ?? 0;
+      case "pageBreak":
+        return 0;
+      default:
+        return 0;
+    }
+  };
+  const measure = (block, env) => {
+    if (!block || block.visible === false) return 0;
+    if (env.isBackgroundLayer) {
+      return measureRaw(block, env);
+    }
+    const padding = resolveBlockPadding(block);
+    const hasBoxBackground = !!block.backgroundColor || !!block.backgroundImage || !!block.backgroundBlocks?.length;
+    const shouldUseBoxModel = hasPadding(padding) || hasBoxBackground;
+    if (!shouldUseBoxModel) {
+      return measureRaw(block, env);
+    }
+    const marginTop = block.marginTop ?? 0;
+    const marginBottom = block.marginBottom ?? 0;
+    const marginLeft = block.marginLeft ?? 0;
+    const marginRight = block.marginRight ?? 0;
+    const outerWidth = Math.max(env.innerWidth - marginLeft - marginRight, 1);
+    const innerWidth = Math.max(outerWidth - padding.left - padding.right, 1);
+    const innerEnv = {
+      ...env,
+      marginLeft: 0,
+      innerWidth
+    };
+    const innerBlock = stripBoxModelProps(block);
+    const innerHeight = measureRaw(innerBlock, innerEnv);
+    return marginTop + padding.top + innerHeight + padding.bottom + marginBottom;
+  };
+  return (block, env) => measure(block, env);
+}
+
+// src/renderer-engine/utils/page-limit.ts
+function createBottomLimitForContent(doc, ctx) {
+  return () => {
+    const pageBottomForContent = doc.page.height - doc.page.margins.bottom;
+    return ctx.signatureTopY ?? pageBottomForContent;
+  };
+}
+
+// src/renderer-engine/utils/block-renderer.ts
+function createBlockRenderer(deps) {
+  const { doc, ctx, styles, computeColumnPixelWidths: computeColumnPixelWidths2, finishPage: finishPage2, processSignatureBlock, defaultImage } = deps;
+  const bottomLimitForContent = createBottomLimitForContent(doc, ctx);
+  const ensureSpaceFor = createEnsureSpaceFor(ctx, doc, bottomLimitForContent, finishPage2);
+  const measureBlockHeight = createMeasureBlockHeight({
+    doc,
+    styles,
+    computeColumnPixelWidths: computeColumnPixelWidths2
+  });
+  const stripBoxModelProps = (block) => {
+    return {
+      ...block,
+      marginTop: 0,
+      marginBottom: 0,
+      marginLeft: 0,
+      marginRight: 0,
+      backgroundColor: void 0,
+      backgroundImage: void 0,
+      backgroundOpacity: void 0,
+      backgroundBlocks: void 0,
+      padding: void 0,
+      paddingTop: void 0,
+      paddingRight: void 0,
+      paddingBottom: void 0,
+      paddingLeft: void 0
+    };
+  };
+  const renderBlockCore = (block, y, env) => {
+    if (block.visible === false) {
+      return y ?? ctx.currentY;
+    }
+    switch (block.type) {
+      case "text":
+        return processTextBlock(doc, ctx, styles, block, y, env, ensureSpaceFor);
+      case "image":
+        return processImageBlock(doc, ctx, block, y, env, ensureSpaceFor, defaultImage);
+      case "qr": {
+        const qb = block;
+        const imageLike = {
+          type: "image",
+          src: qb.src,
+          width: qb.size,
+          height: qb.size,
+          align: qb.align,
+          marginTop: qb.marginTop,
+          marginBottom: qb.marginBottom,
+          marginLeft: qb.marginLeft,
+          marginRight: qb.marginRight
+        };
+        return processImageBlock(doc, ctx, imageLike, y, env, ensureSpaceFor, defaultImage);
+      }
+      case "barcode":
+        return processBarcodeBlock(doc, ctx, block, y, env, ensureSpaceFor);
+      case "line":
+        return processLineBlock(doc, ctx, block, y, env, ensureSpaceFor);
+      case "shape":
+        return processShapeBlock(doc, ctx, block, y, env, ensureSpaceFor);
+      case "columns":
+        return processColumnsBlock(
+          ctx,
+          block,
+          y,
+          env,
+          computeColumnPixelWidths2,
+          renderBlock,
+          ensureSpaceFor,
+          measureBlockHeight
+        );
+      case "table":
+        return processTableBlock(
+          doc,
+          ctx,
+          styles,
+          block,
+          y,
+          env,
+          computeColumnPixelWidths2,
+          bottomLimitForContent,
+          finishPage2,
+          renderBlock,
+          measureBlockHeight
+        );
+      case "keyValueGrid":
+        return processKeyValueGridBlock(
+          doc,
+          ctx,
+          styles,
+          block,
+          y,
+          env,
+          computeColumnPixelWidths2,
+          ensureSpaceFor
+        );
+      case "list":
+        return processListBlock(
+          doc,
+          ctx,
+          styles,
+          block,
+          y,
+          env,
+          ensureSpaceFor
+        );
+      case "pageBreak":
+        finishPage2(true);
+        return ctx.currentY;
+      case "signature":
+        processSignatureBlock(block);
+        return y ?? ctx.currentY;
+      default:
+        throw new PdfEngineError({
+          code: "PDF_ERROR_BLOCK_UNSUPPORTED" /* PDF_ERROR_BLOCK_UNSUPPORTED */,
+          message: `Unsupported block type: ${block.type}`,
+          statusCode: 422,
+          details: { block }
+        });
+    }
+  };
+  const renderBlock = (block, y, env) => {
+    if (block.visible === false) {
+      return y ?? ctx.currentY;
+    }
+    if (env.isBackgroundLayer) {
+      return renderBlockCore(block, y, env);
+    }
+    const padding = resolveBlockPadding(block);
+    const hasBoxBackground = !!block.backgroundColor || !!block.backgroundImage || !!block.backgroundBlocks?.length;
+    const shouldUseBoxModel = hasPadding(padding) || hasBoxBackground;
+    if (!shouldUseBoxModel) {
+      return renderBlockCore(block, y, env);
+    }
+    const marginTop = block.marginTop ?? 0;
+    const marginBottom = block.marginBottom ?? 0;
+    const marginLeft = block.marginLeft ?? 0;
+    const marginRight = block.marginRight ?? 0;
+    const outerX = env.marginLeft + marginLeft;
+    const outerWidth = Math.max(env.innerWidth - marginLeft - marginRight, 1);
+    const innerX = outerX + padding.left;
+    const innerWidth = Math.max(outerWidth - padding.left - padding.right, 1);
+    const innerEnv = {
+      ...env,
+      marginLeft: innerX,
+      innerWidth
+    };
+    const innerBlock = stripBoxModelProps(block);
+    const innerHeight = measureBlockHeight(innerBlock, innerEnv);
+    const boxHeight = padding.top + innerHeight + padding.bottom;
+    const totalHeight = marginTop + boxHeight + marginBottom;
+    if (y === null && env.allowPageBreak !== false && block.type !== "table") {
+      ensureSpaceFor(totalHeight, env);
+    }
+    const finalOuterY = (y ?? ctx.currentY) + marginTop;
+    if (block.backgroundColor) {
+      doc.save();
+      doc.fillOpacity(block.backgroundOpacity ?? 1).rect(outerX, finalOuterY, outerWidth, boxHeight).fill(block.backgroundColor);
+      doc.restore();
+    }
+    if (block.backgroundImage) {
+      try {
+        doc.save();
+        doc.opacity(block.backgroundOpacity ?? 1);
+        doc.image(block.backgroundImage, outerX, finalOuterY, {
+          width: outerWidth,
+          height: boxHeight
+        });
+        doc.restore();
+      } catch (_) {
+      }
+    }
+    if (block.backgroundBlocks?.length) {
+      doc.save();
+      doc.opacity(block.backgroundOpacity ?? 1);
+      renderBlockArray(block.backgroundBlocks, finalOuterY, {
+        ...env,
+        marginLeft: outerX,
+        innerWidth: outerWidth,
+        allowPageBreak: false,
+        isBackgroundLayer: true
+      });
+      doc.restore();
+    }
+    const innerEndY = renderBlockCore(innerBlock, finalOuterY + padding.top, innerEnv);
+    const newY = innerEndY + padding.bottom + marginBottom;
+    if (y === null) {
+      ctx.currentY = newY;
+    }
+    return newY;
+  };
+  const renderBlockArray = (blocks, startY, env) => {
+    let localY = startY;
+    for (const block of blocks) {
+      localY = renderBlock(block, localY, env);
+    }
+    return localY;
+  };
+  return { renderBlock, renderBlockArray, measureBlockHeight };
+}
+
+// src/renderer-engine/utils/context.ts
+function createInitialContext(doc) {
+  return {
+    pageNumber: 1,
+    currentY: doc.page.margins.top,
+    signatureBlock: null,
+    signatureTopY: null,
+    signatureHeight: 0,
+    signaturePlaced: false,
+    afterSignature: false,
+    inFooter: false,
+    inManualPageAdd: false
+  };
+}
+
+// src/renderer-engine/utils/env.ts
+var contentEnv = (doc) => ({
+  marginLeft: doc.page.margins.left,
+  innerWidth: doc.page.width - doc.page.margins.left - doc.page.margins.right,
+  allowPageBreak: true
+});
+
+// src/renderer-engine/utils/finish-page.ts
+function finishPage({
+  addNewPage,
+  doc,
+  def,
+  ctx,
+  footerBandHeight,
+  renderBlockArray,
+  startNewPageLayout
+}) {
+  const mode = def.watermark?.mode;
+  if (def.watermark && watermarkUsesLast(mode)) {
+    const isLast = !addNewPage;
+    drawWatermarkForPage(doc, def.watermark, ctx.pageNumber, isLast);
+  }
+  if (ctx.signatureBlock && ctx.signatureTopY !== null) {
+    const env = contentEnv(doc);
+    drawSignatureBlock(doc, ctx.signatureBlock, ctx.signatureTopY, env, renderBlockArray);
+  }
+  drawFooter(doc, def, ctx, footerBandHeight, renderBlockArray);
+  if (addNewPage) {
+    ctx.inManualPageAdd = true;
+    doc.addPage();
+    ctx.inManualPageAdd = false;
+    ctx.pageNumber += 1;
+    startNewPageLayout();
+  }
+}
+
+// src/renderer-engine/utils/footer.ts
+function normalizeFooter(input, ctx, doc) {
+  if (!input) return null;
+  if (typeof input === "function") {
+    const result = input(ctx.pageNumber, {
+      width: doc.page.width,
+      height: doc.page.height
+    });
+    if (!result) return null;
+    return normalizeFooter(result, ctx, doc);
+  }
+  if (input.blocks && Array.isArray(input.blocks)) {
+    const footer = input;
+    return {
+      visible: footer.visible,
+      blocks: footer.blocks,
+      backgroundBlocks: footer.backgroundBlocks,
+      marginTop: footer.marginTop,
+      marginBottom: footer.marginBottom,
+      marginLeft: footer.marginLeft,
+      marginRight: footer.marginRight,
+      padding: footer.padding,
+      paddingTop: footer.paddingTop,
+      paddingRight: footer.paddingRight,
+      paddingBottom: footer.paddingBottom,
+      paddingLeft: footer.paddingLeft,
+      backgroundColor: footer.backgroundColor,
+      backgroundImage: footer.backgroundImage,
+      backgroundOpacity: footer.backgroundOpacity
+    };
+  }
+  if (input.type) {
+    return { blocks: [input] };
+  }
+  if (Array.isArray(input)) {
+    return { blocks: input };
+  }
+  return null;
+}
+function drawFooter(doc, def, ctx, footerBandHeight, renderBlockArray) {
+  const footerConfig = def.footer;
+  if (!footerConfig) return;
+  const layout = normalizeFooter(footerConfig, ctx, doc);
+  if (!layout) return;
+  if (layout.visible === false) return;
+  const blocks = layout.blocks ?? [];
+  const backgroundBlocks = layout.backgroundBlocks ?? [];
+  if (!blocks.length && !backgroundBlocks.length && !layout.backgroundColor && !layout.backgroundImage) {
+    return;
+  }
+  const bandHeight = footerBandHeight;
+  if (!bandHeight) return;
+  const footerMarginLeft = layout.marginLeft ?? 0;
+  const footerMarginRight = layout.marginRight ?? 0;
+  const outerX = footerMarginLeft;
+  const outerWidth = doc.page.width - footerMarginLeft - footerMarginRight;
+  const padding = resolveFooterPadding(layout);
+  const innerX = outerX + padding.left;
+  const innerWidth = Math.max(outerWidth - padding.left - padding.right, 1);
+  const outerEnv = {
+    marginLeft: outerX,
+    innerWidth: outerWidth,
+    allowPageBreak: false
+  };
+  const innerEnv = {
+    marginLeft: innerX,
+    innerWidth,
+    allowPageBreak: false
+  };
+  const pageHeight = doc.page.height;
+  const bandTop = pageHeight - bandHeight;
+  const backgroundOpacity = layout.backgroundOpacity ?? 1;
+  if (layout.backgroundColor) {
+    doc.save();
+    doc.fillOpacity(backgroundOpacity).rect(0, bandTop, doc.page.width, bandHeight).fill(layout.backgroundColor);
+    doc.restore();
+  }
+  if (layout.backgroundImage) {
+    try {
+      doc.save();
+      doc.opacity(backgroundOpacity);
+      doc.image(layout.backgroundImage, 0, bandTop, {
+        width: doc.page.width,
+        height: bandHeight
+      });
+      doc.restore();
+    } catch (e) {
+      console.warn("Failed to load footer background image:", e);
+    }
+  }
+  doc.save();
+  doc.rect(outerX, bandTop, outerWidth, bandHeight).clip();
+  doc.translate(0, bandTop);
+  ctx.inFooter = true;
+  const localStartY = layout.marginTop ?? 4;
+  if (backgroundBlocks.length) {
+    doc.save();
+    doc.opacity(backgroundOpacity);
+    renderBlockArray(backgroundBlocks, localStartY, {
+      ...outerEnv,
+      allowPageBreak: false,
+      isBackgroundLayer: true
+    });
+    doc.restore();
+  }
+  if (blocks.length) {
+    renderBlockArray(blocks, localStartY + padding.top, innerEnv);
+  }
+  ctx.inFooter = false;
+  doc.restore();
+}
+
+// src/renderer-engine/utils/header.ts
+function drawHeader(doc, def, headerBandHeight, header, renderBlockArray) {
+  if (!header) return;
+  if (header.visible === false) return;
+  if (!headerBandHeight) return;
+  const blocks = header.blocks ?? [];
+  const backgroundBlocks = header.backgroundBlocks ?? [];
+  if (!blocks.length && !backgroundBlocks.length && !header.backgroundColor && !header.backgroundImage) {
+    return;
+  }
+  const bandTop = 0;
+  const bandHeight = def.margins.top;
+  const headerMarginLeft = header.marginLeft ?? 0;
+  const headerMarginRight = header.marginRight ?? 0;
+  const outerX = headerMarginLeft;
+  const outerWidth = doc.page.width - headerMarginLeft - headerMarginRight;
+  const padding = resolveHeaderPadding(header);
+  const innerX = outerX + padding.left;
+  const innerWidth = Math.max(outerWidth - padding.left - padding.right, 1);
+  const outerEnv = {
+    marginLeft: outerX,
+    innerWidth: outerWidth,
+    allowPageBreak: false
+  };
+  const innerEnv = {
+    marginLeft: innerX,
+    innerWidth,
+    allowPageBreak: false
+  };
+  const backgroundOpacity = header.backgroundOpacity ?? 1;
+  if (header.backgroundColor) {
+    doc.save();
+    doc.fillOpacity(backgroundOpacity).rect(0, bandTop, doc.page.width, bandHeight).fill(header.backgroundColor);
+    doc.restore();
+  }
+  if (header.backgroundImage) {
+    try {
+      doc.save();
+      doc.opacity(backgroundOpacity);
+      doc.image(header.backgroundImage, 0, bandTop, {
+        width: doc.page.width,
+        height: bandHeight
+      });
+      doc.restore();
+    } catch (e) {
+      console.warn("Failed to load header background image:", e);
+    }
+  }
+  doc.save();
+  doc.rect(outerX, bandTop, outerWidth, bandHeight).clip();
+  const startY = bandTop + (header.marginTop ?? 0);
+  if (backgroundBlocks.length) {
+    doc.save();
+    doc.opacity(backgroundOpacity);
+    renderBlockArray(backgroundBlocks, startY, {
+      ...outerEnv,
+      allowPageBreak: false,
+      isBackgroundLayer: true
+    });
+    doc.restore();
+  }
+  if (blocks.length) {
+    renderBlockArray(blocks, startY + padding.top, innerEnv);
+  }
+  doc.restore();
+}
+
+// src/renderer-engine/utils/image-loader.ts
+import axios from "axios";
+async function normalizeImageSrc(src, fallback) {
+  if (!src) return fallback ?? src;
+  if (Buffer.isBuffer(src)) return src;
+  if (src.startsWith("data:")) {
+    const commaIdx = src.indexOf(",");
+    if (commaIdx !== -1) {
+      return Buffer.from(src.slice(commaIdx + 1), "base64");
+    }
+  }
+  if (src.startsWith("http://") || src.startsWith("https://")) {
+    try {
+      const res = await axios.get(src, {
+        responseType: "arraybuffer"
+      });
+      return Buffer.from(res.data);
+    } catch (e) {
+      if (fallback !== void 0) {
+        console.warn(`Failed to fetch remote image "${src}", using default image.`);
+        return fallback;
+      }
+      throw toPdfEngineError(e, {
+        code: "PDF_ERROR_IMAGE_FETCH_FAILED" /* PDF_ERROR_IMAGE_FETCH_FAILED */,
+        message: "Failed to fetch remote image for PDF.",
+        statusCode: 422,
+        details: { url: src },
+        retryable: false
+      });
+    }
+  }
+  return src;
+}
+async function materializeImagesInBlocks(blocks, fallback) {
+  const out = [];
+  for (const block of blocks) {
+    const blockAny = { ...block };
+    if (blockAny.backgroundImage) {
+      blockAny.backgroundImage = await normalizeImageSrc(blockAny.backgroundImage, fallback);
     }
-    const maxH = Math.max(...heights, 0);
-    return mt + maxH + mb;
-  };
-  const measureKeyValueGrid = (b, env) => {
-    const mt = b.marginTop ?? 0;
-    const mb = b.marginBottom ?? 0;
-    const rowGap = b.rowGap ?? 4;
-    const orientation = b.orientation ?? "horizontal";
-    const cols = b.columns ?? [];
-    const colCount = cols.length;
-    if (!colCount) return mt + mb;
-    const blockLeft = b.marginLeft ?? 0;
-    const blockRight = b.marginRight ?? 0;
-    const totalWidth = Math.max(env.innerWidth - blockLeft - blockRight, 1);
-    let colWidths;
-    if (b.columnWidths && b.columnWidths.length === colCount) {
-      const safe = b.columnWidths.map((w) => w === void 0 ? "*" : w);
-      colWidths = computeColumnPixelWidths2(safe, totalWidth);
-    } else {
-      colWidths = Array(colCount).fill(totalWidth / colCount);
+    if (blockAny.backgroundBlocks?.length) {
+      blockAny.backgroundBlocks = await materializeImagesInBlocks(blockAny.backgroundBlocks, fallback);
     }
-    const separatorText = b.separator;
-    const sepBoxWidth = separatorText ? 10 : 0;
-    const baseKeyWidthRatio = 0.35;
-    const measureKVText = (tb, width) => {
-      const r = resolveTextBlock(styles, tb);
-      const fontName = getFontNameForText(r);
-      doc.font(fontName);
-      doc.fontSize(r.fontSize ?? 10);
-      return doc.heightOfString(r.text ?? "", { width });
-    };
-    let totalHeight = mt;
-    if (orientation === "vertical") {
-      const keyValueGap = b.verticalKeyValueGap ?? 2;
-      let maxColHeight = 0;
-      for (let colIndex = 0; colIndex < colCount; colIndex++) {
-        const col = cols[colIndex] ?? [];
-        const colWidth = colWidths[colIndex];
-        let colHeight = 0;
-        for (const item of col) {
-          const keyH = measureKVText({ type: "text", text: item.key ?? "" }, colWidth);
-          const valH = measureKVText({ type: "text", text: item.value ?? "" }, colWidth);
-          colHeight += keyH + keyValueGap + valH + rowGap;
-        }
-        if (colHeight > maxColHeight) maxColHeight = colHeight;
-      }
-      totalHeight += maxColHeight;
+    if (block.type === "image") {
+      const img = { ...blockAny };
+      img.src = await normalizeImageSrc(img.src, fallback);
+      out.push(img);
+    } else if (block.type === "columns") {
+      out.push({
+        ...blockAny,
+        columns: await Promise.all(
+          block.columns.map((col) => materializeImagesInBlocks(col, fallback))
+        )
+      });
+    } else if (block.type === "signature" && block.blocks) {
+      out.push({
+        ...blockAny,
+        blocks: await materializeImagesInBlocks(block.blocks, fallback)
+      });
+    } else if (block.type === "table") {
+      const tb = blockAny;
+      const newBody = await Promise.all(
+        tb.body.map(
+          async (entry) => {
+            const materializeCell = async (cell) => {
+              if (!cell.blocks?.length) return cell;
+              return {
+                ...cell,
+                blocks: await materializeImagesInBlocks(cell.blocks, fallback)
+              };
+            };
+            if (Array.isArray(entry)) {
+              return await Promise.all(entry.map(materializeCell));
+            }
+            if (entry && typeof entry === "object" && "content" in entry && Array.isArray(entry.content)) {
+              return {
+                ...entry,
+                content: await Promise.all(entry.content.map(materializeCell))
+              };
+            }
+            return entry;
+          }
+        )
+      );
+      out.push({ ...tb, body: newBody });
     } else {
-      const maxRows = Math.max(...cols.map((c) => c ? c.length : 0), 0);
-      for (let rowIndex = 0; rowIndex < maxRows; rowIndex++) {
-        let rowHeight = 0;
-        for (let colIndex = 0; colIndex < colCount; colIndex++) {
-          const item = cols[colIndex]?.[rowIndex];
-          if (!item) continue;
-          const colWidth = colWidths[colIndex];
-          const keyWidthPx = b.keyWidth === "*" ? Math.max(colWidth * baseKeyWidthRatio, 20) : b.keyWidth ?? 80;
-          const keyH = measureKVText({ type: "text", text: item.key ?? "" }, keyWidthPx);
-          const valueXInsideCol = keyWidthPx + (separatorText ? sepBoxWidth + 4 : 4);
-          const valueWidth = Math.max(colWidth - valueXInsideCol, 1);
-          const valH = measureKVText({ type: "text", text: item.value ?? "" }, valueWidth);
-          rowHeight = Math.max(rowHeight, Math.max(keyH, valH));
-        }
-        if (rowHeight > 0) totalHeight += rowHeight + rowGap;
-      }
-    }
-    totalHeight += mb;
-    return totalHeight;
-  };
-  const measure = (block, env) => {
-    if (!block || block.visible === false) return 0;
-    switch (block.type) {
-      case "text":
-        return measureText(block, env);
-      case "image":
-        return measureImage(block);
-      case "qr":
-        return measureQr(block);
-      case "barcode":
-        return measureBarcode(block);
-      case "line":
-        return measureLine(block);
-      case "table":
-        return measureTable(block, env);
-      case "columns":
-        return measureColumns(block, env);
-      case "keyValueGrid":
-        return measureKeyValueGrid(block, env);
-      case "signature":
-        return block.height ?? 0;
-      case "pageBreak":
-        return 0;
-      default:
-        return 0;
+      out.push(blockAny);
     }
-  };
-  return (block, env) => measure(block, env);
+  }
+  return out;
+}
+
+// src/renderer-engine/utils/layout.ts
+function computeColumnPixelWidths(widths, totalWidth) {
+  let fixedTotal = 0;
+  let starCount = 0;
+  widths.forEach((w) => {
+    if (w === "*") starCount++;
+    else fixedTotal += w;
+  });
+  const remaining = Math.max(totalWidth - fixedTotal, 0);
+  const starWidth = starCount > 0 ? remaining / starCount : 0;
+  return widths.map((w) => w === "*" ? starWidth : w);
 }
 
 // src/renderer-engine/utils/page-background.ts
@@ -1744,12 +2233,10 @@ function drawPageBackground(doc, pageBackground) {
   doc.opacity(1);
 }
 
-// src/renderer-engine/utils/page-limit.ts
-function createBottomLimitForContent(doc, ctx) {
-  return () => {
-    const pageBottomForContent = doc.page.height - doc.page.margins.bottom;
-    return ctx.signatureTopY ?? pageBottomForContent;
-  };
+// src/renderer-engine/utils/page-flow.ts
+function getBottomLimitForContent(doc, ctx) {
+  const pageBottomForContent = doc.page.height - doc.page.margins.bottom;
+  return ctx.signatureTopY ?? pageBottomForContent;
 }
 
 // src/renderer-engine/utils/qr-bar-code.ts
@@ -1772,7 +2259,10 @@ function generateQrBuffer(value, size, version, errorCorrectionLevel) {
             code: "PDF_ERROR_QR_GENERATION_FAILED" /* PDF_ERROR_QR_GENERATION_FAILED */,
             message: "Failed to generate QR code.",
             statusCode: 500,
-            details: { valuePreview: String(value).slice(0, 60), size },
+            details: {
+              valuePreview: String(value).slice(0, 60),
+              size
+            },
             retryable: false
           })
         );
@@ -1799,109 +2289,101 @@ function mapBarcodeTypeToBcid(bcType) {
 function generateBarcodeBuffer(value, options = {}) {
   const { bcType, scale = 3, barHeight = 10, includetext = false, textalign = "center" } = options;
   const bcid = mapBarcodeTypeToBcid(bcType);
+  if (bcType === "EAN13" && !/^\d{12,13}$/.test(value)) {
+    throw toPdfEngineError(new Error("Invalid EAN13 value"), {
+      code: "PDF_ERROR_BARCODE_EAN13_INVALID_LENGTH" /* PDF_ERROR_BARCODE_EAN13_INVALID_LENGTH */,
+      message: "EAN13 barcode value must be 12 or 13 digits.",
+      statusCode: 422,
+      details: { value },
+      retryable: false
+    });
+  }
   return new Promise((resolve, reject) => {
-    let textValue = value;
-    if (bcType === "EAN13") {
-      const digitsOnly = textValue.replace(/\D/g, "");
-      if (digitsOnly.length === 13) {
-        textValue = digitsOnly.slice(0, 12);
-      } else if (digitsOnly.length === 12) {
-        textValue = digitsOnly;
-      } else {
-        return reject(
-          new PdfEngineError({
-            code: "PDF_ERROR_BARCODE_EAN13_INVALID_LENGTH" /* PDF_ERROR_BARCODE_EAN13_INVALID_LENGTH */,
-            message: `EAN13 barcode value must have 12 or 13 digits, got "${value}"`,
-            statusCode: 422,
-            details: { value },
-            retryable: false
-          })
-        );
-      }
-    }
-    const bwipOptions = {
-      bcid,
-      text: textValue,
-      scale,
-      height: barHeight,
-      includetext
-    };
-    bwipOptions.textxalign = textalign;
-    bwipjs.toBuffer(bwipOptions, (err, png) => {
-      if (err) {
-        return reject(
-          toPdfEngineError(err, {
-            code: "PDF_ERROR_BARCODE_GENERATION_FAILED" /* PDF_ERROR_BARCODE_GENERATION_FAILED */,
-            message: "Failed to generate barcode.",
-            statusCode: 500,
-            details: { bcType, valuePreview: String(value).slice(0, 60) },
-            retryable: false
-          })
-        );
+    bwipjs.toBuffer(
+      {
+        bcid,
+        text: value,
+        scale,
+        height: barHeight,
+        includetext,
+        textxalign: textalign
+      },
+      (err, png) => {
+        if (err) {
+          return reject(
+            toPdfEngineError(err, {
+              code: "PDF_ERROR_BARCODE_GENERATION_FAILED" /* PDF_ERROR_BARCODE_GENERATION_FAILED */,
+              message: "Failed to generate barcode.",
+              statusCode: 500,
+              details: {
+                valuePreview: String(value).slice(0, 60),
+                bcType
+              },
+              retryable: false
+            })
+          );
+        }
+        resolve(png);
       }
-      resolve(png);
-    });
+    );
   });
 }
 async function materializeQrAndBarcodesInBlocks(blocks) {
   const out = [];
   for (const block of blocks) {
-    if (block.type === "columns") {
-      const colBlock = block;
-      const newCols = [];
-      for (const col of colBlock.columns) {
-        newCols.push(await materializeQrAndBarcodesInBlocks(col));
-      }
-      out.push({
-        ...colBlock,
-        columns: newCols
-      });
-    } else if (block.type === "signature") {
-      const sig = block;
-      if (sig.blocks && sig.blocks.length) {
-        const newInner = await materializeQrAndBarcodesInBlocks(sig.blocks);
-        out.push({
-          ...sig,
-          blocks: newInner
-        });
-      } else {
-        out.push(block);
-      }
-    } else if (block.type === "qr") {
-      const qb = { ...block };
+    const blockAny = { ...block };
+    if (blockAny.backgroundBlocks?.length) {
+      blockAny.backgroundBlocks = await materializeQrAndBarcodesInBlocks(blockAny.backgroundBlocks);
+    }
+    if (block.type === "qr") {
+      const qb = blockAny;
       if (!qb.src && qb.value) {
-        const size = qb.size ?? 80;
-        const buf = await generateQrBuffer(qb.value, size, qb.qrVersion, qb.errorCorrectionLevel);
-        qb.src = buf;
+        qb.size = qb.size ?? 80;
+        qb.src = await generateQrBuffer(qb.value, qb.size, qb.qrVersion, qb.errorCorrectionLevel);
       }
       out.push(qb);
     } else if (block.type === "barcode") {
-      const bb = { ...block };
+      const bb = blockAny;
       if (!bb.src && bb.value) {
-        const buf = await generateBarcodeBuffer(bb.value, {
+        bb.src = await generateBarcodeBuffer(bb.value, {
           bcType: bb.bcType,
           scale: bb.scale,
           barHeight: bb.barHeight,
           includetext: bb.includetext,
           textalign: bb.textalign
         });
-        bb.src = buf;
       }
       out.push(bb);
+    } else if (block.type === "columns") {
+      out.push({
+        ...blockAny,
+        columns: await Promise.all(block.columns.map((col) => materializeQrAndBarcodesInBlocks(col)))
+      });
+    } else if (block.type === "signature" && block.blocks) {
+      out.push({
+        ...blockAny,
+        blocks: await materializeQrAndBarcodesInBlocks(block.blocks)
+      });
     } else if (block.type === "table") {
-      const tb = block;
+      const tb = blockAny;
       const newBody = await Promise.all(
         tb.body.map(
           async (entry) => {
             const materializeCell = async (cell) => {
               if (!cell.blocks?.length) return cell;
-              return { ...cell, blocks: await materializeQrAndBarcodesInBlocks(cell.blocks) };
+              return {
+                ...cell,
+                blocks: await materializeQrAndBarcodesInBlocks(cell.blocks)
+              };
             };
             if (Array.isArray(entry)) {
               return await Promise.all(entry.map(materializeCell));
             }
             if (entry && typeof entry === "object" && "content" in entry && Array.isArray(entry.content)) {
-              return { ...entry, content: await Promise.all(entry.content.map(materializeCell)) };
+              return {
+                ...entry,
+                content: await Promise.all(entry.content.map(materializeCell))
+              };
             }
             return entry;
           }
@@ -1909,7 +2391,7 @@ async function materializeQrAndBarcodesInBlocks(blocks) {
       );
       out.push({ ...tb, body: newBody });
     } else {
-      out.push(block);
+      out.push(blockAny);
     }
   }
   return out;
@@ -2163,102 +2645,143 @@ function drawWatermarkForPage(doc, watermark, pageNumber, isLast) {
 }
 
 // src/renderer-engine/index.ts
-var BUILT_IN_DEFAULT_IMAGE = Buffer.from(
-  images.default.slice(images.default.indexOf(",") + 1),
-  "base64"
-);
-async function renderCustomPdf(def, outputPath) {
-  const fallbackImage = def.defaultImage ?? BUILT_IN_DEFAULT_IMAGE;
-  if (def.header) {
+var BUILT_IN_DEFAULT_IMAGE = Buffer.from(images.default.slice(images.default.indexOf(",") + 1), "base64");
+async function materializeFooterAssets(footer, fallbackImage) {
+  if (!footer) return footer;
+  if (typeof footer === "function") {
+    return footer;
+  }
+  if (Array.isArray(footer)) {
+    let blocks = await materializeQrAndBarcodesInBlocks(footer);
+    blocks = await materializeImagesInBlocks(blocks, fallbackImage);
+    return blocks;
+  }
+  if (footer.type) {
+    let blocks = await materializeQrAndBarcodesInBlocks([footer]);
+    blocks = await materializeImagesInBlocks(blocks, fallbackImage);
+    return blocks[0];
+  }
+  const footerDef = footer;
+  if (footerDef.backgroundImage) {
+    footerDef.backgroundImage = await normalizeImageSrc(footerDef.backgroundImage, fallbackImage);
+  }
+  if (footerDef.blocks?.length) {
+    footerDef.blocks = await materializeQrAndBarcodesInBlocks(footerDef.blocks);
+    footerDef.blocks = await materializeImagesInBlocks(footerDef.blocks, fallbackImage);
+  }
+  if (footerDef.backgroundBlocks?.length) {
+    footerDef.backgroundBlocks = await materializeQrAndBarcodesInBlocks(footerDef.backgroundBlocks);
+    footerDef.backgroundBlocks = await materializeImagesInBlocks(footerDef.backgroundBlocks, fallbackImage);
+  }
+  return footerDef;
+}
+async function materializeDocAssets(def, fallbackImage) {
+  if (def.header?.blocks?.length) {
     def.header.blocks = await materializeQrAndBarcodesInBlocks(def.header.blocks);
     def.header.blocks = await materializeImagesInBlocks(def.header.blocks, fallbackImage);
   }
+  if (def.header?.backgroundImage) {
+    def.header.backgroundImage = await normalizeImageSrc(def.header.backgroundImage, fallbackImage);
+  }
+  if (def.header?.backgroundBlocks?.length) {
+    def.header.backgroundBlocks = await materializeQrAndBarcodesInBlocks(def.header.backgroundBlocks);
+    def.header.backgroundBlocks = await materializeImagesInBlocks(def.header.backgroundBlocks, fallbackImage);
+  }
   def.content = await materializeQrAndBarcodesInBlocks(def.content);
   def.content = await materializeImagesInBlocks(def.content, fallbackImage);
   if (def.pageBackground?.src) {
     def.pageBackground.src = await normalizeImageSrc(def.pageBackground.src, fallbackImage);
   }
-  if (def.header?.backgroundImage) {
-    def.header.backgroundImage = await normalizeImageSrc(def.header.backgroundImage, fallbackImage);
+  def.footer = await materializeFooterAssets(def.footer, fallbackImage);
+}
+function runRender(doc, def, fallbackImage) {
+  const headerBandHeight = def.margins.top ?? 0;
+  const footerBandHeight = def.margins.bottom ?? 0;
+  if (def.fonts && def.fonts.length) {
+    for (const font of def.fonts) {
+      try {
+        doc.registerFont(font.name, font.src);
+      } catch (e) {
+        console.warn("Failed to register font:", font.name, e);
+      }
+    }
   }
-  if (def.footer && typeof def.footer !== "function") {
-    const footer = def.footer;
-    if (footer.backgroundImage) {
-      footer.backgroundImage = await normalizeImageSrc(footer.backgroundImage, fallbackImage);
+  const ctx = createInitialContext(doc);
+  const styles = def.styles ?? {};
+  const finishPage2 = (addNewPage) => finishPage({
+    addNewPage,
+    doc,
+    def,
+    ctx,
+    footerBandHeight,
+    renderBlockArray,
+    startNewPageLayout
+  });
+  const processSignatureBlock = createProcessSignatureBlock({
+    doc,
+    ctx,
+    styles,
+    finishPage: finishPage2,
+    contentEnvFn: contentEnv
+  });
+  const { renderBlock, renderBlockArray } = createBlockRenderer({
+    doc,
+    ctx,
+    styles,
+    computeColumnPixelWidths,
+    finishPage: finishPage2,
+    processSignatureBlock,
+    defaultImage: fallbackImage
+  });
+  const startNewPageLayout = createStartNewPageLayout({
+    doc,
+    def,
+    ctx,
+    headerBandHeight,
+    renderBlockArray
+  });
+  doc.on("pageAdded", () => {
+    if (ctx.inManualPageAdd) return;
+    ctx.pageNumber += 1;
+    drawPageBackground(doc, def.pageBackground);
+    drawHeader(doc, def, headerBandHeight, def.header ?? void 0, renderBlockArray);
+    const mode = def.watermark?.mode;
+    if (def.watermark && !watermarkUsesLast(mode)) {
+      drawWatermarkForPage(doc, def.watermark, ctx.pageNumber, false);
     }
+    ctx.currentY = doc.page.margins.top;
+  });
+  startNewPageLayout();
+  for (const block of def.content) {
+    if (block.type === "signature") {
+      processSignatureBlock(block);
+      continue;
+    }
+    if (ctx.afterSignature) {
+      finishPage2(true);
+      ctx.afterSignature = false;
+    }
+    renderBlock(block, null, contentEnv(doc));
   }
+  finishPage2(false);
+  doc.end();
+}
+async function renderCustomPdf(def, outputPath) {
+  const fallbackImage = def.defaultImage ?? BUILT_IN_DEFAULT_IMAGE;
+  await materializeDocAssets(def, fallbackImage);
   return new Promise((resolve, reject) => {
-    const headerBandHeight = def.margins.top ?? 0;
-    const footerBandHeight = def.margins.bottom ?? 0;
     const doc = new PDFDocument({
       size: def.pageSize || "A4",
       layout: def.pageOrientation === "landscape" ? "landscape" : "portrait",
       margins: {
-        top: headerBandHeight,
-        bottom: footerBandHeight,
+        top: def.margins.top ?? 0,
+        bottom: def.margins.bottom ?? 0,
         left: def.margins.left,
         right: def.margins.right
       }
     });
-    if (def.fonts && def.fonts.length) {
-      for (const f of def.fonts) {
-        try {
-          doc.registerFont(f.name, f.src);
-        } catch (e) {
-          console.warn("Failed to register font:", f.name, e);
-        }
-      }
-    }
     const stream = fs.createWriteStream(outputPath);
     doc.pipe(stream);
-    const ctx = createInitialContext(doc);
-    const styles = def.styles ?? {};
-    const finishPage2 = (addNewPage) => finishPage({
-      addNewPage,
-      doc,
-      def,
-      ctx,
-      footerBandHeight,
-      renderBlockArray,
-      startNewPageLayout
-    });
-    const processSignatureBlock = createProcessSignatureBlock({
-      doc,
-      ctx,
-      styles,
-      finishPage: finishPage2,
-      contentEnvFn: contentEnv
-    });
-    const { renderBlock, renderBlockArray } = createBlockRenderer({
-      doc,
-      ctx,
-      styles,
-      computeColumnPixelWidths,
-      finishPage: finishPage2,
-      processSignatureBlock,
-      defaultImage: fallbackImage
-    });
-    const startNewPageLayout = createStartNewPageLayout({
-      doc,
-      def,
-      ctx,
-      headerBandHeight,
-      renderBlockArray
-    });
-    startNewPageLayout();
-    for (const block of def.content) {
-      if (block.type === "signature") {
-        processSignatureBlock(block);
-        continue;
-      }
-      if (ctx.afterSignature) {
-        finishPage2(true);
-        ctx.afterSignature = false;
-      }
-      renderBlock(block, null, contentEnv(doc));
-    }
-    finishPage2(false);
-    doc.end();
     stream.on("finish", () => resolve());
     stream.on(
       "error",
@@ -2272,115 +2795,38 @@ async function renderCustomPdf(def, outputPath) {
         })
       )
     );
+    runRender(doc, def, fallbackImage);
   });
 }
 async function renderCustomPdfToBuffer(def) {
   const fallbackImage = def.defaultImage ?? BUILT_IN_DEFAULT_IMAGE;
-  if (def.header) {
-    def.header.blocks = await materializeQrAndBarcodesInBlocks(def.header.blocks);
-    def.header.blocks = await materializeImagesInBlocks(def.header.blocks, fallbackImage);
-  }
-  def.content = await materializeQrAndBarcodesInBlocks(def.content);
-  def.content = await materializeImagesInBlocks(def.content, fallbackImage);
-  if (def.pageBackground?.src) {
-    def.pageBackground.src = await normalizeImageSrc(def.pageBackground.src, fallbackImage);
-  }
-  if (def.header?.backgroundImage) {
-    def.header.backgroundImage = await normalizeImageSrc(def.header.backgroundImage, fallbackImage);
-  }
-  if (def.footer && typeof def.footer !== "function") {
-    const footer = def.footer;
-    if (footer.backgroundImage) {
-      footer.backgroundImage = await normalizeImageSrc(footer.backgroundImage, fallbackImage);
-    }
-  }
+  await materializeDocAssets(def, fallbackImage);
   return new Promise((resolve, reject) => {
-    const headerBandHeight = def.margins.top ?? 0;
-    const footerBandHeight = def.margins.bottom ?? 0;
     const doc = new PDFDocument({
       size: def.pageSize || "A4",
       layout: def.pageOrientation === "landscape" ? "landscape" : "portrait",
       margins: {
-        top: headerBandHeight,
-        bottom: footerBandHeight,
+        top: def.margins.top ?? 0,
+        bottom: def.margins.bottom ?? 0,
         left: def.margins.left,
         right: def.margins.right
       }
     });
     const chunks = [];
-    doc.on("data", (chunk) => {
-      chunks.push(chunk);
-    });
-    doc.on("end", () => {
-      resolve(Buffer.concat(chunks));
-    });
-    doc.on("error", (err) => {
-      reject(
+    doc.on("data", (chunk) => chunks.push(chunk));
+    doc.on("end", () => resolve(Buffer.concat(chunks)));
+    doc.on(
+      "error",
+      (err) => reject(
         toPdfEngineError(err, {
           code: "PDF_ERROR_PDFKIT_ERROR" /* PDF_ERROR_PDFKIT_ERROR */,
           message: "PDFKit emitted an error while rendering.",
           statusCode: 500,
           retryable: true
         })
-      );
-    });
-    if (def.fonts && def.fonts.length) {
-      for (const f of def.fonts) {
-        try {
-          doc.registerFont(f.name, f.src);
-        } catch (e) {
-          console.warn("Failed to register font:", f.name, e);
-        }
-      }
-    }
-    const ctx = createInitialContext(doc);
-    const styles = def.styles ?? {};
-    const finishPage2 = (addNewPage) => finishPage({
-      addNewPage,
-      doc,
-      def,
-      ctx,
-      footerBandHeight,
-      renderBlockArray,
-      startNewPageLayout
-    });
-    const processSignatureBlock = createProcessSignatureBlock({
-      doc,
-      ctx,
-      styles,
-      finishPage: finishPage2,
-      contentEnvFn: contentEnv
-    });
-    const { renderBlock, renderBlockArray } = createBlockRenderer({
-      doc,
-      ctx,
-      styles,
-      computeColumnPixelWidths,
-      finishPage: finishPage2,
-      processSignatureBlock,
-      defaultImage: fallbackImage
-    });
-    const startNewPageLayout = createStartNewPageLayout({
-      doc,
-      def,
-      ctx,
-      headerBandHeight,
-      renderBlockArray
-    });
-    startNewPageLayout();
-    for (const block of def.content) {
-      if (block.type === "signature") {
-        processSignatureBlock(block);
-        continue;
-      }
-      if (ctx.afterSignature) {
-        finishPage2(true);
-        ctx.afterSignature = false;
-      }
-      renderBlock(block, null, contentEnv(doc));
-    }
-    finishPage2(false);
-    doc.end();
+      )
+    );
+    runRender(doc, def, fallbackImage);
   });
 }
 export {
@@ -2388,9 +2834,42 @@ export {
   PdfEngineError,
   PdfEngineErrorCode,
   QR_ERROR_LEVEL,
+  computeColumnPixelWidths,
+  contentEnv,
+  createBlockRenderer,
+  createBottomLimitForContent,
+  createEnsureSpaceFor,
+  createInitialContext,
+  createMeasureBlockHeight,
+  createProcessSignatureBlock,
+  createStartNewPageLayout,
+  drawFooter,
+  drawHeader,
+  drawPageBackground,
+  drawSignatureBlock,
+  drawStyledText,
+  drawWatermarkForPage,
+  finishPage,
+  generateBarcodeBuffer,
+  generateQrBuffer,
+  getBottomLimitForContent,
+  getFontNameForText,
+  hasPadding,
   images,
   isPdfEngineError,
+  mapBarcodeTypeToBcid,
+  materializeImagesInBlocks,
+  materializeQrAndBarcodesInBlocks,
+  mergeStyleDefs,
+  normalizeImageSrc,
   renderCustomPdf,
   renderCustomPdfToBuffer,
-  toPdfEngineError
+  resolveBlockPadding,
+  resolveFooterPadding,
+  resolveHeaderPadding,
+  resolveSpacing,
+  resolveTableCell,
+  resolveTextBlock,
+  toPdfEngineError,
+  watermarkUsesLast
 };