@jasy/pdf 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/renderer/flow-renderer.d.ts

@@ -0,0 +1,16 @@
+import { FlowElement, FlowPieceElement } from "../elements/layout/flow-element.js";
+import { RegionElement } from "../elements/layout/region-element.js";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { IRNode } from "../ir/display-list.js";
+import { type RenderScope } from "../utils/renderer-registry.js";
+/** A Flow draws the page it made (laid out in place, in a box with a height). */
+export declare class FlowRenderer {
+    static render(flow: FlowElement, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
+}
+/** One page of a Flow: its template, whose Regions draw what they hold. */
+export declare class FlowPieceRenderer {
+    static render(piece: FlowPieceElement, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
+}
+export declare class RegionRenderer {
+    static render(region: RegionElement, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
+}

package/dist/renderer/flow-renderer.js

@@ -0,0 +1,21 @@
+import { RendererRegistry, within } from "../utils/renderer-registry.js";
+/** A Flow draws the page it made (laid out in place, in a box with a height). */
+export class FlowRenderer {
+    static async render(flow, objectManager, scope) {
+        const { x, y, piece } = flow.getProps();
+        return piece ? RendererRegistry.render(piece, objectManager, within(scope, { x, y })) : [];
+    }
+}
+/** One page of a Flow: its template, whose Regions draw what they hold. */
+export class FlowPieceRenderer {
+    static async render(piece, objectManager, scope) {
+        const { x, y, child } = piece.getProps();
+        return RendererRegistry.render(child, objectManager, within(scope, { x, y }));
+    }
+}
+export class RegionRenderer {
+    static async render(region, objectManager, scope) {
+        const { x, y, child } = region.getProps();
+        return child ? RendererRegistry.render(child, objectManager, within(scope, { x, y })) : [];
+    }
+}

package/dist/renderer/form-field-renderer.d.ts

@@ -1,3 +1,4 @@
+import type { RenderScope } from "../utils/renderer-registry.js";
 import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 import { TextFieldElement } from "../elements/forms/text-field-element.js";
 import { CheckboxElement } from "../elements/forms/checkbox-element.js";
@@ -15,6 +16,6 @@ type FormFieldElement = TextFieldElement | CheckboxElement | RadioElement | Choi
  * discriminates downstream).
  */
 export declare class FormFieldRenderer {
-    static render(element: FormFieldElement, _objectManager: PDFObjectManager): Promise<IRNode[]>;
+    static render(element: FormFieldElement, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
 }
 export {};

package/dist/renderer/form-field-renderer.js

@@ -5,8 +5,21 @@
  * discriminates downstream).
  */
 export class FormFieldRenderer {
-    static async render(element, _objectManager) {
-        const { x, y, width, height, spec, style } = element.getProps();
-        return [{ type: "formfield", x, y, width, height, field: spec, style }];
+    static async render(element, objectManager, scope) {
+        const props = element.getProps();
+        const { x: ownX, y: ownY, width, height, spec, style } = props;
+        const font = "font" in props ? props.font : undefined;
+        // Its own position is relative to `scope.origin`; the IR wants page coordinates.
+        const x = scope.origin.x + (ownX ?? 0);
+        const y = scope.origin.y + (ownY ?? 0);
+        // Tagged: the widget goes into a /Form element, named by its tooltip (/TU) or else its field name
+        // (PDF/UA 7.18.1, 7.18.4). A radio button is one answer of its group.
+        const name = spec.kind === "radio" ? `${spec.group}: ${spec.value}` : spec.name;
+        const structKey = objectManager.struct.enabled
+            ? objectManager.struct.openElement(element.structId, "Form", {
+                alt: spec.tooltip === undefined ? name : undefined,
+            })
+            : undefined;
+        return [{ type: "formfield", x, y, width, height, field: spec, style, structKey, font }];
     }
 }

package/dist/renderer/image-renderer.d.ts

@@ -1,6 +1,7 @@
+import type { RenderScope } from "../utils/renderer-registry.js";
 import { ImageElement } from "../elements/image-element.js";
 import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 import { IRNode } from "../ir/display-list.js";
 export declare class ImageRenderer {
-    static render(imageElement: ImageElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+    static render(imageElement: ImageElement, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
 }

package/dist/renderer/image-renderer.js

@@ -1,15 +1,20 @@
 import { BoxFit } from "../elements/image-element.js";
 import { bytesFromLatin1 } from "../utils/bytes.js";
-import { applyContainFit, applyCoverFit, applyFillFit, applyFitNone, decodePngToRgbFlate, } from "../utils/image-helper.js";
+import { applyContainFit, applyCoverFit, applyFillFit, applyFitNone, decodePngToRgbFlate, jpegColor, naturalSize, } from "../utils/image-helper.js";
 import { isRounded } from "../ir/display-list.js";
 export class ImageRenderer {
-    static async render(imageElement, objectManager) {
+    static async render(imageElement, objectManager, scope) {
         // Load the image and convert it in a binary string
-        let { x, y, width, height, image, fit, radius, alt } = imageElement.getProps();
+        const { x: ownX, y: ownY, width, height, image, fit, radius, align, alt, } = imageElement.getProps();
+        // Its own position is relative to `scope.origin`; the IR wants page coordinates.
+        const x = scope.origin.x + (ownX ?? 0);
+        const y = scope.origin.y + (ownY ?? 0);
         await image.init(); // Load and initialize the image
         const imageType = await image.getImageType(); // For the moment we can handle `png` and `jpg/jpeg` files
         const fileData = await image.getFileData();
         const dimensions = await image.getImageDimensions();
+        // Laid out at its own size in points; the pixels only describe the XObject.
+        const own = naturalSize(dimensions);
         if (!fileData) {
             throw new Error("File data cannot be `null`");
         }
@@ -17,71 +22,46 @@ export class ImageRenderer {
         // so decode it to raw DeviceRGB samples that the FlateDecode XObject path expects.
         let embedData = fileData;
         let smask;
+        // A JPEG is embedded as it is, so it keeps the color space it was saved in; a PNG becomes RGB.
+        const color = imageType === "DCTDecode" ? jpegColor(bytesFromLatin1(fileData)) : undefined;
         if (imageType === "FlateDecode") {
             const decoded = await decodePngToRgbFlate(bytesFromLatin1(fileData));
             embedData = decoded.data;
             smask = decoded.smask;
         }
-        // Now we check the `fit` property and changing the dimensions of the image
-        // Optionally we must add an overflow container
-        let mustCreateOverflowContainer = false;
-        const containerDimensions = JSON.parse(JSON.stringify({ x, y, width, height })); // Deep clone images dimensions
-        switch (fit) {
-            case BoxFit.cover:
-                mustCreateOverflowContainer = true;
-                const fitCoverResult = applyCoverFit(dimensions.width, dimensions.height, width ?? 0, height ?? 0);
-                x += fitCoverResult.offsetX;
-                y += fitCoverResult.offsetY;
-                width = fitCoverResult.width;
-                height = fitCoverResult.height;
-                break;
-            case BoxFit.contain:
-                mustCreateOverflowContainer = true;
-                const fitContainResult = applyContainFit(dimensions.width, dimensions.height, width ?? 0, height ?? 0);
-                x += fitContainResult.offsetX;
-                y += fitContainResult.offsetY;
-                width = fitContainResult.width;
-                height = fitContainResult.height;
-                break;
-            case BoxFit.none:
-                const fitNoneResult = applyFitNone(dimensions.width, dimensions.height, width ?? 0, height ?? 0);
-                x += fitNoneResult.offsetX;
-                y += fitNoneResult.offsetY;
-                width = fitNoneResult.width;
-                height = fitNoneResult.height;
-                break;
-            case BoxFit.fill:
-                const fitFillResult = applyFillFit(width ?? 0, height ?? 0);
-                width = fitFillResult.width;
-                height = fitFillResult.height;
-        }
-        // A radius rounds the image BOX (the element frame), so it clips to that frame too -
-        // independent of the cover/contain overflow clip.
-        const wantsClip = mustCreateOverflowContainer || isRounded(radius);
+        // The box laid out for it; `fit` decides what is drawn in it and where.
+        const box = {
+            x,
+            y,
+            width: width ?? own.width,
+            height: height ?? own.height,
+        };
+        const fitted = fit === BoxFit.cover
+            ? applyCoverFit(own.width, own.height, box.width, box.height, align)
+            : fit === BoxFit.contain
+                ? applyContainFit(own.width, own.height, box.width, box.height, align)
+                : fit === BoxFit.none
+                    ? applyFitNone(own.width, own.height, box.width, box.height, align)
+                    : applyFillFit(box.width, box.height);
+        // Anything but `fill` may leave the box, so it is clipped to it; a radius rounds the box too.
+        const wantsClip = fit !== BoxFit.fill || isRounded(radius);
         // The fitted geometry becomes a display-list primitive; the backend registers
         // the XObject and emits the placement (+ clip, rounded when a radius is set).
         const node = {
             type: "image",
-            x,
-            y,
-            width: width,
-            height: height,
+            x: x + fitted.offsetX,
+            y: y + fitted.offsetY,
+            width: fitted.width,
+            height: fitted.height,
             intrinsicWidth: dimensions.width,
             intrinsicHeight: dimensions.height,
             data: embedData,
             imageType,
+            ...(color ? { color } : {}),
+            ...(dimensions.orientation ? { orientation: dimensions.orientation } : {}),
             ...(smask ? { smask } : {}),
             ...(radius ? { radius } : {}),
-            ...(wantsClip
-                ? {
-                    clip: {
-                        x: containerDimensions.x,
-                        y: containerDimensions.y,
-                        width: containerDimensions.width,
-                        height: containerDimensions.height,
-                    },
-                }
-                : {}),
+            ...(wantsClip ? { clip: box } : {}),
         };
         // Accessible tagging: an image WITH alt text is a Figure; without, it stays untagged and the backend
         // treats it as decoration (an Artifact). One struct element per image.

package/dist/renderer/index.d.ts

@@ -10,3 +10,5 @@ export * from "./line-renderer.js";
 export * from "./row-renderer.js";
 export * from "./svg-renderer.js";
 export * from "./canvas-renderer.js";
+export * from "./flow-renderer.js";
+export * from "./column-break-renderer.js";

package/dist/renderer/index.js

@@ -10,3 +10,5 @@ export * from "./line-renderer.js";
 export * from "./row-renderer.js";
 export * from "./svg-renderer.js";
 export * from "./canvas-renderer.js";
+export * from "./flow-renderer.js";
+export * from "./column-break-renderer.js";

package/dist/renderer/keep-together-renderer.d.ts

@@ -1,10 +1,11 @@
 import { KeepTogetherElement } from "../elements/layout/keep-together-element.js";
 import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 import { IRNode } from "../ir/display-list.js";
+import { type RenderScope } from "../utils/renderer-registry.js";
 /**
  * A `keepTogether` is layout-transparent: it just renders its child. All of its work happens in the
  * layout pass (`fragment`), never here.
  */
 export declare class KeepTogetherRenderer {
-    static render(group: KeepTogetherElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+    static render(group: KeepTogetherElement, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
 }

package/dist/renderer/keep-together-renderer.js

@@ -4,9 +4,8 @@ import { RendererRegistry } from "../utils/renderer-registry.js";
  * layout pass (`fragment`), never here.
  */
 export class KeepTogetherRenderer {
-    static async render(group, objectManager) {
+    static async render(group, objectManager, scope) {
         const { child } = group.getProps();
-        const renderer = RendererRegistry.getRenderer(child);
-        return renderer(child, objectManager);
+        return RendererRegistry.render(child, objectManager, scope);
     }
 }

package/dist/renderer/line-renderer.d.ts

@@ -1,6 +1,7 @@
+import type { RenderScope } from "../utils/renderer-registry.js";
 import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 import { LineElement } from "../elements/index.js";
 import { IRNode } from "../ir/display-list.js";
 export declare class LineRenderer {
-    static render(lineElement: LineElement, _objectManager: PDFObjectManager): Promise<IRNode[]>;
+    static render(lineElement: LineElement, _objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
 }

package/dist/renderer/line-renderer.js

@@ -1,6 +1,11 @@
 export class LineRenderer {
-    static async render(lineElement, _objectManager) {
-        const { x, y, xEnd, yEnd, color, strokeWidth } = lineElement.getProps();
+    static async render(lineElement, _objectManager, scope) {
+        const { x: ownX, y: ownY, xEnd: ownXEnd, yEnd: ownYEnd, color, strokeWidth, } = lineElement.getProps();
+        // Its own position is relative to `scope.origin`; the IR wants page coordinates.
+        const x = scope.origin.x + (ownX ?? 0);
+        const y = scope.origin.y + (ownY ?? 0);
+        const xEnd = scope.origin.x + (ownXEnd ?? 0);
+        const yEnd = scope.origin.y + (ownYEnd ?? 0);
         const node = {
             type: "line",
             x1: x,

package/dist/renderer/link-renderer.d.ts

@@ -1,6 +1,7 @@
 import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 import { LinkElement } from "../elements/layout/link-element.js";
+import { type RenderScope } from "../utils/renderer-registry.js";
 import { IRNode } from "../ir/display-list.js";
 export declare class LinkRenderer {
-    static render(element: LinkElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+    static render(element: LinkElement, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
 }

package/dist/renderer/link-renderer.js

@@ -1,11 +1,42 @@
 import { RendererRegistry } from "../utils/renderer-registry.js";
+import { TextElement } from "../elements/text-element.js";
+/** The text a link covers, as read - not run by run, where a justified line is one run per word. */
+function textOf(element) {
+    if (element instanceof TextElement) {
+        return [
+            element
+                .getProps()
+                .spans.map((s) => s.content)
+                .join(""),
+        ];
+    }
+    return element.layoutChildren().flatMap(textOf);
+}
 export class LinkRenderer {
-    static async render(element, objectManager) {
-        const { href, dest, child, x, y, width, height } = element.getProps();
-        const renderer = RendererRegistry.getRenderer(child);
-        const childNodes = await renderer(child, objectManager);
+    static async render(element, objectManager, scope) {
+        const { href, dest, child, x: ownX, y: ownY, width, height } = element.getProps();
+        // Its own position is relative to `scope.origin`; the IR wants page coordinates.
+        const x = scope.origin.x + (ownX ?? 0);
+        const y = scope.origin.y + (ownY ?? 0);
+        const renderChild = () => RendererRegistry.render(child, objectManager, scope);
         // The child draws normally; a Link IR node carries the clickable rect + target (external href or
         // internal dest) for the page renderer to emit as a /Link annotation (no content-stream ops itself).
-        return [...childNodes, { type: "link", x, y, width, height, href, dest }];
+        if (!objectManager.struct.enabled) {
+            return [...(await renderChild()), { type: "link", x, y, width, height, href, dest }];
+        }
+        // Tagged: the link's content sits in a /Link element, which also takes the annotation, and the
+        // annotation describes itself by the text it covers (PDF/UA 7.18.5). A split link is ONE element.
+        const struct = objectManager.struct;
+        const structKey = struct.openElement(element.structId, "Link");
+        struct.push(structKey);
+        let childNodes;
+        try {
+            childNodes = await renderChild();
+        }
+        finally {
+            struct.pop();
+        }
+        const alt = textOf(child).join(" ").replace(/\s+/g, " ").trim() || (href ?? dest ?? "");
+        return [...childNodes, { type: "link", x, y, width, height, href, dest, structKey, alt }];
     }
 }

package/dist/renderer/padding-renderer.d.ts

@@ -1,6 +1,7 @@
 import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { type RenderScope } from "../utils/renderer-registry.js";
 import { PaddingElement } from "../elements/layout/padding-element.js";
 import { IRNode } from "../ir/display-list.js";
 export declare class PaddingRenderer {
-    static render(paddingElement: PaddingElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+    static render(paddingElement: PaddingElement, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
 }

package/dist/renderer/padding-renderer.js

@@ -1,8 +1,8 @@
-import { RendererRegistry } from "../utils/renderer-registry.js";
+import { RendererRegistry, within } from "../utils/renderer-registry.js";
 export class PaddingRenderer {
-    static async render(paddingElement, objectManager) {
-        const { child } = paddingElement.getProps();
-        const renderer = RendererRegistry.getRenderer(child);
-        return renderer(child, objectManager);
+    static async render(paddingElement, objectManager, scope) {
+        const { x, y, child } = paddingElement.getProps();
+        // Its child is placed relative to its own top-left, inset by the margins.
+        return RendererRegistry.render(child, objectManager, within(scope, { x, y }));
     }
 }

package/dist/renderer/page-break-renderer.d.ts

@@ -1,14 +1,15 @@
+import type { RenderScope } from "../utils/renderer-registry.js";
 import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 import { PageBreakElement } from "../elements/layout/page-break-element.js";
 import { IRNode } from "../ir/display-list.js";
 /**
  * A `PageBreak` draws nothing - the pagination packer consumes it at the cut, so in a vertical flow it
  * never reaches this pass. Reaching it therefore means the break was ineffective: it sat somewhere that
- * does not paginate, like inside a horizontal `Row` (a row is one line, you cannot split it across
- * pages - CSS and react-pdf ignore a forced break there too). We degrade to drawing nothing, but warn
- * once so the mistake is not silent. This one choke-point catches every ineffective break; no element
- * needs a special case.
+ * does not paginate - inside a horizontal `Row` (one line; CSS and react-pdf ignore a forced break there
+ * too), or inside a `PageBuilder`, whose content is built for the page it lands on and placed whole. We
+ * degrade to drawing nothing, but warn so the mistake is not silent. This one choke-point catches every
+ * ineffective break; no element needs a special case.
  */
 export declare class PageBreakRenderer {
-    static render(_element: PageBreakElement, _objectManager: PDFObjectManager): Promise<IRNode[]>;
+    static render(element: PageBreakElement, objectManager: PDFObjectManager, _scope: RenderScope): Promise<IRNode[]>;
 }

package/dist/renderer/page-break-renderer.js

@@ -1,15 +1,22 @@
 /**
  * A `PageBreak` draws nothing - the pagination packer consumes it at the cut, so in a vertical flow it
  * never reaches this pass. Reaching it therefore means the break was ineffective: it sat somewhere that
- * does not paginate, like inside a horizontal `Row` (a row is one line, you cannot split it across
- * pages - CSS and react-pdf ignore a forced break there too). We degrade to drawing nothing, but warn
- * once so the mistake is not silent. This one choke-point catches every ineffective break; no element
- * needs a special case.
+ * does not paginate - inside a horizontal `Row` (one line; CSS and react-pdf ignore a forced break there
+ * too), or inside a `PageBuilder`, whose content is built for the page it lands on and placed whole. We
+ * degrade to drawing nothing, but warn so the mistake is not silent. This one choke-point catches every
+ * ineffective break; no element needs a special case.
  */
 export class PageBreakRenderer {
-    static async render(_element, _objectManager) {
-        console.warn("PageBreak had no effect: it is not in a paginating flow (e.g. it is inside a Row, which is a " +
-            "single horizontal line). Put the break as a sibling in a Column to break after that content.");
+    static async render(element, objectManager, _scope) {
+        objectManager.diagnostics.report({
+            code: "page-break-ignored",
+            severity: "warning",
+            message: "PageBreak had no effect: it is not in a paginating flow - it is inside a Row (a single " +
+                "horizontal line) or a PageBuilder (built for one page and placed whole, Columns inside it " +
+                "included). Move the break out, into a Column that flows across pages.",
+            about: element,
+            page: element.page,
+        });
         return [];
     }
 }

package/dist/renderer/page-builder-renderer.d.ts

@@ -1,6 +1,7 @@
 import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 import { PageBuilderElement } from "../elements/layout/page-builder-element.js";
+import { type RenderScope } from "../utils/renderer-registry.js";
 import { IRNode } from "../ir/display-list.js";
 export declare class PageBuilderRenderer {
-    static render(element: PageBuilderElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+    static render(element: PageBuilderElement, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
 }

package/dist/renderer/page-builder-renderer.js

@@ -1,11 +1,10 @@
 import { RendererRegistry } from "../utils/renderer-registry.js";
 export class PageBuilderRenderer {
-    static async render(element, objectManager) {
+    static async render(element, objectManager, scope) {
         // `composed` is whatever the closure built for THIS page during the render pass's layout.
         const { composed } = element.getProps();
         if (!composed)
             return [];
-        const renderer = RendererRegistry.getRenderer(composed);
-        return renderer(composed, objectManager);
+        return RendererRegistry.render(composed, objectManager, scope);
     }
 }

package/dist/renderer/page-renderer.js

@@ -1,10 +1,19 @@
 import { pageFormats, PageSize } from "../constants/page-sizes.js";
+import { resolvePageContentBox } from "../elements/page-element.js";
 import { RendererRegistry } from "../utils/renderer-registry.js";
 import { Orientation } from "./pdf-config.js";
 import { PdfBackend } from "./pdf-backend.js";
+import { PositionedRenderer } from "./positioned-renderer.js";
 export class PageRenderer {
     static async render(page, objectManager) {
         const { children, config, header, footer } = page.getProps();
+        RendererRegistry.beginPage(objectManager); // an element may be drawn once per page
+        // A page is the outermost box: its children's offsets are page coordinates. Its content box is the
+        // frame a `Positioned` with no `relative` ancestor was placed against.
+        const scope = {
+            origin: { x: 0, y: 0 },
+            frame: resolvePageContentBox(config).origin, // config is resolved by layout
+        };
         // Header (top band) and footer (bottom band) sit around the body and repeat on every
         // physical page; they are placed by `PageElement.calculateLayout` / the page driver.
         const renderables = [...(header ? [header] : []), ...children, ...(footer ? [footer] : [])];
@@ -18,11 +27,8 @@ export class PageRenderer {
         // Collect the whole page as a display list (top-left coordinates), flip it to PDF
         // coordinates at this one seam, then serialize once. Serializing registers the
         // fonts/images used below, so it must run before the resource section.
-        const nodes = [];
-        for (const element of renderables) {
-            const renderer = RendererRegistry.getRenderer(element);
-            nodes.push(...(await renderer(element, objectManager)));
-        }
+        // The page is the outermost stacking context: header, body and footer share one paint order.
+        const nodes = await PositionedRenderer.paintStacked(renderables, objectManager, scope);
         // Accessible tagging: one struct context per page (allocates its StructParents index), threaded into
         // serialize so each drawable node is wrapped in marked content. Undefined = tagging off (byte-identical).
         const structCtx = objectManager.struct.enabled ? objectManager.struct.beginPage() : undefined;
@@ -72,21 +78,35 @@ export class PageRenderer {
         const num = (n) => Number(n.toFixed(2));
         const annotRefs = [];
         for (const node of flipped) {
+            if (node.type !== "link" && node.type !== "formfield")
+                continue;
+            // Tagged, every annotation names its structure element (PDF/UA 7.18).
+            const structKey = structCtx ? node.structKey : undefined;
+            const structParent = structKey === undefined ? undefined : objectManager.struct.annotationParent(structKey);
+            const tag = (obj) => {
+                if (structKey !== undefined) {
+                    objectManager.struct.linkAnnotation(structKey, obj, structCtx.structParents);
+                }
+            };
             // A form field: build its Widget annotation + register it as an /AcroForm field (the logic lives in
             // forms/acroform.ts), then reference it here in the page /Annots - the same side channel as a link.
             if (node.type === "formfield") {
-                annotRefs.push(`${objectManager.acroform.addField(node, objectManager)} 0 R`);
+                const widget = objectManager.acroform.addField(node, objectManager, structParent);
+                tag(widget);
+                annotRefs.push(`${widget} 0 R`);
                 continue;
             }
-            if (node.type !== "link")
-                continue;
             const rect = `[${num(node.x)} ${num(node.y)} ${num(node.x + node.width)} ${num(node.y + node.height)}]`;
             // Either an external URL (/URI) or an internal named destination (/GoTo, resolved via /Names /Dests).
             // The Link IR guarantees exactly one is set; prefer `dest` when present.
             const action = node.dest !== undefined
                 ? `/A << /S /GoTo /D ${objectManager.pdfString(node.dest)} >>`
-                : `/A << /S /URI /URI ${objectManager.pdfString(node.href ?? "")} >>`;
-            const annot = objectManager.addObject(`<< /Type /Annot /Subtype /Link /Rect ${rect} /Border [0 0 0] ${action} >>`);
+                : `/A << /S /URI /URI ${objectManager.pdfUri(node.href ?? "")} >>`;
+            const tagged = structParent === undefined
+                ? ""
+                : ` /StructParent ${structParent} /Contents ${objectManager.pdfString(node.alt ?? "")}`;
+            const annot = objectManager.addObject(`<< /Type /Annot /Subtype /Link /Rect ${rect} /Border [0 0 0] ${action}${tagged} >>`);
+            tag(annot);
             annotRefs.push(`${annot} 0 R`);
         }
         const annotsCode = annotRefs.length > 0 ? ` /Annots [${annotRefs.join(" ")}]` : "";

package/dist/renderer/pdf-backend.d.ts

@@ -70,9 +70,10 @@ export declare class PdfBackend {
      */
     private static roundedRectPath;
     /**
-     * Clamp the four radii into the box. Each is capped at half the box, and two radii sharing an edge
-     * are scaled down together when they would overlap - the CSS rule, and what keeps the path from
-     * folding back on itself.
+     * Clamp the four radii into the box: two radii sharing an edge are scaled down together when they
+     * would overlap - the CSS rule (css-backgrounds-3, corner overlap), and what keeps the path from
+     * folding back on itself. A single corner is NOT capped at half the box: on a 200x40 box a lone
+     * 30pt corner stays 30, as in CSS; equal corners still end at half the short side.
      */
     private static clampRadii;
     /**

package/dist/renderer/pdf-backend.js

@@ -1,5 +1,6 @@
 import { isRounded, } from "../ir/display-list.js";
 import { Color } from "../common/color.js";
+import { ORIENTATION_MATRIX } from "../utils/image-helper.js";
 /**
  * PDF backend - turns display-list primitives into content-stream operators.
  *
@@ -279,14 +280,14 @@ export class PdfBackend {
             `h`);
     }
     /**
-     * Clamp the four radii into the box. Each is capped at half the box, and two radii sharing an edge
-     * are scaled down together when they would overlap - the CSS rule, and what keeps the path from
-     * folding back on itself.
+     * Clamp the four radii into the box: two radii sharing an edge are scaled down together when they
+     * would overlap - the CSS rule (css-backgrounds-3, corner overlap), and what keeps the path from
+     * folding back on itself. A single corner is NOT capped at half the box: on a 200x40 box a lone
+     * 30pt corner stays 30, as in CSS; equal corners still end at half the short side.
      */
     static clampRadii(radius, w, h) {
         const n = typeof radius === "number" ? radius : 0;
-        const cap = Math.max(0, Math.min(w, h) / 2);
-        const at = (v) => Math.max(0, Math.min(v ?? n, cap));
+        const at = (v) => Math.max(0, v ?? n);
         const r = typeof radius === "number"
             ? { tl: at(radius), tr: at(radius), br: at(radius), bl: at(radius) }
             : { tl: at(radius.tl), tr: at(radius.tr), br: at(radius.br), bl: at(radius.bl) };
@@ -416,8 +417,14 @@ export class PdfBackend {
             case "image": {
                 // The backend owns PDF resource creation: register the XObject (using the
                 // source pixel dimensions) and then place it with a scaling matrix.
-                const ref = om.registerImage(node.intrinsicWidth, node.intrinsicHeight, node.imageType, node.data, node.smask);
-                const draw = `q\n${node.width} 0 0 ${node.height} ${node.x} ${node.y} cm\n` + `/IM${ref} Do\nQ\n`;
+                const ref = om.registerImage(node.intrinsicWidth, node.intrinsicHeight, node.imageType, node.data, node.smask, node.color);
+                // The placement scales the unit square to the box; an orientation turns the pixels inside it.
+                const upright = node.orientation
+                    ? `${ORIENTATION_MATRIX[node.orientation].join(" ")} cm\n`
+                    : "";
+                const draw = `q\n${node.width} 0 0 ${node.height} ${node.x} ${node.y} cm\n` +
+                    upright +
+                    `/IM${ref} Do\nQ\n`;
                 if (!node.clip)
                     return draw;
                 // Clip to the frame (re … W n); rounded when a radius is set. The rectangular

package/dist/renderer/pdf-document-renderer.d.ts

@@ -3,14 +3,7 @@ import { LayoutContext } from "../elements/pdf-element.js";
 import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 export declare class PDFDocumentRenderer {
     static render(document: PDFDocumentElement, objectManager: PDFObjectManager, ctx: LayoutContext): Promise<number>;
-    /**
-     * The page geometry a physical page will use. `PageElement.calculateLayout` has already folded the
-     * document defaults into every page's config by the time we get here (`PDFRenderer` lays the document
-     * out before it calls us, and it is our only caller). Merging again is therefore a no-op today - it is
-     * here so this stays correct BY CONSTRUCTION rather than by call order: were that order ever changed,
-     * an unmerged config would otherwise make `resolvePageSize` fall back to A4 and quietly report the
-     * wrong page size.
-     */
+    /** The page geometry a physical page will use: resolved, never read back from an earlier layout. */
     private static configOf;
     /**
      * Splits one logical page into the physical pages it will occupy, without rendering.