@quillmark/quillify 0.3.0 → 0.4.0

package/NOTICE

@@ -1,5 +1,5 @@
 quillify
-Copyright 2026 Nibs
+Copyright 2026 Enrique Oti
 
 quillify redistributes eight files that are other projects' work. Everything
 else it depends on is installed by its consumer and is not in the package.

package/README.md

@@ -4,7 +4,7 @@ Turn a published PDF form into a [Quillmark](https://github.com/borb-sh/quillmar
 
 Published forms rarely come as a clean fillable PDF. Most are encrypted with an empty password, and many are dynamic XFA, which only Acrobat lays out. quillify reads either kind and returns the page as a background with its form layer stripped, and every field with its place.
 
-57 of 59 federal forms and 1,143 of 1,354 Air Force forms convert, with every field read back at its place.
+57 of 59 federal forms and 1,147 of 1,354 Air Force forms convert, with every field read back at its place.
 
 ## Install
 
@@ -45,6 +45,7 @@ The file is treated as hostile. The background comes back without its form layer
 
 ## Documentation
 
+- [Example](examples/): a page that takes a PDF, lists its fields under the names `suggest` gives and renders a filled copy. In a clone: `npm ci`, `npm run build`, `npx vite examples`.
 - [API](docs/api.md): what goes in, what comes back, every refusal and problem.
 - [Guide](docs/guide.md): bundlers, content security policy, the engine, from a quill to a filled PDF.
 - [Limits](docs/limits.md): what converts, what is refused, how a redrawn form can differ.

package/assets/qpdf.worker.js

@@ -126,14 +126,19 @@ onmessage = async ({ data: { bytes, flags, wasm, limit } }) => {
 	}
 	let out;
 	let written = 0;
+	let said = '';
 	try {
 		qpdf.FS.writeFile('/in.pdf', bytes);
 		// Nothing in qpdf bounds the file it writes: streams that lie inside one
 		// another are each written whole. The write that passes the limit ends
 		// the run.
 		const { write } = qpdf.FS;
+		const text = new TextDecoder();
 		qpdf.FS.write = (stream, buffer, offset, length, ...rest) => {
 			if ((written += length) > limit) throw new Error('qpdf wrote past the limit');
+			// Its error stream. A qpdf that ends by itself says last why it writes no file, so the end is kept.
+			if (stream.fd === 2)
+				said = (said + text.decode(buffer.subarray(offset, offset + length))).slice(-1024);
 			return write(stream, buffer, offset, length, ...rest);
 		};
 		// qpdf ends with 0, or with 3 when it warned. After an error the file is
@@ -141,8 +146,10 @@ onmessage = async ({ data: { bytes, flags, wasm, limit } }) => {
 		if ([0, 3].includes(qpdf.callMain(['/in.pdf', ...flags, '/out.pdf'])))
 			out = qpdf.FS.readFile('/out.pdf');
 	} catch {
-		// qpdf wrote nothing it could stand behind.
+		// qpdf wrote nothing it could stand behind. It did not end by itself, so
+		// its last line is no error of its own: a warning carries the file's words.
+		said = '';
 	}
 	const size = Math.max(written, qpdf.HEAPU8.byteLength);
-	postMessage({ loaded: true, out, size }, out ? [out.buffer] : []);
+	postMessage({ loaded: true, out, size, said }, out ? [out.buffer] : []);
 };

package/dist/api.d.ts

@@ -41,6 +41,7 @@ export interface FieldNaming {
     /** A read-only field is left out whatever this says. */
     keep: boolean;
     name: string;
+    title?: string;
     description: string;
     example?: string;
     text?: 'line' | 'paragraph' | 'lines';

package/dist/assemble.d.ts

@@ -1,5 +1,5 @@
 import type { InventoryWidget, QualifiedField, QualifiedForm, QuillTree } from './types.js';
-/** What the assembly reads of a field, of the form and of a widget. Its tests hand it a title, which it does not read. */
+/** What the assembly reads of a field, of the form and of a widget. Its tests hand it a quill title, which it does not read. */
 type Named = Omit<QualifiedField, 'label'>;
 type Qualified = {
     quill: Pick<QualifiedForm['quill'], 'name' | 'description'> & {

package/dist/assemble.js

@@ -6,23 +6,15 @@ export const QUILL_VERSION = '0.1.0';
  * (U+007F to U+009F, U+FFFE and U+FFFF) are written as `\u` escapes.
  */
 const q = (s) => JSON.stringify(s.toWellFormed()).replace(/[\u007f-\u009f\ufffe\uffff]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
-/** A group id is snake_case; a radio group's PDF name is whatever its author typed. */
-function groupId(name) {
-    const id = name
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '_')
-        .replace(/^_+|_+$/g, '');
-    return /^[a-z]/.test(id) ? id : `group_${id}`;
-}
 /**
  * A `default:` says nobody need answer the field. A required field declares
  * none, a boolean apart: it defaults to false either way.
  */
 function fieldYaml(field) {
     const lines = [`    ${q(field.name)}:`];
+    if (field.title !== undefined)
+        lines.push(`      title: ${q(field.title)}`);
     const ui = [];
-    if (field.group)
-        ui.push(`        group: ${q(groupId(field.group))}`);
     switch (field.type) {
         case 'string':
             lines.push('      type: string');
@@ -74,9 +66,6 @@ export function quillYaml(form, fields) {
         '  body:',
         '    enabled: false'
     ];
-    const groups = [...new Set(fields.flatMap((f) => (f.group ? [groupId(f.group)] : [])))];
-    if (groups.length > 0)
-        lines.push('  ui:', `    groups: [${groups.map(q).join(', ')}]`);
     if (fields.length > 0) {
         lines.push('  fields:');
         for (const field of fields)

package/dist/display-list.d.ts

@@ -14,7 +14,10 @@ export interface Box {
     fill: Colour | null;
     /** Top, right, bottom, left. A null edge is not drawn. */
     edges: [Edge | null, Edge | null, Edge | null, Edge | null];
-    /** The radius of an SVG rect's corners, along the middle of its border. */
+    /**
+     * The radius of an SVG rect's corners, along the middle of its border. An
+     * ellipse has one that reaches the middle of its longer side.
+     */
     radius?: number;
 }
 /** A picture, at the box the browser paints its pixels in. */
@@ -45,16 +48,15 @@ export interface Run {
     italic: boolean;
     colour: Colour;
     letterSpacing: number;
-    /** What the browser measured, which `drawRuns` scales the run to. */
+    /** What the browser measured, which `drawRun` scales the run to. */
     width: number;
     /** Quarter turns counter-clockwise about the start of the baseline, when the run is turned. */
     turn?: number;
 }
+export type Drawn = Box | Picture | Line | Run;
 export interface DisplayList {
-    boxes: Box[];
-    pictures: Picture[];
-    lines: Line[];
-    runs: Run[];
+    /** What the page shows, in the order the browser paints it. */
+    drawn: Drawn[];
     width: number;
     height: number;
 }
@@ -63,20 +65,21 @@ export interface DisplayList {
  * the layout, and the rects here are read off it.
  *
  * What it can express is text, CSS backgrounds and borders, pictures, and
- * inline SVG `line` and `rect`. A picture that did not load, a background
- * image, a `rect` filled with a gradient or a pattern, another SVG shape, a
- * border style it cannot draw and a transform it cannot carry are refused with
- * the construct named: a background that is silently incomplete is worse than
- * not taking the form. An element hidden by its own style, an SVG `line` with
- * no stroke, a `rect` with neither stroke nor fill and an HTML element under
- * 0.3 pt on a side are passed over.
+ * inline SVG `line`, `rect`, `ellipse` and `circle`. A picture that did not
+ * load, a background image, a shape filled with a gradient or a pattern,
+ * another SVG shape, a border style it cannot draw and a transform it cannot
+ * carry are refused with the construct named: a background that is silently
+ * incomplete is worse than not taking the form. An element hidden by its own
+ * style, an SVG `line` with no stroke, a shape with neither stroke nor fill
+ * or of no width or height, and an HTML element under 0.3 pt on a side are
+ * passed over.
  */
 export declare function displayList(page: XfaPage, pageNumber: number): DisplayList;
 /**
  * True for a transform a run's box cannot carry. XFA offsets caption
  * wrappers with a translation, which the rects already hold. A positive
  * horizontal scale is carried too: `getClientRects` reports the scaled width and
- * `drawRuns` puts it back as `Tz`, which is how LiveCycle's
+ * `drawRun` puts it back as `Tz`, which is how LiveCycle's
  * `xfa-font-horizontal-scale` reaches the page. A rotation, a skew, a mirror or
  * a vertical scale changes glyph shape or height, and a run carries neither. A
  * quarter turn is read apart, by `quarterTurns`.

package/dist/display-list.js

@@ -23,21 +23,19 @@ function stroked(style) {
  * the layout, and the rects here are read off it.
  *
  * What it can express is text, CSS backgrounds and borders, pictures, and
- * inline SVG `line` and `rect`. A picture that did not load, a background
- * image, a `rect` filled with a gradient or a pattern, another SVG shape, a
- * border style it cannot draw and a transform it cannot carry are refused with
- * the construct named: a background that is silently incomplete is worse than
- * not taking the form. An element hidden by its own style, an SVG `line` with
- * no stroke, a `rect` with neither stroke nor fill and an HTML element under
- * 0.3 pt on a side are passed over.
+ * inline SVG `line`, `rect`, `ellipse` and `circle`. A picture that did not
+ * load, a background image, a shape filled with a gradient or a pattern,
+ * another SVG shape, a border style it cannot draw and a transform it cannot
+ * carry are refused with the construct named: a background that is silently
+ * incomplete is worse than not taking the form. An element hidden by its own
+ * style, an SVG `line` with no stroke, a shape with neither stroke nor fill
+ * or of no width or height, and an HTML element under 0.3 pt on a side are
+ * passed over.
  */
 export function displayList(page, pageNumber) {
     const { layer, origin } = page;
     const view = layer.ownerDocument.defaultView;
-    const boxes = [];
-    const pictures = [];
-    const lines = [];
-    const runs = [];
+    const drawn = [];
     // The quarter turns each element is laid out under, its own and its ancestors'.
     const turns = new Map([[layer, 0]]);
     const X = (v) => +(v - origin.left).toFixed(2);
@@ -45,7 +43,43 @@ export function displayList(page, pageNumber) {
     const refuse = (construct, detail) => {
         throw new Refused({ code: 'unpaintable', page: pageNumber - 1, construct, detail });
     };
-    for (const el of layer.querySelectorAll('*')) {
+    // CSS paints the boxes of what is in the flow under a positioned element,
+    // then its text, pictures and SVG shapes, then the positioned elements
+    // under it in tree order, each the same way.
+    const order = [];
+    const under = (root) => {
+        const front = [];
+        const positioned = [];
+        const flow = (parent) => {
+            for (const node of parent.childNodes) {
+                if (node.nodeType === Node.TEXT_NODE)
+                    front.push(node);
+                if (node.nodeType !== Node.ELEMENT_NODE)
+                    continue;
+                const el = node;
+                if (view.getComputedStyle(el).position !== 'static')
+                    positioned.push(el);
+                else {
+                    (/^(img|line|rect|ellipse|circle|input)$/i.test(el.tagName) ? front : order).push(el);
+                    flow(el);
+                }
+            }
+        };
+        flow(root);
+        for (const node of front)
+            order.push(node);
+        for (const el of positioned) {
+            order.push(el);
+            under(el);
+        }
+    };
+    under(layer);
+    for (const node of order) {
+        if (node.nodeType === Node.TEXT_NODE) {
+            collectText(node, X, Y, drawn, turns);
+            continue;
+        }
+        const el = node;
         const tag = el.tagName.toLowerCase();
         const style = view.getComputedStyle(el);
         const own = quarterTurns(style.transform);
@@ -70,7 +104,7 @@ export function displayList(page, pageNumber) {
             const fit = style.objectFit === 'contain'
                 ? Math.min(rect.width / image.naturalWidth, rect.height / image.naturalHeight)
                 : 0;
-            pictures.push({
+            drawn.push({
                 x: X(rect.x),
                 y: Y(rect.y),
                 w: +(fit ? image.naturalWidth * fit : rect.width).toFixed(2),
@@ -79,7 +113,7 @@ export function displayList(page, pageNumber) {
             });
             continue;
         }
-        if (tag === 'line' || tag === 'rect') {
+        if (tag === 'line' || tag === 'rect' || tag === 'ellipse' || tag === 'circle') {
             const svg = el.ownerSVGElement;
             if (!svg)
                 continue;
@@ -98,7 +132,7 @@ export function displayList(page, pageNumber) {
                         return 0;
                     return raw.trim().endsWith('%') ? (span * value) / 100 : value;
                 };
-                lines.push({
+                drawn.push({
                     x1: X(svgRect.x + at('x1', svgRect.width)),
                     y1: Y(svgRect.y + at('y1', svgRect.height)),
                     x2: X(svgRect.x + at('x2', svgRect.width)),
@@ -108,22 +142,26 @@ export function displayList(page, pageNumber) {
                 });
             }
             else {
-                // pdf.js writes every rectangle a fill, and the browser drops one that is
-                // no color: a gradient or a pattern. What is left computes to black.
+                // pdf.js writes every shape a fill, and the browser drops one that is no
+                // color: a gradient or a pattern. What is left computes to black.
                 if (!el.style.fill && !el.hasAttribute('fill'))
                     refuse('background_image');
-                // A rectangle whose edge is hidden has a stroke of no width.
+                // A shape whose edge is hidden has a stroke of no width.
                 const fill = style.fill !== 'none' && opaque(style.fill) ? rgb(style.fill) : null;
                 if (!edge && !fill)
                     continue;
-                // SVG centers a stroke on the rectangle's edge, and a box's border is
+                // SVG centers a stroke on the shape's edge, and a box's border is
                 // drawn inside it, so the box is half a stroke larger all round. What
                 // that adds to the fill lies under the stroke.
                 const half = (edge?.width ?? 0) / 2;
                 const r = el.getBoundingClientRect();
-                // The browser draws a rect square when its rx is below zero.
-                const radius = parseFloat(style.rx);
-                boxes.push({
+                // The browser paints no shape of no width or height, whatever its stroke.
+                if (!r.width || !r.height)
+                    continue;
+                // The browser draws a rect square when its rx is below zero. An ellipse
+                // is a rect whose corners meet.
+                const radius = tag === 'rect' ? parseFloat(style.rx) : Math.max(r.width, r.height) / 2;
+                drawn.push({
                     x: X(r.x - half),
                     y: Y(r.y - half),
                     w: +(r.width + 2 * half).toFixed(2),
@@ -152,7 +190,7 @@ export function displayList(page, pageNumber) {
             if (type === 'checkbox' || type === 'radio') {
                 const painted = square(rect);
                 const hair = { width: 1, colour: [0, 0, 0] };
-                boxes.push({
+                drawn.push({
                     x: X(painted.left),
                     y: Y(painted.top),
                     w: +painted.width.toFixed(2),
@@ -188,7 +226,7 @@ export function displayList(page, pageNumber) {
             edges.push(edges.shift());
         const fill = opaque(style.backgroundColor) ? rgb(style.backgroundColor) : null;
         if (fill || edges.some(Boolean))
-            boxes.push({
+            drawn.push({
                 x: X(rect.x),
                 y: Y(rect.y),
                 w: +rect.width.toFixed(2),
@@ -197,8 +235,7 @@ export function displayList(page, pageNumber) {
                 edges
             });
     }
-    collectText(layer, X, Y, runs, turns);
-    return { boxes, pictures, lines, runs, width: page.width, height: page.height };
+    return { drawn, width: page.width, height: page.height };
 }
 /**
  * How many quarter turns counter-clockwise a transform is, and 0 for any
@@ -215,7 +252,7 @@ function quarterTurns(transform) {
  * True for a transform a run's box cannot carry. XFA offsets caption
  * wrappers with a translation, which the rects already hold. A positive
  * horizontal scale is carried too: `getClientRects` reports the scaled width and
- * `drawRuns` puts it back as `Tz`, which is how LiveCycle's
+ * `drawRun` puts it back as `Tz`, which is how LiveCycle's
  * `xfa-font-horizontal-scale` reaches the page. A rotation, a skew, a mirror or
  * a vertical scale changes glyph shape or height, and a run carries neither. A
  * quarter turn is read apart, by `quarterTurns`.
@@ -231,109 +268,111 @@ export function unrepresentable(transform) {
 }
 /** SVG shapes pdf.js can emit that the primitives above have no form for. */
 function svgOnly(tag) {
-    return ['path', 'polygon', 'polyline', 'circle', 'ellipse', 'image', 'use', 'text'].includes(tag);
+    return ['path', 'polygon', 'polyline', 'image', 'use', 'text'].includes(tag);
 }
 /**
  * One run per visual line, with the box the browser measured it into. Splitting
  * where the rect top changes is what keeps a wrapped paragraph's second line at
  * its own baseline. A tab ends a run too and is in none: the text after it
- * starts a run at the box the layout moved it to.
+ * starts a run at the box the layout moved it to. A soft hyphen the layout
+ * breaks a line at is a hyphen in the run it ends, which is measured with it.
  */
-function collectText(layer, X, Y, runs, turns) {
-    const owner = layer.ownerDocument;
-    const view = owner.defaultView;
+function collectText(node, X, Y, drawn, turns) {
+    let text = node.nodeValue ?? '';
+    const parent = node.parentElement;
+    if (!text.trim() || !parent)
+        return;
+    // A <select> is de-chromed above; only the option the form shows is drawn.
+    if (parent.tagName === 'OPTION' && !parent.selected)
+        return;
+    const owner = node.ownerDocument;
+    const style = owner.defaultView.getComputedStyle(parent);
+    if (style.visibility === 'hidden' || style.display === 'none')
+        return;
     const measure = owner.createElement('canvas').getContext('2d');
-    const walker = owner.createTreeWalker(layer, NodeFilter.SHOW_TEXT);
     const range = owner.createRange();
-    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
-        const text = node.nodeValue;
-        const parent = node.parentElement;
-        if (!text || !text.trim() || !parent)
-            continue;
-        // A <select> is de-chromed above; only the option the form shows is drawn.
-        if (parent.tagName === 'OPTION' && !parent.selected)
+    const size = parseFloat(style.fontSize);
+    measure.font = `${style.fontStyle} ${style.fontWeight} ${size}px ${style.fontFamily}`;
+    const descent = measure.measureText('Hg').fontBoundingBoxDescent ?? size * 0.21;
+    const common = {
+        size: +size.toFixed(2),
+        family: style.fontFamily,
+        bold: parseInt(style.fontWeight, 10) >= 600 || style.fontWeight === 'bold',
+        italic: style.fontStyle === 'italic' || style.fontStyle === 'oblique',
+        colour: rgb(style.color),
+        letterSpacing: parseFloat(style.letterSpacing) || 0
+    };
+    // Under a turn each rect is read in the frame the text is upright in, and
+    // the start of each line's baseline is turned back to the page.
+    const turn = turns.get(parent);
+    const [cos, sin] = [
+        [1, 0],
+        [0, -1],
+        [-1, 0],
+        [0, 1]
+    ][turn];
+    const upright = ({ left, right, top, bottom }) => {
+        const [x1, x2] = [cos * left + sin * top, cos * right + sin * bottom];
+        const [y1, y2] = [cos * top - sin * left, cos * bottom - sin * right];
+        return {
+            x: Math.min(x1, x2),
+            right: Math.max(x1, x2),
+            top: Math.min(y1, y2),
+            bottom: Math.max(y1, y2)
+        };
+    };
+    let start = 0;
+    let top = null;
+    let box = null;
+    const flush = (end) => {
+        const slice = text.slice(start, end);
+        if (end <= start || !box || !slice.trim())
+            return;
+        const base = box.bottom - descent;
+        drawn.push({
+            text: slice,
+            x: X(cos * box.x - sin * base),
+            baseline: Y(sin * box.x + cos * base),
+            width: +(box.right - box.x).toFixed(2),
+            turn: turn || undefined,
+            ...common
+        });
+    };
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '\t') {
+            flush(i);
+            start = i + 1;
+            top = null;
+            box = null;
             continue;
-        const style = view.getComputedStyle(parent);
-        if (style.visibility === 'hidden' || style.display === 'none')
+        }
+        range.setStart(node, i);
+        range.setEnd(node, i + 1);
+        // At a break the soft hyphen has an empty rect and then the box of the
+        // hyphen shown, and the letter after it has that box and then its own.
+        const rects = range.getClientRects();
+        const rect = rects[rects.length - 1];
+        if (!rect)
             continue;
-        const size = parseFloat(style.fontSize);
-        measure.font = `${style.fontStyle} ${style.fontWeight} ${size}px ${style.fontFamily}`;
-        const descent = measure.measureText('Hg').fontBoundingBoxDescent ?? size * 0.21;
-        const common = {
-            size: +size.toFixed(2),
-            family: style.fontFamily,
-            bold: parseInt(style.fontWeight, 10) >= 600 || style.fontWeight === 'bold',
-            italic: style.fontStyle === 'italic' || style.fontStyle === 'oblique',
-            colour: rgb(style.color),
-            letterSpacing: parseFloat(style.letterSpacing) || 0
-        };
-        // Under a turn each rect is read in the frame the text is upright in, and
-        // the start of each line's baseline is turned back to the page.
-        const turn = turns.get(parent);
-        const [cos, sin] = [
-            [1, 0],
-            [0, -1],
-            [-1, 0],
-            [0, 1]
-        ][turn];
-        const upright = ({ left, right, top, bottom }) => {
-            const [x1, x2] = [cos * left + sin * top, cos * right + sin * bottom];
-            const [y1, y2] = [cos * top - sin * left, cos * bottom - sin * right];
-            return {
-                x: Math.min(x1, x2),
-                right: Math.max(x1, x2),
-                top: Math.min(y1, y2),
-                bottom: Math.max(y1, y2)
-            };
-        };
-        let start = 0;
-        let top = null;
-        let box = null;
-        const flush = (end) => {
-            const slice = text.slice(start, end);
-            if (end <= start || !box || !slice.trim())
-                return;
-            const base = box.bottom - descent;
-            runs.push({
-                text: slice,
-                x: X(cos * box.x - sin * base),
-                baseline: Y(sin * box.x + cos * base),
-                width: +(box.right - box.x).toFixed(2),
-                turn: turn || undefined,
-                ...common
-            });
-        };
-        for (let i = 0; i < text.length; i++) {
-            if (text[i] === '\t') {
-                flush(i);
-                start = i + 1;
-                top = null;
-                box = null;
-                continue;
-            }
-            range.setStart(node, i);
-            range.setEnd(node, i + 1);
-            const rect = range.getClientRects()[0];
-            if (!rect)
-                continue;
-            const glyph = upright(rect);
-            if (top === null || Math.abs(glyph.top - top) < 0.6) {
-                top ??= glyph.top;
-                box = box
-                    ? {
-                        x: Math.min(box.x, glyph.x),
-                        bottom: Math.max(box.bottom, glyph.bottom),
-                        right: Math.max(box.right, glyph.right)
-                    }
-                    : { x: glyph.x, bottom: glyph.bottom, right: glyph.right };
-            }
-            else {
-                flush(i);
-                start = i;
-                top = glyph.top;
-                box = { x: glyph.x, bottom: glyph.bottom, right: glyph.right };
-            }
+        const glyph = upright(rect);
+        if (text[i] === '\u00ad' && glyph.right > glyph.x)
+            text = `${text.slice(0, i)}-${text.slice(i + 1)}`;
+        if (top === null || Math.abs(glyph.top - top) < 0.6) {
+            top ??= glyph.top;
+            box = box
+                ? {
+                    x: Math.min(box.x, glyph.x),
+                    bottom: Math.max(box.bottom, glyph.bottom),
+                    right: Math.max(box.right, glyph.right)
+                }
+                : { x: glyph.x, bottom: glyph.bottom, right: glyph.right };
+        }
+        else {
+            flush(i);
+            start = i;
+            top = glyph.top;
+            box = { x: glyph.x, bottom: glyph.bottom, right: glyph.right };
         }
-        flush(text.length);
     }
+    flush(text.length);
 }

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export { quillify, type Quillified } from './quillify.js';
 export { sanitize, type Sanitized } from './sanitize.js';
 export type { Field, FieldNaming, Form, Naming, Place, Problem, Size } from './api.js';
 export type { Refusal } from './refusal.js';
-export type { Rect } from './types.js';
+export { limits, type Rect } from './types.js';

package/dist/index.js

@@ -1,3 +1,4 @@
 export { check, suggest } from './naming.js';
 export { quillify } from './quillify.js';
 export { sanitize } from './sanitize.js';
+export { limits } from './types.js';

package/dist/inventory.js

@@ -2,7 +2,7 @@ import { PDFArray, PDFDict, PDFDocument, PDFHexString, PDFName, PDFString, pdfDo
 import { toTopLeftRect } from './coords.js';
 import { openPdf } from './pdfjs.js';
 import { Refused } from './refusal.js';
-import { MAX_PAGES, MAX_WIDGETS, WIDGET_KINDS } from './types.js';
+import { MAX_PAGES, MAX_SIDE, MAX_WIDGETS, WIDGET_KINDS } from './types.js';
 /** pdf.js passes on whatever name a file gives `/FT`. */
 const isWidgetKind = (type) => WIDGET_KINDS.includes(type);
 export async function inventoryPdf(bytes, signal) {
@@ -49,7 +49,11 @@ export async function inventoryPdf(bytes, signal) {
                 throw new Refused({ code: 'rotated', page: index });
             const view = page.view;
             views.push({ ref: page.ref, box: view });
-            dims.push({ width: view[2] - view[0], height: view[3] - view[1] });
+            const size = { width: view[2] - view[0], height: view[3] - view[1] };
+            if (page.userUnit !== 1 ||
+                Math.max(size.width, size.height, ...view.map(Math.abs)) > MAX_SIDE)
+                throw new Refused({ code: 'damaged' });
+            dims.push(size);
             const annotations = (await within(page.getAnnotations()));
             for (const a of annotations) {
                 // A push button runs an action; it holds no value, so it is no field.

package/dist/naming.js

@@ -74,6 +74,8 @@ function shaped({ name, description, fields }) {
             not(`${slot}.name`, 'a string');
         if (typeof entry.description !== 'string')
             not(`${slot}.description`, 'a string');
+        if (entry.title !== undefined && typeof entry.title !== 'string')
+            not(`${slot}.title`, 'a string');
         if (entry.example !== undefined && typeof entry.example !== 'string')
             not(`${slot}.example`, 'a string');
         if (entry.text !== undefined && !TEXT.has(entry.text))