@zanii/blackbox 0.22.0 → 0.23.0

package/dist/pdf/index.js

@@ -0,0 +1,673 @@
+// Signed PDF/A-3b reports (spec/pdf.md): a report's Markdown laid out as text in an embedded font,
+// its JSON (and any other copy) attached as associated files, and a PAdES baseline B signature by
+// an Ed25519 identity. Pure and deterministic: the same input, key and time give the same bytes in
+// both SDKs (spec/vectors/report-pdf.json). Mirrors sdks/python/src/zanii_blackbox/pdf.py.
+//
+// Latin is drawn in WinAnsi with the DejaVu Sans subset; Arabic is shaped to its presentation forms
+// and put in visual order (./arabic.ts), and drawn with the Noto Sans Arabic subset (spec/pdf.md §6).
+import { createHash, createPrivateKey, createPublicKey, sign, verify } from "node:crypto";
+import { didFromPublicKey } from "@zanii/core";
+import { bidiLevels, prepare, reorderLine, shapeClusters, } from "./arabic.js";
+const enc = new TextEncoder();
+const latin1 = (s) => Uint8Array.from(s, (c) => c.charCodeAt(0));
+const cat = (parts) => new Uint8Array(Buffer.concat(parts));
+const sha = (alg, b) => new Uint8Array(createHash(alg).update(b).digest());
+// ---------------------------------------------------------------- text
+/** cp1252's 0x80-0x9F, by code point. */
+const CP1252 = {
+    8364: 0x80,
+    8218: 0x82,
+    402: 0x83,
+    8222: 0x84,
+    8230: 0x85,
+    8224: 0x86,
+    8225: 0x87,
+    710: 0x88,
+    8240: 0x89,
+    352: 0x8a,
+    8249: 0x8b,
+    338: 0x8c,
+    381: 0x8e,
+    8216: 0x91,
+    8217: 0x92,
+    8220: 0x93,
+    8221: 0x94,
+    8226: 0x95,
+    8211: 0x96,
+    8212: 0x97,
+    732: 0x98,
+    8482: 0x99,
+    353: 0x9a,
+    8250: 0x9b,
+    339: 0x9c,
+    382: 0x9e,
+    376: 0x9f,
+};
+/** Whether a code point is in WinAnsi (tab counts, drawn as a space). */
+const inWinAnsi = (cp) => cp === 9 || (cp >= 0x20 && cp <= 0x7e) || (cp >= 0xa0 && cp <= 0xff) || cp in CP1252;
+/** One code point in WinAnsi; anything else is "?" (the attachment keeps the exact text). */
+function winAnsi(cp) {
+    if (cp === 9)
+        return 32;
+    if ((cp >= 0x20 && cp <= 0x7e) || (cp >= 0xa0 && cp <= 0xff))
+        return cp;
+    return CP1252[cp] ?? 0x3f;
+}
+const codes = (s) => Array.from(s, (c) => winAnsi(c.codePointAt(0)));
+const SIZES = { h1: 150, h2: 125, h3: 110, body: 90 }; // tenths of a point
+const PAGE_W = 5950;
+const PAGE_H = 8420;
+const MARGIN = 560;
+const WIDTH = PAGE_W - 2 * MARGIN;
+const MARK_GAP = 40; // font units between stacked marks (§6.4)
+function context(assets, lang) {
+    const a = assets.arabic;
+    if (lang === "ar" && !a)
+        throw new Error("lang ar needs the Arabic assets");
+    return {
+        m: assets.metrics,
+        P: a ? prepare(a.unicode) : null,
+        arabic: new Map((a?.metrics.glyphs ?? []).map((g) => [g[0], g.slice(1)])),
+        marks: new Map((a?.metrics.marks ?? []).map((g) => [g[0], g[1]])),
+        p: lang === "ar" ? 1 : 0,
+        used: new Map(),
+    };
+}
+function glyph(cp, x) {
+    if (!inWinAnsi(cp)) {
+        const a = x.arabic.get(cp);
+        if (a) {
+            const [gid, w, y0, y1] = a;
+            return { f: 2, code: gid, w, y0, y1, mark: x.marks.get(cp) ?? null, actual: null };
+        }
+    }
+    const code = winAnsi(cp);
+    const w = x.m.widths[code - x.m.first_char] ?? 0;
+    return { f: 1, code, w, y0: 0, y1: 0, mark: null, actual: null };
+}
+/** The Markdown as lines, wrapped to the page in logical order, then each put in visual order
+ * (integer arithmetic only). */
+function layout(markdown, x) {
+    const out = [];
+    for (const raw of markdown.split("\n")) {
+        let line = raw.trimEnd();
+        if (/^<\/?div\b/.test(line) || /^\|[-|: ]+\|$/.test(line))
+            continue;
+        let size = SIZES.body;
+        const h = /^(#{1,3}) (.*)$/.exec(line);
+        if (h) {
+            size = [SIZES.h1, SIZES.h2, SIZES.h3][h[1].length - 1];
+            line = h[2];
+        }
+        else if (/^\|.*\|$/.test(line)) {
+            // §6.3: each cell is isolated, as in an HTML table cell
+            const [a, b] = x.P ? [x.p ? "⁧" : "⁦", "⁩"] : ["", ""];
+            line = line
+                .slice(1, -1)
+                .split("|")
+                .map((c) => a + c.trim() + b)
+                .join("   ");
+        }
+        else if (line.startsWith("> "))
+            line = line.slice(2);
+        line = line.replaceAll("**", "").replaceAll("`", "");
+        if (line === "") {
+            out.push({ size: 0, vis: [], idx: [], odd: [], inOrder: true });
+            continue;
+        }
+        const clusters = x.P
+            ? shapeClusters(line, x.P)
+            : Array.from(line, (c) => ({ cps: [c.codePointAt(0)], src: c, cls: "L" }));
+        const levels = x.P ? bidiLevels(clusters, x.p, x.P) : clusters.map(() => 0);
+        const cw = clusters.map((c) => c.cps.reduce((n, cp) => {
+            const g = glyph(cp, x);
+            return n + (g.mark === null ? g.w : 0);
+        }, 0));
+        const has = (cs) => cs.some((i) => clusters[i].cps.length > 0);
+        const fits = (cs) => cs.reduce((n, i) => n + cw[i], 0) * size <= WIDTH * 1000;
+        const words = [[]];
+        const seps = [];
+        clusters.forEach((c, i) => {
+            if (c.src === " ") {
+                seps.push(i);
+                words.push([]);
+            }
+            else
+                words.at(-1).push(i);
+        });
+        const lines = [];
+        let cur = [];
+        words.forEach((word, w) => {
+            const next = has(cur) ? [...cur, seps[w - 1], ...word] : [...cur, ...word];
+            if (fits(next)) {
+                cur = next;
+                return;
+            }
+            if (has(cur))
+                lines.push(cur);
+            cur = [];
+            for (const c of word) {
+                if (has(cur) && !fits([...cur, c])) {
+                    lines.push(cur);
+                    cur = [];
+                }
+                cur.push(c);
+            }
+        });
+        lines.push(cur);
+        for (const l of lines) {
+            const vis = x.P
+                ? reorderLine(l, clusters, levels, x.p, x.P)
+                : l.map((index) => ({ index, cps: clusters[index].cps, odd: false }));
+            out.push({
+                size,
+                vis: vis.map((c) => c.cps.map((cp, k) => {
+                    const g = glyph(cp, x);
+                    const was = clusters[c.index].cps[k];
+                    return cp === was ? g : { ...g, actual: was };
+                })),
+                idx: vis.map((c) => c.index),
+                odd: vis.map((c) => c.odd),
+                inOrder: vis.every((c, k) => k === 0 || c.index > vis[k - 1].index),
+            });
+        }
+    }
+    return out;
+}
+const pt = (v) => `${Math.floor(v / 10)}.${v % 10}`;
+/** A length in 1/10000 pt. */
+const pt4 = (v) => {
+    const a = Math.abs(v);
+    return `${v < 0 ? "-" : ""}${Math.floor(a / 10000)}.${String(a % 10000).padStart(4, "0")}`;
+};
+const pdfString = (cs) => `(${cs.map((c) => (c === 0x28 || c === 0x29 || c === 0x5c ? `\\${String.fromCharCode(c)}` : String.fromCharCode(c))).join("")})`;
+const utf16 = (s) => Array.from({ length: s.length }, (_, i) => s.charCodeAt(i).toString(16).toUpperCase().padStart(4, "0")).join("");
+const mirrorOf = (g) => g.actual !== null;
+/** §6.4: one line drawn glyph by glyph (runs of one font, marks centered on their base). */
+function drawLine(line, y, x) {
+    const { size, vis } = line;
+    const total = vis.reduce((n, c) => n + c.reduce((k, g) => k + (g.mark === null ? g.w : 0), 0), 0);
+    if (!vis.some((c) => c.length))
+        return "";
+    let at = x.p ? (PAGE_W - MARGIN) * 1000 - size * total : MARGIN * 1000;
+    const y0 = y * 1000;
+    // Each run (one font, one direction) is placed by its own matrix, in visual order inside the run,
+    // and the runs are written in logical order (§6.4).
+    const ops = [];
+    let run = [];
+    let runX = 0;
+    let runKey = 0;
+    let runOdd = false;
+    const str = (f, gs) => f === 1
+        ? pdfString(gs.map((g) => g.code))
+        : `<${gs.map((g) => g.code.toString(16).padStart(4, "0")).join("")}>`;
+    const emit = (gs, gx, gy, key) => {
+        const f = gs[0].f;
+        for (const g of gs)
+            if (f === 2)
+                x.used.set(g.code, g.w);
+        const tj = `1 0 0 1 ${pt4(gx)} ${pt4(gy)} Tm ${str(f, gs)} Tj`;
+        const a = gs[0].actual;
+        // a mirrored bracket copies as the character it stands for
+        ops.push({
+            key,
+            f,
+            s: a === null
+                ? tj
+                : `/Span << /ActualText <FEFF${utf16(String.fromCodePoint(a))}> >> BDC ${tj} EMC`,
+        });
+    };
+    // the marks on the run's letters, written after it so that a run isn't split
+    let marks = [];
+    const flush = () => {
+        if (run.length)
+            emit(run, runX, y0, runKey);
+        for (const [g, gx, gy, index] of marks)
+            emit([g], gx, gy, run.length ? runKey : index);
+        run = [];
+        marks = [];
+    };
+    vis.forEach((cluster, k) => {
+        const index = line.idx[k];
+        const odd = line.odd[k];
+        const base = cluster.find((g) => g.mark === null);
+        const bx = at;
+        let top = base ? base.y1 : 0;
+        let bottom = base ? base.y0 : 0;
+        for (const g of cluster) {
+            if (g.mark === null) {
+                if (run.length &&
+                    (run[0].f !== g.f ||
+                        runOdd !== odd ||
+                        mirrorOf(g) ||
+                        mirrorOf(run[0])))
+                    flush();
+                if (!run.length) {
+                    runX = at;
+                    runKey = index;
+                    runOdd = odd;
+                }
+                runKey = Math.min(runKey, index);
+                run.push(g);
+                at += size * g.w;
+                continue;
+            }
+            let rise;
+            if (g.y0 + g.y1 >= 0) {
+                rise = Math.max(0, top + MARK_GAP - g.y0);
+                top = g.y1 + rise;
+            }
+            else {
+                rise = Math.min(0, bottom - MARK_GAP - g.y1);
+                bottom = g.y0 + rise;
+            }
+            marks.push([
+                g,
+                bx + Math.floor((size * (base ? base.w : 0)) / 2) - size * g.mark,
+                y0 + size * rise,
+                index,
+            ]);
+        }
+    });
+    flush();
+    // a stable sort: the marks stay after the run that holds their letters
+    ops.sort((a, b) => a.key - b.key);
+    let font = 0;
+    const body = ops.map((o) => {
+        const tf = o.f === font ? "" : `/F${o.f} ${pt(size)} Tf `;
+        font = o.f;
+        return tf + o.s;
+    });
+    return `BT ${body.join(" ")} ET\n`;
+}
+/** Page content streams (latin1 strings). */
+function pages(markdown, x) {
+    const out = [];
+    let page = "";
+    let y = PAGE_H - MARGIN;
+    let top = true;
+    for (const line of layout(markdown, x)) {
+        const { size } = line;
+        const lead = size === 0 ? 60 : Math.floor((size * 14) / 10);
+        const before = size > SIZES.body && !top ? 60 : 0;
+        if (y - before - lead < MARGIN) {
+            out.push(page);
+            page = "";
+            y = PAGE_H - MARGIN;
+            top = true;
+        }
+        if (size === 0) {
+            if (!top)
+                y -= lead;
+            continue;
+        }
+        y -= (top ? 0 : before) + lead;
+        top = false;
+        // a left-to-right line in WinAnsi alone is drawn as one string, as in v1
+        if (x.p === 0 && line.inOrder && line.vis.every((c) => c.every((g) => g.f === 1)))
+            page += `BT /F1 ${pt(size)} Tf ${pt(MARGIN)} ${pt(y)} Td ${pdfString(line.vis.flat().map((g) => g.code))} Tj ET\n`;
+        else
+            page += drawLine(line, y, x);
+    }
+    out.push(page);
+    return out;
+}
+// ---------------------------------------------------------------- DER
+const len = (n) => {
+    if (n < 0x80)
+        return [n];
+    const b = [];
+    for (let v = n; v > 0; v = Math.floor(v / 256))
+        b.unshift(v % 256);
+    return [0x80 | b.length, ...b];
+};
+const tlv = (tag, ...parts) => {
+    const body = cat(parts);
+    return cat([Uint8Array.from([tag, ...len(body.length)]), body]);
+};
+const seq = (...p) => tlv(0x30, ...p);
+const set = (...p) => tlv(0x31, ...p);
+function oid(s) {
+    const [a, b, ...rest] = s.split(".").map(Number);
+    const out = [a * 40 + b];
+    for (const n of rest) {
+        const g = [n & 0x7f];
+        for (let v = Math.floor(n / 128); v > 0; v = Math.floor(v / 128))
+            g.unshift(0x80 | (v & 0x7f));
+        out.push(...g);
+    }
+    return tlv(0x06, Uint8Array.from(out));
+}
+const OID = {
+    data: "1.2.840.113549.1.7.1",
+    signedData: "1.2.840.113549.1.7.2",
+    contentType: "1.2.840.113549.1.9.3",
+    messageDigest: "1.2.840.113549.1.9.4",
+    signingCertV2: "1.2.840.113549.1.9.16.2.47",
+    sha256: "2.16.840.1.101.3.4.2.1",
+    sha512: "2.16.840.1.101.3.4.2.3",
+    ed25519: "1.3.101.112",
+    cn: "2.5.4.3",
+};
+/** One DER element at `at` (constructed ones parsed to their children). */
+function der(buf, at = 0, depth = 0) {
+    if (depth > 20 || at + 2 > buf.length)
+        throw new Error("der: bad input");
+    const tag = buf[at];
+    let n = buf[at + 1];
+    let p = at + 2;
+    if (n & 0x80) {
+        const k = n & 0x7f;
+        if (k < 1 || k > 4)
+            throw new Error("der: bad length");
+        n = 0;
+        for (let i = 0; i < k; i++)
+            n = n * 256 + buf[p++];
+    }
+    if (p + n > buf.length)
+        throw new Error("der: truncated");
+    const value = buf.subarray(p, p + n);
+    const children = [];
+    if (tag & 0x20)
+        for (let q = 0; q < value.length;) {
+            const c = der(value, q, depth + 1);
+            children.push(c);
+            q += c.raw.length;
+        }
+    return { tag, raw: buf.subarray(at, p + n), value, children };
+}
+function oidOf(n) {
+    if (n?.tag !== 0x06)
+        return "";
+    const v = n.value;
+    const parts = [Math.floor(v[0] / 40), v[0] % 40];
+    let x = 0;
+    for (const b of v.subarray(1)) {
+        x = x * 128 + (b & 0x7f);
+        if (!(b & 0x80)) {
+            parts.push(x);
+            x = 0;
+        }
+    }
+    return parts.join(".");
+}
+// ---------------------------------------------------------------- the signature
+const PKCS8 = Buffer.from("302e020100300506032b657004220420", "hex");
+const SPKI = Buffer.from("302a300506032b6570032100", "hex");
+const privateKey = (seed) => createPrivateKey({
+    key: Buffer.concat([PKCS8, Buffer.from(seed)]),
+    format: "der",
+    type: "pkcs8",
+});
+const ed25519 = () => seq(oid(OID.ed25519));
+/** spec/pdf.md §3: the identity's self-signed X.509 certificate (v1, CN = its did:key). */
+export function pdfCertificate(seed) {
+    const key = privateKey(seed);
+    const pub = new Uint8Array(Buffer.from(createPublicKey(key).export({ format: "jwk" }).x, "base64url"));
+    const name = seq(set(seq(oid(OID.cn), tlv(0x0c, enc.encode(didFromPublicKey(pub))))));
+    const serial = sha("sha256", pub).slice(0, 8);
+    serial[0] = (serial[0] & 0x7f) | 0x40;
+    const tbs = seq(tlv(0x02, serial), ed25519(), name, seq(tlv(0x17, latin1("000101000000Z")), tlv(0x18, latin1("99991231235959Z"))), name, seq(ed25519(), tlv(0x03, Uint8Array.of(0), pub)));
+    const sig = new Uint8Array(sign(null, tbs, key));
+    return seq(tbs, ed25519(), tlv(0x03, Uint8Array.of(0), sig));
+}
+/** CMS SignedData, detached, PAdES baseline B (spec/pdf.md §3). */
+function cms(content, seed) {
+    const cert = pdfCertificate(seed);
+    const tbs = der(der(cert).children[0]?.raw);
+    const issuer = tbs.children[2]?.raw;
+    const serial = tbs.children[0]?.raw;
+    const attrs = [
+        seq(oid(OID.contentType), set(oid(OID.data))),
+        seq(oid(OID.messageDigest), set(tlv(0x04, sha("sha512", content)))),
+        seq(oid(OID.signingCertV2), set(seq(seq(seq(tlv(0x04, sha("sha256", cert))))))),
+    ].sort((a, b) => Buffer.compare(a, b));
+    const sig = new Uint8Array(sign(null, set(...attrs), privateKey(seed)));
+    const digestAlg = seq(oid(OID.sha512));
+    const signer = seq(tlv(0x02, Uint8Array.of(1)), seq(issuer, serial), digestAlg, tlv(0xa0, ...attrs), ed25519(), tlv(0x04, sig));
+    return seq(oid(OID.signedData), tlv(0xa0, seq(tlv(0x02, Uint8Array.of(1)), set(digestAlg), seq(oid(OID.data)), tlv(0xa0, cert), set(signer))));
+}
+// ---------------------------------------------------------------- the file
+const SIG_BYTES = 4096;
+const ISO = /^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(?:\.\d+)?Z$/;
+const NAME = /^[A-Za-z0-9._-]{1,64}$/;
+const xml = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const ascii = (s) => pdfString(codes(s));
+/** spec/pdf.md: the report as a signed PDF/A-3b file. `seed` is the signer's Ed25519 seed. */
+export function reportPdf(input, seed, assets) {
+    const t = ISO.exec(input.at);
+    if (!t)
+        throw new Error("at must be ISO-8601 UTC with Z");
+    const [, Y, Mo, D, H, Mi, S] = t;
+    const pdfDate = `D:${Y}${Mo}${D}${H}${Mi}${S}Z`;
+    const xmpDate = `${Y}-${Mo}-${D}T${H}:${Mi}:${S}Z`;
+    const files = [...input.attachments].sort((a, b) => (a.name < b.name ? -1 : 1));
+    for (const f of files)
+        if (!NAME.test(f.name) || !/^[a-z]+\/[a-z0-9.+-]+$/.test(f.mime))
+            throw new Error(`bad attachment ${f.name}`);
+    const m = assets.metrics;
+    const lang = input.lang ?? "en";
+    if (lang !== "en" && lang !== "ar")
+        throw new Error("lang must be en or ar");
+    const ctx = context(assets, lang);
+    const contents = pages(input.markdown, ctx);
+    const f2 = ctx.used.size ? 11 + 2 * files.length + 2 * contents.length : 0;
+    const FONT = `ZBBXPA+${m.name}`;
+    const fileObj = (i) => 11 + 2 * i;
+    const pageObj = (i) => 11 + 2 * files.length + 2 * i;
+    const objs = [];
+    const dict = (s) => latin1(s);
+    const stream = (head, body) => cat([
+        latin1(`<< ${head}${head ? " " : ""}/Length ${body.length} >>\nstream\n`),
+        body,
+        latin1("\nendstream"),
+    ]);
+    const afs = files.map((_, i) => `${fileObj(i)} 0 R`).join(" ");
+    objs[1] = dict(`<< /Type /Catalog /Pages 2 0 R /Metadata 3 0 R /OutputIntents [4 0 R] /AcroForm << /Fields [10 0 R] /SigFlags 3 >>${files.length ? ` /Names << /EmbeddedFiles << /Names [${files.map((f, i) => `(${f.name}) ${fileObj(i)} 0 R`).join(" ")}] >> >> /AF [${afs}]` : ""} /Lang (${lang}) >>`);
+    objs[2] = dict(`<< /Type /Pages /Kids [${contents.map((_, i) => `${pageObj(i)} 0 R`).join(" ")}] /Count ${contents.length} >>`);
+    const xmp = enc.encode(`<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>\n<x:xmpmeta xmlns:x="adobe:ns:meta/">\n<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">\n<rdf:Description rdf:about="" xmlns:pdfaid="http://www.aiim.org/pdfa/ns/id/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:xmp="http://ns.adobe.com/xap/1.0/" xmlns:pdf="http://ns.adobe.com/pdf/1.3/">\n<pdfaid:part>3</pdfaid:part>\n<pdfaid:conformance>B</pdfaid:conformance>\n<dc:format>application/pdf</dc:format>\n<dc:title><rdf:Alt><rdf:li xml:lang="x-default">${xml(input.title)}</rdf:li></rdf:Alt></dc:title>\n<xmp:CreateDate>${xmpDate}</xmp:CreateDate>\n<xmp:ModifyDate>${xmpDate}</xmp:ModifyDate>\n<xmp:CreatorTool>Zanii Blackbox</xmp:CreatorTool>\n<pdf:Producer>zanii-blackbox pdf v1</pdf:Producer>\n</rdf:Description>\n</rdf:RDF>\n</x:xmpmeta>\n<?xpacket end="w"?>`);
+    objs[3] = stream("/Type /Metadata /Subtype /XML", xmp);
+    objs[4] = dict("<< /Type /OutputIntent /S /GTS_PDFA1 /OutputConditionIdentifier (Gray gamma 2.2) /Info (Gray gamma 2.2) /DestOutputProfile 5 0 R >>");
+    objs[5] = stream("/N 1", assets.icc);
+    objs[6] = dict(`<< /Type /Font /Subtype /TrueType /BaseFont /${FONT} /FirstChar ${m.first_char} /LastChar ${m.first_char + m.widths.length - 1} /Widths [${m.widths.join(" ")}] /Encoding /WinAnsiEncoding /FontDescriptor 7 0 R >>`);
+    objs[7] = dict(`<< /Type /FontDescriptor /FontName /${FONT} /Flags ${m.flags} /FontBBox [${m.bbox.join(" ")}] /ItalicAngle ${m.italic_angle} /Ascent ${m.ascent} /Descent ${m.descent} /CapHeight ${m.cap_height} /StemV ${m.stem_v} /FontFile2 8 0 R >>`);
+    objs[8] = stream(`/Length1 ${assets.font.length}`, assets.font);
+    const BR = "/ByteRange [0 ********** ********** **********]";
+    objs[9] = dict(`<< /Type /Sig /Filter /Adobe.PPKLite /SubFilter /ETSI.CAdES.detached ${BR} /Contents <${"0".repeat(SIG_BYTES * 2)}> /M (${pdfDate}) >>`);
+    objs[10] = dict(`<< /Type /Annot /Subtype /Widget /FT /Sig /T (Signature1) /V 9 0 R /F 132 /Rect [0 0 0 0] /P ${pageObj(0)} 0 R >>`);
+    files.forEach((f, i) => {
+        objs[fileObj(i)] = dict(`<< /Type /Filespec /F (${f.name}) /UF (${f.name}) /AFRelationship /${f.relationship} /Desc ${ascii(f.description)} /EF << /F ${fileObj(i) + 1} 0 R /UF ${fileObj(i) + 1} 0 R >> >>`);
+        objs[fileObj(i) + 1] = stream(`/Type /EmbeddedFile /Subtype /${f.mime.replace("/", "#2F")} /Params << /ModDate (${pdfDate}) /Size ${f.bytes.length} >>`, f.bytes);
+    });
+    contents.forEach((c, i) => {
+        objs[pageObj(i)] = dict(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Resources << /Font << /F1 6 0 R${f2 ? ` /F2 ${f2} 0 R` : ""} >> >> /Contents ${pageObj(i) + 1} 0 R${i === 0 ? " /Annots [10 0 R]" : ""} >>`);
+        objs[pageObj(i) + 1] = stream("", latin1(c));
+    });
+    if (f2)
+        arabicFont(objs, f2, assets.arabic, ctx.used, stream);
+    const parts = [latin1("%PDF-1.7\n%\xe2\xe3\xcf\xd3\n")];
+    let at = parts[0]?.length;
+    const offsets = [];
+    for (let n = 1; n < objs.length; n++) {
+        offsets[n] = at;
+        const o = cat([latin1(`${n} 0 obj\n`), objs[n], latin1("\nendobj\n")]);
+        parts.push(o);
+        at += o.length;
+    }
+    const id = Buffer.from(sha("sha256", enc.encode(`${input.title}\n${input.at}\n${input.markdown}`)).slice(0, 16)).toString("hex");
+    parts.push(latin1(`xref\n0 ${objs.length}\n0000000000 65535 f \n${offsets
+        .slice(1)
+        .map((o) => `${String(o).padStart(10, "0")} 00000 n \n`)
+        .join("")}trailer\n<< /Size ${objs.length} /Root 1 0 R /ID [<${id}> <${id}>] >>\nstartxref\n${at}\n%%EOF\n`));
+    const pdf = cat(parts);
+    // §3: the signature covers every byte but its own /Contents
+    const text = Buffer.from(pdf).toString("latin1");
+    const a = text.indexOf("/Contents <", offsets[9]) + 10;
+    const b = a + SIG_BYTES * 2 + 2;
+    const range = `[0 ${a} ${b} ${pdf.length - b}]`.padEnd(BR.length - 11, " ");
+    pdf.set(latin1(range), text.indexOf(BR, offsets[9]) + 11);
+    const signed = cms(cat([pdf.subarray(0, a), pdf.subarray(b)]), seed);
+    if (signed.length > SIG_BYTES)
+        throw new Error("signature too large");
+    pdf.set(latin1(Buffer.from(signed).toString("hex")), a + 1);
+    return pdf;
+}
+/** §6.5: the Arabic subset as a Type0 font (Identity-H, glyph ids as CIDs), with the widths and
+ * the ToUnicode entries of the glyphs drawn. Objects n to n + 4. */
+function arabicFont(objs, n, a, used, stream) {
+    const am = a.metrics;
+    const name = `ZBBXPB+${am.name}`;
+    const gids = [...used.keys()].sort((x, y) => x - y);
+    const text = new Map(am.to_unicode.map(([g, t]) => [g, t.replaceAll(" ", "")]));
+    objs[n] = latin1(`<< /Type /Font /Subtype /Type0 /BaseFont /${name} /Encoding /Identity-H /DescendantFonts [${n + 1} 0 R] /ToUnicode ${n + 4} 0 R >>`);
+    objs[n + 1] = latin1(`<< /Type /Font /Subtype /CIDFontType2 /BaseFont /${name} /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> /FontDescriptor ${n + 2} 0 R /W [${gids.map((g) => `${g} [${used.get(g)}]`).join(" ")}] /CIDToGIDMap /Identity >>`);
+    objs[n + 2] = latin1(`<< /Type /FontDescriptor /FontName /${name} /Flags ${am.flags} /FontBBox [${am.bbox.join(" ")}] /ItalicAngle ${am.italic_angle} /Ascent ${am.ascent} /Descent ${am.descent} /CapHeight ${am.cap_height} /StemV ${am.stem_v} /FontFile2 ${n + 3} 0 R >>`);
+    objs[n + 3] = stream(`/Length1 ${a.font.length}`, a.font);
+    const hex4 = (g) => g.toString(16).toUpperCase().padStart(4, "0");
+    let chars = "";
+    for (let i = 0; i < gids.length; i += 100) {
+        const part = gids.slice(i, i + 100).filter((g) => text.has(g));
+        chars += `${part.length} beginbfchar\n${part.map((g) => `<${hex4(g)}> <${text.get(g)}>\n`).join("")}endbfchar\n`;
+    }
+    objs[n + 4] = stream("", latin1(`/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n/CMapName /Adobe-Identity-UCS def\n/CMapType 2 def\n1 begincodespacerange\n<0000> <FFFF>\nendcodespacerange\n${chars}endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend`));
+}
+/** spec/pdf.md §4: checks the signature (the ByteRange digest and the CMS signature, against the
+ * certificate inside) and the PDF/A-3b structure as far as it can be checked offline. */
+export function verifyPdf(pdf) {
+    const text = Buffer.from(pdf).toString("latin1");
+    const problems = [];
+    const pdfa = [];
+    let signer = null;
+    const br = [...text.matchAll(/\/ByteRange \[\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s*\]/g)].at(-1);
+    const m = [...text.matchAll(/\/M \(D:(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)Z\)/g)].at(-1);
+    const signedAt = m ? `${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}Z` : null;
+    if (!br)
+        problems.push("no signature");
+    else {
+        const [r0, r1, r2, r3] = br.slice(1, 5).map(Number);
+        if (r0 !== 0 || r1 >= r2 || r2 + r3 !== pdf.length)
+            problems.push("the signature does not cover the whole file");
+        else if (text[r1] !== "<" || text[r2 - 1] !== ">")
+            problems.push("bad ByteRange");
+        else
+            try {
+                signer = checkCms(Buffer.from(text.slice(r1 + 1, r2 - 1), "hex"), cat([pdf.subarray(0, r1), pdf.subarray(r2, r2 + r3)]), problems);
+            }
+            catch {
+                problems.push("the signature is not CMS");
+            }
+    }
+    // PDF/A-3b, the parts checkable without veraPDF
+    if (!text.startsWith("%PDF-1.") || !/^%PDF-1\.\d\r?\n%[\x80-\xff]{4}/.test(text))
+        pdfa.push("header");
+    if (!/<pdfaid:part>3<\/pdfaid:part>/.test(text) || !/<pdfaid:conformance>B</.test(text))
+        pdfa.push("XMP pdfaid");
+    if (!/\/OutputIntents \[/.test(text) || !/\/S \/GTS_PDFA1/.test(text))
+        pdfa.push("OutputIntent");
+    if (/\/Encrypt\b|\/JavaScript\b|\/JS\b/.test(text))
+        pdfa.push("forbidden key");
+    if (!/\/ID \[<[0-9a-f]+> <[0-9a-f]+>\]/.test(text))
+        pdfa.push("trailer ID");
+    if (!text.endsWith("%%EOF\n"))
+        pdfa.push("EOF");
+    const fonts = text.match(/\/Type \/FontDescriptor\b/g)?.length ?? 0;
+    if (fonts === 0 || (text.match(/\/FontFile2 \d+ 0 R/g)?.length ?? 0) < fonts)
+        pdfa.push("fonts embedded");
+    const xref = objects(text, pdfa);
+    const attachments = [];
+    for (const spec of text.matchAll(/\/Type \/Filespec \/F \(([^)]*)\) \/UF \([^)]*\) \/AFRelationship \/(\w+) .*?\/EF << \/F (\d+) 0 R/g)) {
+        const at = xref.get(Number(spec[3]));
+        const s = at === undefined ? null : streamAt(pdf, text, at);
+        if (!s || !/\/Type \/EmbeddedFile/.test(s.head) || !/\/ModDate/.test(s.head)) {
+            pdfa.push(`embedded file ${spec[1]}`);
+            continue;
+        }
+        attachments.push({
+            name: spec[1],
+            mime: (/\/Subtype \/([\w#.+-]+)/.exec(s.head)?.[1] ?? "").replace("#2F", "/"),
+            relationship: spec[2],
+            sha256: Buffer.from(sha("sha256", s.bytes)).toString("hex"),
+            size: s.bytes.length,
+        });
+    }
+    if ((text.match(/\/Type \/Filespec/g)?.length ?? 0) !== attachments.length)
+        pdfa.push("AFRelationship");
+    return {
+        ok: problems.length === 0 && pdfa.length === 0,
+        signer,
+        signed_at: signedAt,
+        pdfa: { ok: pdfa.length === 0, problems: pdfa },
+        attachments,
+        problems,
+    };
+}
+/** The xref table: object number to offset, each checked to start that object. */
+function objects(text, pdfa) {
+    const out = new Map();
+    const sx = /startxref\n(\d+)\n%%EOF\n$/.exec(text);
+    const x = sx ? Number(sx[1]) : -1;
+    const head = /^xref\n0 (\d+)\n/.exec(text.slice(x, x + 30));
+    if (!head) {
+        pdfa.push("xref");
+        return out;
+    }
+    const n = Number(head[1]);
+    const start = x + head[0].length;
+    for (let i = 1; i < n; i++) {
+        const off = Number(text.slice(start + 20 * i, start + 20 * i + 10));
+        if (!text.startsWith(`${i} 0 obj\n`, off)) {
+            pdfa.push("xref");
+            return out;
+        }
+        out.set(i, off);
+    }
+    return out;
+}
+function streamAt(pdf, text, at) {
+    const s = text.indexOf("stream\n", at);
+    const head = text.slice(at, s);
+    const n = /\/Length (\d+) >>\n$/.exec(head);
+    if (s < 0 || !n)
+        return null;
+    return { head, bytes: pdf.subarray(s + 7, s + 7 + Number(n[1])) };
+}
+/** The CMS checks of spec/pdf.md §4; the signer's did:key, or null with a problem added. */
+function checkCms(sig, content, problems) {
+    const ci = der(sig);
+    if (oidOf(ci.children[0]) !== OID.signedData)
+        throw new Error("not signed data");
+    const sd = ci.children[1]?.children[0];
+    const [, , encap, certs, infos] = sd.children;
+    if ((encap?.children.length ?? 0) !== 1)
+        problems.push("the signature is not detached");
+    const cert = certs?.children[0];
+    const si = infos?.children[0];
+    const [, , digestAlg, attrs, sigAlg, value] = si.children;
+    const alg = oidOf(digestAlg?.children[0]);
+    const hashName = alg === OID.sha512 ? "sha512" : alg === OID.sha256 ? "sha256" : null;
+    if (!hashName || !attrs || attrs.tag !== 0xa0)
+        throw new Error("bad signer info");
+    const attr = (o) => attrs.children.find((a) => oidOf(a.children[0]) === o)?.children[1];
+    if (oidOf(attr(OID.contentType)?.children[0]) !== OID.data)
+        problems.push("content type");
+    const md = attr(OID.messageDigest)?.children[0]?.value;
+    if (!md || Buffer.compare(md, sha(hashName, content)) !== 0)
+        problems.push("the file was changed after signing");
+    const certHash = attr(OID.signingCertV2)?.children[0]?.children[0]?.children[0]?.children.at(-1);
+    if (!certHash || Buffer.compare(certHash.value, sha("sha256", cert.raw)) !== 0)
+        problems.push("signing-certificate-v2");
+    const tbs = cert.children[0];
+    const spki = tbs.children[tbs.children[0]?.tag === 0xa0 ? 6 : 5];
+    const pub = spki.children[1].value.subarray(1);
+    if (oidOf(sigAlg?.children[0]) !== OID.ed25519 || pub.length !== 32) {
+        problems.push("not an Ed25519 signature");
+        return null;
+    }
+    const key = createPublicKey({ key: Buffer.concat([SPKI, pub]), format: "der", type: "spki" });
+    const signedAttrs = cat([Uint8Array.of(0x31), attrs.raw.subarray(1)]);
+    if (!verify(null, signedAttrs, key, value.value)) {
+        problems.push("bad signature");
+        return null;
+    }
+    return didFromPublicKey(new Uint8Array(pub));
+}

package/dist/policy/index.d.ts

@@ -76,9 +76,5 @@ export declare function audited(compiled: readonly Compiled[], names: readonly s
     rule: string;
     would: Rule["action"];
 }>;
-/**
- * spec/policy.md §2 as findings: POLICY_DENIED for MCP calls the gateway refused (tool.call meta.policy),
- * POLICY_VIOLATION for tools a model response asked for that a deny rule matches.
- */
 export declare function policyFindings(lines: readonly string[], bodies: Bodies, compiled: CompiledPolicy): Finding[];
 export {};