@jasy/pdf 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/renderer/bookmark-renderer.js

@@ -1,9 +1,10 @@
 import { RendererRegistry } from "../utils/renderer-registry.js";
 export class BookmarkRenderer {
-    static async render(element, objectManager) {
-        const { title, level, child, y } = element.getProps();
-        const renderer = RendererRegistry.getRenderer(child);
-        const childNodes = await renderer(child, objectManager);
+    static async render(element, objectManager, scope) {
+        const { title, level, child, y: ownY } = element.getProps();
+        // Its own position is relative to `scope.origin`; the IR wants page coordinates.
+        const y = scope.origin.y + (ownY ?? 0);
+        const childNodes = await RendererRegistry.render(child, objectManager, scope);
         // The child draws normally; an Outline IR node carries the title + nesting + scroll target for the
         // page renderer to collect into the /Outlines tree (it produces no content-stream ops itself).
         return [...childNodes, { type: "outline", y, title, level }];

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

@@ -1,3 +1,4 @@
+import type { RenderScope } from "../utils/renderer-registry.js";
 import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 import { CanvasElement } from "../elements/canvas-element.js";
 import type { IRNode } from "../ir/display-list.js";
@@ -10,5 +11,5 @@ import type { IRNode } from "../ir/display-list.js";
  * past its own edge would otherwise bleed into the layout beside it.
  */
 export declare class CanvasRenderer {
-    static render(element: CanvasElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+    static render(element: CanvasElement, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
 }

package/dist/renderer/canvas-renderer.js

@@ -8,8 +8,11 @@ import { CanvasPainter } from "../canvas/painter.js";
  * past its own edge would otherwise bleed into the layout beside it.
  */
 export class CanvasRenderer {
-    static async render(element, objectManager) {
-        const { x, y, width, height, paint, alt } = element.getProps();
+    static async render(element, objectManager, scope) {
+        const { x: ownX, y: ownY, width, height, paint, alt } = 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);
         // The layout bounds are kept as plain numbers, and the painter and the callback each get their
         // OWN size object. Sharing one meant a callback that wrote to `size.width` moved the clip away
         // from the box layout had reserved - the drawing would then bleed into what sits beside it.

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

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

package/dist/renderer/container-renderer.js

@@ -1,12 +1,13 @@
-import { RendererRegistry } from "../utils/renderer-registry.js";
+import { RendererRegistry, within } from "../utils/renderer-registry.js";
 export class ContainerRenderer {
-    static async render(containerElement, objectManager) {
-        const { children } = containerElement.getProps();
+    static async render(containerElement, objectManager, scope) {
+        const { x, y, children } = containerElement.getProps();
         const nodes = [];
+        // Its children are placed relative to its own top-left.
+        const inner = within(scope, { x, y });
         if (children)
             for (const child of children) {
-                const renderer = RendererRegistry.getRenderer(child);
-                nodes.push(...(await renderer(child, objectManager)));
+                nodes.push(...(await RendererRegistry.render(child, objectManager, inner)));
             }
         return nodes;
     }

package/dist/renderer/default-text-style-renderer.d.ts

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

package/dist/renderer/default-text-style-renderer.js

@@ -2,9 +2,8 @@ import { RendererRegistry } from "../utils/renderer-registry.js";
 // Transparent wrapper: the text style was already resolved onto the descendants at layout time, so
 // the renderer just emits the child's display list (like PaddingRenderer).
 export class DefaultTextStyleRenderer {
-    static async render(element, objectManager) {
+    static async render(element, objectManager, scope) {
         const { child } = element.getProps();
-        const renderer = RendererRegistry.getRenderer(child);
-        return renderer(child, objectManager);
+        return RendererRegistry.render(child, objectManager, scope);
     }
 }

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

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

package/dist/renderer/deferred-renderer.js

@@ -1,10 +1,9 @@
 import { RendererRegistry } from "../utils/renderer-registry.js";
 export class DeferredRenderer {
-    static async render(element, objectManager) {
+    static async render(element, objectManager, scope) {
         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/expanded-renderer.d.ts

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

package/dist/renderer/expanded-renderer.js

@@ -1,8 +1,7 @@
 import { RendererRegistry } from "../utils/renderer-registry.js";
 export class ExpandedRenderer {
-    static async render(expandedElement, objectManager) {
+    static async render(expandedElement, objectManager, scope) {
         const { child } = expandedElement.getProps();
-        const renderer = RendererRegistry.getRenderer(child);
-        return renderer(child, objectManager);
+        return RendererRegistry.render(child, objectManager, scope);
     }
 }

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

@@ -3,9 +3,12 @@ import { bytesFromLatin1 } from "../utils/bytes.js";
 import { applyContainFit, applyCoverFit, applyFillFit, applyFitNone, decodePngToRgbFlate, } 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();
+        let { x: ownX, y: ownY, width, height, image, fit, radius, alt } = imageElement.getProps();
+        // Its own position is relative to `scope.origin`; the IR wants page coordinates.
+        let x = scope.origin.x + (ownX ?? 0);
+        let 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();

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,18 @@
 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";
 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] : [])];
@@ -20,8 +28,7 @@ export class PageRenderer {
         // 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)));
+            nodes.push(...(await RendererRegistry.render(element, 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).
@@ -72,21 +79,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

@@ -279,14 +279,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) };

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.