@broadpaper/forme 0.2.1 → 0.3.0

package/README.md

@@ -6,7 +6,7 @@
 
 Browserless PDF generation for BroadPaper, via the Forme WebAssembly engine. The recommended backend.
 
-Part of [**BroadPaper**](https://www.broadpaper.com) — an embeddable visual report designer and PDF renderer.
+Part of [**BroadPaper**](https://www.broadpaper.com/developers/) — an embeddable visual report designer and PDF renderer.
 Your users design the report in your application; BroadPaper owns the layout, the branding,
 the pagination and the output.
 
@@ -21,26 +21,29 @@ engine and nothing else to install. That is what makes BroadPaper deployable in
 that has no browser in it, which is most of the containers a report renderer belongs in.
 
 ```ts
-import { renderPdf } from "@broadpaper/forme";
+import { createRegistry } from "@broadpaper/blocks";
+import { renderPdfPaginated } from "@broadpaper/forme";
 
-const { pdf, pages } = await renderPdf({ template, data });
+const { pdf, pages } = await renderPdfPaginated({ template, data, registry: createRegistry() });
 ```
 
-Text is selectable, fonts are embedded, and output is byte-for-byte deterministic for
+Text is selectable, the fonts you supply are embedded, and output is byte-for-byte deterministic for
 identical input — so a document regenerated a year later is the same file, and a diff of two
 renders shows what actually changed.
 
 ## Licensing
 
 BroadPaper is **free to evaluate, with no trial clock and nothing behind a feature gate**.
-Install it, use every feature, run it against your real data, in production if you like.
+Install it, use every feature and evaluate it against your real data for as long as you like.
+Production use needs a licence.
 
-The only difference without a licence is that generated PDFs carry an evaluation mark. A
-licence removes it — that is the entire commercial mechanism. No seats, no activation, no
-machine binding, no telemetry, and no call home at any point.
+In the software, the only difference without a licence is that generated PDFs carry an
+evaluation mark, and a licence removes it. Contractually, the licence is also what permits
+production use. No seats, no activation, no machine binding, no telemetry, and no call home at
+any point.
 
 - [How licensing works](https://www.broadpaper.com/docs/guide/licensing/)
-- [Pricing](https://www.broadpaper.com/pricing/)
+- [Pricing](https://www.broadpaper.com/developers/pricing/)
 - [Licence agreement](https://www.broadpaper.com/legal/terms/)
 
 ## Documentation

package/dist/{chunk-2PT5WRKQ.js → chunk-2C3MAW2U.js}

@@ -892,7 +892,7 @@ var FormeMeasurer = class {
       defaultPage: { size: "A4", margin: { top: 54, right: 54, bottom: 54, left: 54 }, wrap: true },
       defaultStyle: {}
     };
-    if (this.opts.fonts?.length) doc.fonts = this.opts.fonts;
+    if (this.opts.fonts?.length) doc.fonts = this.opts.fonts.map((f) => ({ ...f }));
     const result = await this.opts.render(doc);
     const pages = result.layout?.pages ?? [];
     const toPx = 96 / 72;
@@ -947,6 +947,7 @@ var FormeEditorMeasurer = class {
       }
     }
     if (!pending.length) return out;
+    const fonts = await this.config.fonts;
     const measurer = new FormeMeasurer({
       registry: opts.registry,
       theme: opts.theme,
@@ -955,7 +956,7 @@ var FormeEditorMeasurer = class {
       mode: opts.mode,
       pageWidth: width,
       margins: { top: 0, right: 0, bottom: 0, left: 0 },
-      fonts: this.config.fonts,
+      fonts,
       render: this.config.render
     });
     const measured = await measurer.measure(pending, width);
@@ -983,47 +984,261 @@ import {
 } from "@broadpaper/core";
 import { mapStyle as mapStyle4 } from "@formepdf/shared";
 import { producerString, resolveLicenseStatus, watermarkFor } from "@broadpaper/license";
+
+// src/credit.ts
+function creditNode(spec, width, ctx) {
+  const size = spec.fontSize;
+  const children = [];
+  if (spec.mark) {
+    children.push({
+      tag: "img",
+      props: { src: spec.mark, alt: "", style: { width: `${size}px`, height: `${size}px`, opacity: String(spec.opacity) } },
+      children: []
+    });
+  }
+  children.push({
+    tag: "span",
+    props: { style: { "font-size": `${size}px`, color: spec.color, opacity: String(spec.opacity), "line-height": "1.2" } },
+    children: [spec.text]
+  });
+  const line = {
+    tag: "div",
+    props: {
+      style: {
+        display: "flex",
+        "align-items": "center",
+        gap: `${Math.max(2, Math.round(size * 0.5))}px`,
+        width: `${width}px`,
+        "justify-content": "center"
+      }
+    },
+    children
+  };
+  return translate(line, ctx)?.node ?? null;
+}
+
+// src/api.ts
 import { BroadPaper, configure, resolveLicenseStatus as resolveLicenseStatus2, verifyLicense, parseLicense } from "@broadpaper/license";
 import { computePageGeometry as pageGeometry, paginate, resolveValue } from "@broadpaper/core";
 
+// src/long-tables.ts
+var EPS = 0.5;
+function round3(n) {
+  return Math.round(n * 100) / 100;
+}
+function isRow(c) {
+  return typeof c !== "string" && c.tag === "tr";
+}
+function bodyRowCount(table) {
+  let n = 0;
+  for (const c of table.children) {
+    if (typeof c === "string") continue;
+    if (c.tag === "tbody") n += c.children.filter(isRow).length;
+    else if (c.tag === "tr") n++;
+  }
+  return n;
+}
+function longTables(tree, limit) {
+  const out = [];
+  const visit = (v, key) => {
+    const own = typeof v.props["data-key"] === "string" ? v.props["data-key"] : key;
+    if (v.tag === "table") {
+      const rows = bodyRowCount(v);
+      if (rows > limit && own) out.push({ table: v, key: own, bodyRows: rows });
+      return;
+    }
+    for (const c of v.children) if (typeof c !== "string") visit(c, own);
+  };
+  visit(tree, void 0);
+  return out;
+}
+function sliceTables(tree, tables, start, count) {
+  const targets = new Set(tables.map((t) => t.table));
+  const visit = (v) => {
+    if (targets.has(v)) return sliceRows(v, start, count);
+    let changed = false;
+    const children = v.children.map((c) => {
+      if (typeof c === "string") return c;
+      const next = visit(c);
+      if (next !== c) changed = true;
+      return next;
+    });
+    return changed ? { ...v, children } : v;
+  };
+  return visit(tree);
+}
+function sliceRows(table, start, count) {
+  let index = 0;
+  const keep = () => {
+    const i = index++;
+    return i >= start && i < start + count;
+  };
+  const children = [];
+  for (const c of table.children) {
+    if (typeof c === "string") children.push(c);
+    else if (c.tag === "tbody") children.push({ ...c, children: c.children.filter((r) => !isRow(r) || keep()) });
+    else if (c.tag === "tr") {
+      if (keep()) children.push(c);
+    } else children.push(c);
+  }
+  return { ...table, children };
+}
+function sameRows(a, b) {
+  return !!a && a.length === b.length && a[0]?.top === b[0]?.top && a[a.length - 1]?.top === b[b.length - 1]?.top;
+}
+function stitchTables(first, tables, batches) {
+  const g = {
+    ...first,
+    nodes: Object.fromEntries(Object.entries(first.nodes).map(([k, n]) => [k, { ...n }]))
+  };
+  const bottomOf = (rows) => Math.max(...rows.map((r) => r.top + r.height));
+  const order = tables.map((t) => ({ t, rows: first.nodes[t.key]?.rows })).filter((x) => !!x.rows && x.rows.some((r) => r.kind === "body")).sort((a, b) => bottomOf(b.rows) - bottomOf(a.rows));
+  for (const { t } of order) {
+    const main = g.nodes[t.key].rows;
+    const body = main.filter((r) => r.kind === "body");
+    const last = body[body.length - 1];
+    const bodyEnd = last.top + last.height;
+    const gap = body.length > 1 ? Math.max(0, body[1].top - (body[0].top + body[0].height)) : 0;
+    const extra = [];
+    let cursor = bodyEnd + gap;
+    for (const batch of batches) {
+      const rows = batch.nodes[t.key]?.rows?.filter((r) => r.kind === "body") ?? [];
+      if (!rows.length) continue;
+      const base = rows[0].top;
+      for (const r of rows) extra.push({ top: round3(cursor + r.top - base), height: r.height, kind: "body" });
+      const end = rows[rows.length - 1];
+      cursor += end.top + end.height - base + gap;
+    }
+    if (!extra.length) continue;
+    const tail = extra[extra.length - 1];
+    const delta = round3(tail.top + tail.height - bodyEnd);
+    const merged = [
+      ...main.filter((r) => r.kind === "header"),
+      ...body,
+      ...extra,
+      ...main.filter((r) => r.kind === "footer").map((r) => ({ ...r, top: round3(r.top + delta) }))
+    ];
+    for (const n of Object.values(g.nodes)) {
+      const holdsThisTable = sameRows(n.rows, main);
+      if (n.top >= bodyEnd - EPS) {
+        n.top = round3(n.top + delta);
+        if (n.lines) n.lines = n.lines.map((y) => round3(y + delta));
+        if (n.rows && !holdsThisTable) n.rows = n.rows.map((r) => ({ ...r, top: round3(r.top + delta) }));
+      } else if (n.top + n.height > bodyEnd - EPS) {
+        n.height = round3(n.height + delta);
+      }
+      if (holdsThisTable) n.rows = merged;
+    }
+    g.height = round3(g.height + delta);
+  }
+  return g;
+}
+
 // src/paged.ts
 import {
-  renderNode as renderNode2,
-  walkVNodes as walkVNodes2
+  renderNode as renderNode2
 } from "@broadpaper/core";
 import { mapStyle as mapStyle3 } from "@formepdf/shared";
 
 // src/clip.ts
 import { styleString as styleString2 } from "@broadpaper/core";
-var EPS = 0.01;
+var EPS2 = 0.01;
 function cropToWindow(root, geom, from, to) {
   const w = { geom, from, to, dropped: 0 };
-  const node = crop(root, w, void 0);
+  const node = crop(root, w, void 0, true);
   return { node, offset: w.dropped };
 }
 function outside(w, top, height) {
-  return top + height <= w.from + EPS || top >= w.to - EPS;
+  return top + height <= w.from + EPS2 || top >= w.to - EPS2;
 }
-function crop(v, w, rows) {
-  const key = typeof v.props["data-key"] === "string" ? v.props["data-key"] : void 0;
-  const g = key ? w.geom.nodes[key] : void 0;
+function crop(v, w, rows, stacked) {
+  const g = geometryOf(v, w.geom);
   if (g) {
     if (outside(w, g.top, g.height)) return blank(v, g.height);
     if (g.rows) rows = g.rows;
   }
   if (v.tag === "table" && rows) return cropTable(v, w, rows);
-  let changed = false;
-  const children = v.children.map((c) => {
+  const childrenStacked = stacked && !sideBySide(v.children, w.geom);
+  const removed = childrenStacked ? removeAbove(v.children, w) : 0;
+  let changed = removed > 0;
+  const children = v.children.slice(removed).map((c) => {
     if (typeof c === "string") return c;
-    const next = crop(c, w, rows);
+    const next = crop(c, w, rows, childrenStacked);
     if (next !== c) changed = true;
     return next;
   });
   return changed ? { ...v, children } : v;
 }
+function geometryOf(v, geom) {
+  const key = typeof v.props["data-key"] === "string" ? v.props["data-key"] : void 0;
+  return key ? geom.nodes[key] : void 0;
+}
+function extent(v, geom) {
+  const g = geometryOf(v, geom);
+  if (g) return g.height > EPS2 ? [g.top, g.top + g.height] : null;
+  let span = null;
+  for (const c of v.children) {
+    if (typeof c === "string") continue;
+    const e = extent(c, geom);
+    if (e) span = span ? [Math.min(span[0], e[0]), Math.max(span[1], e[1])] : e;
+  }
+  return span;
+}
+function sideBySide(children, geom) {
+  const spans = children.filter((c) => typeof c !== "string").map((c) => extent(c, geom)).filter((e) => e !== null).sort((a, b) => a[0] - b[0]);
+  let bottom = Number.NEGATIVE_INFINITY;
+  for (const [top, end] of spans) {
+    if (top < bottom - EPS2) return true;
+    bottom = Math.max(bottom, end);
+  }
+  return false;
+}
+function removeAbove(children, w) {
+  let start = null;
+  let end = 0;
+  let count = 0;
+  for (let i = 0; i < children.length; i++) {
+    const c = children[i];
+    if (typeof c === "string") {
+      if (c.trim()) return 0;
+      continue;
+    }
+    const g = geometryOf(c, w.geom);
+    if (!g) return 0;
+    if (g.top + g.height > w.from + EPS2) {
+      if (start === null) return 0;
+      w.dropped += g.top - margin(c, "top") - start;
+      return i;
+    }
+    start ??= g.top - margin(c, "top");
+    end = g.top + g.height + margin(c, "bottom");
+    count = i + 1;
+  }
+  if (start === null) return 0;
+  w.dropped += end - start;
+  return count;
+}
+function margin(v, side) {
+  let value = 0;
+  for (const declaration of styleString2(v.props.style).split(";")) {
+    const m = /^\s*margin(?:-(top|bottom|left|right))?\s*:\s*(.+?)\s*$/i.exec(declaration);
+    if (!m) continue;
+    if (m[1]) {
+      if (m[1].toLowerCase() === side) value = pixels(m[2]);
+    } else {
+      const parts = m[2].split(/\s+/);
+      value = pixels(side === "top" ? parts[0] : parts.length >= 3 ? parts[2] : parts[0]);
+    }
+  }
+  return value;
+}
+function pixels(length2) {
+  const m = /^(-?\d*\.?\d+)(px)?$/i.exec(length2.trim());
+  return m && (m[2] || Number(m[1]) === 0) ? Number(m[1]) : 0;
+}
 function blank(v, height) {
   const kept = styleString2(v.props.style).split(";").map((d) => d.trim()).filter((d) => d && !/^height\s*:/i.test(d));
-  kept.push(`height:${round3(height)}px`);
+  kept.push(`height:${round4(height)}px`);
   return { ...v, props: { ...v.props, style: kept.join(";") }, children: [] };
 }
 function cropTable(table, w, rows) {
@@ -1050,7 +1265,7 @@ function cropTable(table, w, rows) {
   };
   return rewrite(table);
 }
-function round3(n) {
+function round4(n) {
   return Math.round(n * 100) / 100;
 }
 
@@ -1067,15 +1282,17 @@ function box(left, top, width, height, children, clip = true, bleed = 0) {
   return { kind: { type: "View" }, style, children };
 }
 function headerOnly(v) {
-  const clone = structuredClone(v);
-  walkVNodes2(clone, (n) => {
-    if (n.tag === "table") {
-      n.children = n.children.filter((c) => typeof c !== "string" && (c.tag === "colgroup" || c.tag === "thead"));
-      return false;
-    }
-    return true;
+  if (v.tag === "table") {
+    return { ...v, children: v.children.filter((c) => typeof c !== "string" && (c.tag === "colgroup" || c.tag === "thead")) };
+  }
+  let changed = false;
+  const children = v.children.map((c) => {
+    if (typeof c === "string") return c;
+    const next = headerOnly(c);
+    if (next !== c) changed = true;
+    return next;
   });
-  return clone;
+  return changed ? { ...v, children } : v;
 }
 function sectionsByKey(doc) {
   const map = /* @__PURE__ */ new Map();
@@ -1097,10 +1314,16 @@ function emitPages(input) {
   const bleed = page.margins.right;
   const bodyDependsOnPage = isPageDependent(resolved.body);
   const cache = /* @__PURE__ */ new Map();
+  const rendered = /* @__PURE__ */ new Map();
+  const treeOf = (section, opts) => {
+    if (bodyDependsOnPage) return renderNode2(section, opts, width);
+    if (!rendered.has(section.key)) rendered.set(section.key, renderNode2(section, opts, width));
+    return rendered.get(section.key);
+  };
   const translateSection = (section, opts, from, to) => {
     const cacheKey = `${section.key}|${from}|${to}`;
     if (!bodyDependsOnPage && cache.has(cacheKey)) return cache.get(cacheKey);
-    const v = renderNode2(section, opts, width);
+    const v = treeOf(section, opts);
     if (!v) return null;
     const geom = geometry[section.key];
     const cropped = geom ? cropToWindow(v, geom, from, to) : { node: v, offset: 0 };
@@ -1110,6 +1333,16 @@ function emitPages(input) {
     if (!bodyDependsOnPage) cache.set(cacheKey, out);
     return out;
   };
+  const headers = /* @__PURE__ */ new Map();
+  const repeatedHeader = (tableKey, table, opts, headerWidth) => {
+    const key = `${tableKey}|${headerWidth}`;
+    if (!bodyDependsOnPage && headers.has(key)) return headers.get(key);
+    const v = renderNode2(table, opts, headerWidth);
+    const t = v ? translate(headerOnly(v), ctx) : null;
+    const node = t ? t.node : null;
+    if (!bodyDependsOnPage) headers.set(key, node);
+    return node;
+  };
   const region = (sections, opts) => {
     const out = [];
     for (const s of sections) {
@@ -1123,7 +1356,7 @@ function emitPages(input) {
   return paged.pages.map((p) => {
     const opts = { ...renderOpts, page: { number: p.number, total: paged.totalPages } };
     const children = [];
-    if (input.watermark) children.push(watermarkNode(input.watermark));
+    for (const mark of input.watermarks ?? []) if (mark && (mark.placement ?? "center") === "center") children.push(watermarkNode(mark));
     const headerSections = p.first && resolved.header.firstPage ? resolved.header.firstPage : resolved.header.default;
     if (headerSections.length && page.headerHeight > 0) {
       children.push(box(page.margins.left, page.headerTop, width, page.headerHeight, region(headerSections, opts)));
@@ -1137,10 +1370,8 @@ function emitPages(input) {
       for (const r of f.repeatHeaders) {
         const table = byKey.get(r.tableKey);
         if (!table) continue;
-        const v = renderNode2(table, opts, r.width);
-        if (!v) continue;
-        const t = translate(headerOnly(v), ctx);
-        if (t) inner.push(box(r.left, 0, r.width, r.height, [t.node]));
+        const header = repeatedHeader(r.tableKey, table, opts, r.width);
+        if (header) inner.push(box(r.left, 0, r.width, r.height, [header]));
       }
       const content = translateSection(section, opts, f.from, f.to);
       if (content) {
@@ -1158,6 +1389,14 @@ function emitPages(input) {
     if (footerSections.length && page.footerHeight > 0) {
       children.push(box(page.margins.left, page.footerTop, width, page.footerHeight, region(footerSections, opts)));
     }
+    for (const mark of input.watermarks ?? []) {
+      if (!mark || (mark.placement ?? "center") !== "bottom") continue;
+      const node = creditNode(mark, width, ctx);
+      if (!node) continue;
+      const h = mark.fontSize * 1.6;
+      const top = Math.max(page.height - h, page.height - page.margins.bottom + Math.max(0, (page.margins.bottom - h) / 2));
+      children.push(box(page.margins.left, top, width, h, [node]));
+    }
     return {
       kind: {
         type: "Page",
@@ -1220,12 +1459,15 @@ async function buildFormeDocument(opts) {
     return out;
   };
   const children = [];
-  const mark = watermarkFor(license);
-  if (mark) children.push(watermarkNode(mark));
+  const marks = [watermarkFor(license), opts.watermark].filter((m) => Boolean(m));
+  for (const mark of marks) if ((mark.placement ?? "center") === "center") children.push(watermarkNode(mark));
   const header = translate2(resolved.header.default);
   if (header.length) children.push({ kind: { type: "Fixed", position: "Header" }, style: {}, children: header });
   const footer = translate2(resolved.footer.default);
-  if (footer.length) children.push({ kind: { type: "Fixed", position: "Footer" }, style: {}, children: footer });
+  const credits = marks.filter((m) => (m.placement ?? "center") === "bottom").map((m) => creditNode(m, geom.contentWidth, ctx)).filter((n) => Boolean(n));
+  if (footer.length || credits.length) {
+    children.push({ kind: { type: "Fixed", position: "Footer" }, style: {}, children: [...footer, ...credits] });
+  }
   children.push(...translate2(resolved.body));
   const page = {
     kind: {
@@ -1282,6 +1524,20 @@ async function renderPdf(opts) {
 }
 async function renderPdfPaginated(opts) {
   const started = Date.now();
+  const layout = await layoutPaginated(opts);
+  const drawn = await layout.draw();
+  return {
+    pdf: drawn.pdf,
+    pages: drawn.pages,
+    layout: drawn.layout,
+    paged: layout.paged,
+    geometry: layout.geometry,
+    warnings: drawn.warnings,
+    durationMs: Date.now() - started
+  };
+}
+var MEASURE_BATCH_ROWS = 1e3;
+async function layoutPaginated(opts) {
   const license = await resolveLicenseStatus(opts.license !== void 0 ? { license: opts.license } : {});
   const { template } = migrateTemplate(opts.template);
   const theme = mergeTheme(opts.theme);
@@ -1316,17 +1572,15 @@ async function renderPdfPaginated(opts) {
   };
   const ctx = { warnings: /* @__PURE__ */ new Set(), suppressPageBreaks: true };
   const render = opts.renderer ?? defaultRenderer;
-  const measure = async (sections) => {
-    if (!sections.length) return {};
+  const layoutSections = async (list) => {
+    if (!list.length) return {};
     const measured = [];
-    for (const section of sections) {
-      const v = renderNode3(section, renderOpts, geom.contentWidth);
-      if (!v) continue;
-      const t = translate(v, ctx);
+    for (const { section, tree } of list) {
+      const t = translate(tree, ctx);
       if (t) measured.push({ section, node: t.node, ann: t.ann });
     }
     if (!measured.length) return {};
-    const doc2 = {
+    const doc = {
       children: [
         {
           kind: {
@@ -1345,53 +1599,86 @@ async function renderPdfPaginated(opts) {
       defaultPage: { size: "A4", margin: { top: 54, right: 54, bottom: 54, left: 54 }, wrap: true },
       defaultStyle: baseStyle(theme)
     };
-    if (opts.fonts?.length) doc2.fonts = fontEntries(opts.fonts);
-    const result2 = await render(doc2);
-    const pages2 = result2.layout?.pages ?? [];
+    if (opts.fonts?.length) doc.fonts = fontEntries(opts.fonts);
+    const result = await render(doc);
+    const pages = result.layout?.pages ?? [];
     const scale2 = 1 / PX_TO_PT_LOCAL;
-    const scaled = pages2[0]?.elements.map((e) => scaleElement(e, scale2)) ?? [];
+    const scaled = pages[0]?.elements.map((e) => scaleElement(e, scale2)) ?? [];
     return geometryFromLayout(measured, scaled, geom.contentWidth);
   };
+  const batchRows = Math.max(1, opts.measureBatchRows ?? MEASURE_BATCH_ROWS);
+  const measure = async (sections) => {
+    const parts = [];
+    for (const section of sections) {
+      const tree = renderNode3(section, renderOpts, geom.contentWidth);
+      if (tree) parts.push({ section, tree, long: longTables(tree, batchRows) });
+    }
+    const out = await layoutSections(parts.map((p) => ({ section: p.section, tree: p.long.length ? sliceTables(p.tree, p.long, 0, batchRows) : p.tree })));
+    for (const p of parts) {
+      const first = out[p.section.key];
+      if (!p.long.length || !first) continue;
+      const most = Math.max(...p.long.map((t) => t.bodyRows));
+      const batches = [];
+      for (let start = batchRows; start < most; start += batchRows) {
+        batches.push({ section: { ...p.section, key: `${p.section.key}#rows-${start}` }, tree: sliceTables(p.tree, p.long, start, batchRows) });
+      }
+      const measured = [];
+      for (let i = 0; i < batches.length; i += BATCHES_PER_PASS) {
+        const chunk = batches.slice(i, i + BATCHES_PER_PASS);
+        const got = await layoutSections(chunk);
+        for (const b of chunk) {
+          const g = got[b.section.key];
+          if (g) measured.push(g);
+        }
+      }
+      out[p.section.key] = stitchTables(first, p.long, measured);
+    }
+    return out;
+  };
   const geometry = await measure(resolved.body);
   const regionGeometry = await measure([...resolved.header.default, ...resolved.header.firstPage ?? [], ...resolved.footer.default, ...resolved.footer.firstPage ?? []]);
   const paged = paginate({ document: resolved, geometry, page: geom, minPages: 1, regionGeometry });
-  const pages = emitPages({
-    resolved,
-    paged,
-    page: geom,
-    renderOpts,
-    ctx,
-    geometry,
-    background: template.page.background ? resolveValue(template.page.background, theme, "#ffffff") : void 0,
-    watermark: watermarkFor(license)
-  });
-  const doc = {
-    children: pages,
-    metadata: { title: template.name, creator: producerString(license), ...opts.metadata ?? {} },
-    defaultPage: { size: "A4", margin: { top: 54, right: 54, bottom: 54, left: 54 }, wrap: true },
-    defaultStyle: baseStyle(theme)
-  };
-  if (opts.fonts?.length) doc.fonts = fontEntries(opts.fonts);
-  if (opts.tagged) doc.tagged = true;
-  if (opts.pdfUa) doc.pdfUa = true;
-  if (opts.pdfA) doc.pdfa = opts.pdfA;
-  const result = await render(doc);
-  const layout = result.layout ?? null;
+  const background = template.page.background ? resolveValue(template.page.background, theme, "#ffffff") : void 0;
   return {
-    pdf: result.pdf,
-    pages: layout?.pages.length ?? paged.totalPages,
-    layout,
     paged,
     geometry,
-    warnings: [
-      ...ctx.warnings,
-      ...resolved.warnings.map((w) => w.message),
-      ...paged.warnings.map((w) => w.message),
-      ...result.warnings ?? []
-    ],
-    durationMs: Date.now() - started
+    async draw(range) {
+      const from = Math.max(0, range?.from ?? 0);
+      const to = Math.min(paged.pages.length, range?.to ?? paged.pages.length);
+      const pages = emitPages({
+        resolved,
+        // `totalPages` stays the whole document's, so a later file still counts
+        // its pages as part of the whole.
+        paged: { ...paged, pages: paged.pages.slice(from, to) },
+        page: geom,
+        renderOpts,
+        ctx,
+        geometry,
+        background,
+        watermarks: [watermarkFor(license), opts.watermark]
+      });
+      const doc = {
+        children: pages,
+        metadata: { title: template.name, creator: producerString(license), ...opts.metadata ?? {} },
+        defaultPage: { size: "A4", margin: { top: 54, right: 54, bottom: 54, left: 54 }, wrap: true },
+        defaultStyle: baseStyle(theme)
+      };
+      if (opts.fonts?.length) doc.fonts = fontEntries(opts.fonts);
+      if (opts.tagged) doc.tagged = true;
+      if (opts.pdfUa) doc.pdfUa = true;
+      if (opts.pdfA) doc.pdfa = opts.pdfA;
+      const result = await render(doc);
+      const layout = result.layout ?? null;
+      return {
+        pdf: result.pdf,
+        pages: layout?.pages.length ?? to - from,
+        layout,
+        warnings: [...ctx.warnings, ...resolved.warnings.map((w) => w.message), ...paged.warnings.map((w) => w.message), ...result.warnings ?? []]
+      };
+    }
   };
 }
+var BATCHES_PER_PASS = 2;
 var PX_TO_PT_LOCAL = 72 / 96;
 function scaleElement(el, scale2) {
   return {
@@ -1429,10 +1716,12 @@ export {
   setEngineLoader,
   renderPdf,
   renderPdfPaginated,
+  MEASURE_BATCH_ROWS,
+  layoutPaginated,
   BroadPaper,
   configure,
   resolveLicenseStatus2 as resolveLicenseStatus,
   verifyLicense,
   parseLicense
 };
-//# sourceMappingURL=chunk-2PT5WRKQ.js.map
+//# sourceMappingURL=chunk-2C3MAW2U.js.map