@awacloud/pdf 0.0.0-stage → 1.0.0

package/src/extra/legacy-xfa-read.js

@@ -0,0 +1,104 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview Opt-in: LEGACY read-only /XFA reader.
+ *
+ * PDF 2.0 forbids XFA on write, but legacy documents still need to be
+ * parsed. The /XFA entry on the AcroForm dict comes in two shapes:
+ *
+ *   (a) a single stream containing a complete XDP document, or
+ *   (b) an array alternating string-keys and streams, e.g.
+ *       ['preamble', stream, 'config', stream, 'template', stream, …].
+ *
+ * This extra surfaces the packets as opaque XML byte buffers on a
+ * `_legacy.xfa` object — no further interpretation is attempted.
+ *
+ * @module pdf/extra/legacy-xfa-read
+ */
+
+import { pdfErrors } from '../errors.js';
+
+export const pdfLegacyXfaRead = {
+    name: 'pdfLegacyXfaRead',
+    dependencies: ['pdfErrors'],
+    deps: [pdfErrors],
+
+    factory(errors) {
+        const { ParseError } = errors;
+        const KNOWN_PACKETS = new Set([
+            'xdp', 'preamble', 'config', 'template', 'localeSet',
+            'datasets', 'form', 'connectionSet', 'sourceSet',
+            'stylesheet', 'xmpmeta', 'signature', 'postamble', 'pdf'
+        ]);
+
+        function isStream(v) { return v && v.type === 'stream'; }
+        function isStr(v) { return v && v.type === 'string'; }
+        function isArr(v) { return v && v.type === 'array'; }
+
+        function streamBytes(s) {
+            if (!isStream(s)) {
+                throw new ParseError('pdf/xfa/bad-packet',
+                    'XFA packet must be a stream',
+                    { context: { type: s && s.type } });
+            }
+            return s.raw;
+        }
+
+        function decodeString(v) {
+            if (!isStr(v)) {
+                throw new ParseError('pdf/xfa/bad-key',
+                    'XFA array key must be a PDF string',
+                    { context: { type: v && v.type } });
+            }
+            const b = v.value;
+            if (b instanceof Uint8Array) return new TextDecoder('latin1').decode(b);
+            return String(b);
+        }
+
+        function readXfa(xfa) {
+            if (isStream(xfa)) {
+                return {
+                    _legacy: { xfa: { shape: 'stream', xdp: streamBytes(xfa) } }
+                };
+            }
+            if (isArr(xfa)) {
+                if (xfa.items.length % 2 !== 0) {
+                    throw new ParseError('pdf/xfa/odd-array',
+                        'XFA array must have even item count (key/stream pairs)',
+                        { context: { length: xfa.items.length } });
+                }
+                const packets = {};
+                const order = [];
+                const unknown = [];
+                for (let i = 0; i < xfa.items.length; i += 2) {
+                    const key = decodeString(xfa.items[i]);
+                    const bytes = streamBytes(xfa.items[i + 1]);
+                    packets[key] = bytes;
+                    order.push(key);
+                    if (!KNOWN_PACKETS.has(key)) unknown.push(key);
+                }
+                return {
+                    _legacy: {
+                        xfa: { shape: 'array', packets, order, unknownPackets: unknown }
+                    }
+                };
+            }
+            throw new ParseError('pdf/xfa/bad-shape',
+                '/XFA must be a stream or array',
+                { context: { type: xfa && xfa.type } });
+        }
+
+        function isKnownPacket(name) {
+            return KNOWN_PACKETS.has(String(name));
+        }
+
+        return {
+            readXfa,
+            isKnownPacket,
+            KNOWN_PACKETS
+        };
+    }
+};

package/src/extra/linearization-write.js

@@ -0,0 +1,97 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview Opt-in: Linearization Parameter Dictionary emitter
+ * (builds and validates the dictionary; the hint stream is an empty stub).
+ *
+ * @module pdf/extra/linearization-write
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfLinearizationWrite = {
+    name: 'pdfLinearizationWrite',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { RenderError } = errors;
+        const { obj } = parser;
+
+        /** Frozen list of required entries (§F.2 Table F.1). */
+        const LINEARIZED_KEYS = Object.freeze([
+            'Linearized', 'L', 'H', 'O', 'E', 'N', 'T'
+        ]);
+
+        function buildLinearizedDict(p) {
+            if (!p || typeof p !== 'object') {
+                throw new RenderError('pdf/extra/linwrite/bad-params',
+                    'buildLinearizedDict requires a parameters object',
+                    { context: { type: typeof p } });
+            }
+            for (const k of ['fileLength', 'firstPageObj', 'firstPageEnd',
+                             'pageCount', 'mainXrefOffset']) {
+                if (!Number.isFinite(p[k])) {
+                    throw new RenderError('pdf/extra/linwrite/missing-' + k,
+                        'parameter ' + k + ' is required and must be a number',
+                        { context: { key: k, type: typeof p[k] } });
+                }
+            }
+            if (!Number.isFinite(p.hintOffset) || !Number.isFinite(p.hintLength)) {
+                throw new RenderError('pdf/extra/linwrite/missing-hint',
+                    'hintOffset and hintLength are required',
+                    { context: { hintOffset: p.hintOffset, hintLength: p.hintLength } });
+            }
+            const entries = {
+                Linearized: obj.real(p.version != null ? p.version : 1.0),
+                L: obj.int(p.fileLength),
+                H: obj.array([obj.int(p.hintOffset), obj.int(p.hintLength)]),
+                O: obj.int(p.firstPageObj),
+                E: obj.int(p.firstPageEnd),
+                N: obj.int(p.pageCount),
+                T: obj.int(p.mainXrefOffset)
+            };
+            if (p.firstPage != null) entries.P = obj.int(p.firstPage);
+            return obj.dict(entries);
+        }
+
+        function buildHintStreamStub() {
+            const dict = obj.dict({
+                Length: obj.int(0),
+                S: obj.int(0)
+            });
+            return obj.stream(dict, new Uint8Array(0));
+        }
+
+        function validateLinearizedDict(dict) {
+            if (!dict || dict.type !== 'dict') {
+                throw new RenderError('pdf/extra/linwrite/validate/not-dict',
+                    'expected a dict',
+                    { context: { type: dict && dict.type } });
+            }
+            const errs = [];
+            for (const k of LINEARIZED_KEYS) {
+                if (!dict.entries[k]) errs.push('missing /' + k);
+            }
+            const h = dict.entries.H;
+            if (h && (h.type !== 'array' || h.items.length < 2)) {
+                errs.push('/H must be an array of at least 2 integers');
+            }
+            return { pass: errs.length === 0, errors: errs, warnings: [] };
+        }
+
+        return {
+            buildLinearizedDict,
+            buildHintStreamStub,
+            validateLinearizedDict,
+            LINEARIZED_KEYS
+        };
+    }
+};
+

package/src/extra/misc.js

@@ -0,0 +1,217 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview Opt-in: miscellaneous tail typing.
+ *
+ * Covers the long tail of Catalog-level entries that don't warrant
+ * their own L1 module:
+ *
+ *   - /SpiderInfo      — Web-Capture provenance (ISO 32000-2 §14.10.2).
+ *   - /Threads         — array of article-thread dicts (§12.4.3).
+ *   - /Legal           — legal-attestation dict (§12.8.5).
+ *   - /Requirements    — array of requirement dicts (§12.10).
+ *   - /Perms           — extra permission flavours beyond /UR3, notably
+ *                        /DocMDP transformation parameters (§12.8.2.2).
+ *   - /NeedsRendering  — boolean indicator for XFA-bearing forms.
+ *
+ * @module pdf/extra/misc
+ */
+
+import { pdfErrors } from '../errors.js';
+
+export const pdfMisc = {
+    name: 'pdfMisc',
+    dependencies: ['pdfErrors'],
+    deps: [pdfErrors],
+
+    factory(errors) {
+        const { ParseError } = errors;
+        const REQUIREMENT_S_VALUES = new Set([
+            'EnableJavaScripts'
+        ]);
+
+        function isDict(v) { return v && v.type === 'dict'; }
+        function isName(v) { return v && v.type === 'name'; }
+        function isArr(v) { return v && v.type === 'array'; }
+        function isBool(v) { return v && v.type === 'bool'; }
+        function isInt(v) { return v && v.type === 'int'; }
+
+        function typeSpiderInfo(dict) {
+            if (!isDict(dict)) {
+                throw new ParseError('pdf/misc/spider-not-dict',
+                    '/SpiderInfo must be a dict');
+            }
+            const e = dict.entries;
+            const out = { raw: dict, _extras: {} };
+            if (e.V) {
+                if (!isInt(e.V) && !(e.V && e.V.type === 'real')) {
+                    throw new ParseError('pdf/misc/spider-bad-V',
+                        '/SpiderInfo /V must be numeric');
+                }
+                out.version = e.V.value;
+            }
+            if (e.C) {
+                if (!isArr(e.C)) {
+                    throw new ParseError('pdf/misc/spider-bad-C',
+                        '/SpiderInfo /C must be an array');
+                }
+                out.commands = e.C.items;
+            }
+            const KNOWN = new Set(['V', 'C']);
+            for (const k of Object.keys(e)) {
+                if (!KNOWN.has(k)) out._extras[k] = e[k];
+            }
+            return out;
+        }
+
+        function typeThreads(arr) {
+            if (!isArr(arr)) {
+                throw new ParseError('pdf/misc/threads-not-array',
+                    '/Threads must be an array');
+            }
+            const out = [];
+            for (let i = 0; i < arr.items.length; i++) {
+                const it = arr.items[i];
+                if (it.type !== 'ref' && !isDict(it)) {
+                    throw new ParseError('pdf/misc/thread-bad-entry',
+                        '/Threads entry must be a dict or ref',
+                        { context: { index: i } });
+                }
+                out.push(it);
+            }
+            return out;
+        }
+
+        function typeLegal(dict) {
+            if (!isDict(dict)) {
+                throw new ParseError('pdf/misc/legal-not-dict',
+                    '/Legal must be a dict');
+            }
+            const e = dict.entries;
+            const out = { raw: dict, flags: {}, _extras: {} };
+            const KNOWN_FLAGS = new Set([
+                'JavaScriptActions', 'LaunchActions', 'URIActions',
+                'MovieActions', 'SoundActions', 'HiddenAnnotations',
+                'NonEmbeddedFonts', 'DevDepGS_OP', 'DevDepGS_HT',
+                'DevDepGS_TR', 'DevDepGS_UCR', 'DevDepGS_FL', 'DevDepGS_BG',
+                'Annotations', 'ExternalRefXobjects', 'ExternalOPIdicts',
+                'ExternalStreams', 'TrueTypeFonts', 'AlternateImages'
+            ]);
+            for (const [k, v] of Object.entries(e)) {
+                if (KNOWN_FLAGS.has(k)) {
+                    if (!isInt(v)) {
+                        throw new ParseError('pdf/misc/legal-bad-flag',
+                            `/Legal /${k} must be an integer count`,
+                            { context: { key: k } });
+                    }
+                    out.flags[k] = v.value;
+                } else if (k === 'Attestation') {
+                    if (v.type !== 'string') {
+                        throw new ParseError('pdf/misc/legal-bad-attestation',
+                            '/Attestation must be a string');
+                    }
+                    out.attestation = v.value;
+                } else {
+                    out._extras[k] = v;
+                }
+            }
+            return out;
+        }
+
+        function typeRequirements(arr) {
+            if (!isArr(arr)) {
+                throw new ParseError('pdf/misc/req-not-array',
+                    '/Requirements must be an array');
+            }
+            const out = [];
+            for (let i = 0; i < arr.items.length; i++) {
+                const it = arr.items[i];
+                if (!isDict(it)) {
+                    throw new ParseError('pdf/misc/req-bad-entry',
+                        '/Requirements entry must be a dict',
+                        { context: { index: i } });
+                }
+                const e = it.entries;
+                if (!e.S || !isName(e.S)) {
+                    throw new ParseError('pdf/misc/req-missing-S',
+                        '/Requirements entry needs /S name',
+                        { context: { index: i } });
+                }
+                out.push({
+                    raw: it,
+                    s: e.S.value,
+                    standard: REQUIREMENT_S_VALUES.has(e.S.value),
+                    rh: e.RH
+                });
+            }
+            return out;
+        }
+
+        function typeDocMdpParams(dict) {
+            if (!isDict(dict)) {
+                throw new ParseError('pdf/misc/docmdp-not-dict',
+                    '/DocMDP transform params must be a dict');
+            }
+            const e = dict.entries;
+            const out = { raw: dict, _extras: {} };
+            if (e.P) {
+                if (!isInt(e.P) || e.P.value < 1 || e.P.value > 3) {
+                    throw new ParseError('pdf/misc/docmdp-bad-P',
+                        '/DocMDP /P must be 1, 2, or 3');
+                }
+                out.permission = e.P.value;
+            }
+            if (e.V) {
+                if (!isName(e.V)) {
+                    throw new ParseError('pdf/misc/docmdp-bad-V',
+                        '/DocMDP /V must be a name');
+                }
+                out.version = e.V.value;
+            }
+            const KNOWN = new Set(['Type', 'P', 'V']);
+            for (const k of Object.keys(e)) {
+                if (!KNOWN.has(k)) out._extras[k] = e[k];
+            }
+            return out;
+        }
+
+        function typePerms(dict) {
+            if (!isDict(dict)) {
+                throw new ParseError('pdf/misc/perms-not-dict',
+                    '/Perms must be a dict');
+            }
+            const e = dict.entries;
+            const out = { raw: dict, _extras: {} };
+            if (e.DocMDP) out.docMDP = e.DocMDP;
+            if (e.UR3)    out.ur3    = e.UR3;
+            if (e.UR)     out.ur     = e.UR;
+            const KNOWN = new Set(['DocMDP', 'UR3', 'UR']);
+            for (const k of Object.keys(e)) {
+                if (!KNOWN.has(k)) out._extras[k] = e[k];
+            }
+            return out;
+        }
+
+        function typeNeedsRendering(v) {
+            if (!isBool(v)) {
+                throw new ParseError('pdf/misc/needsrendering-bad',
+                    '/NeedsRendering must be boolean');
+            }
+            return v.value;
+        }
+
+        return {
+            typeSpiderInfo,
+            typeThreads,
+            typeLegal,
+            typeRequirements,
+            typeDocMdpParams,
+            typePerms,
+            typeNeedsRendering,
+            REQUIREMENT_S_VALUES
+        };
+    }
+};

package/src/extra/optional-content-extended.js

@@ -0,0 +1,142 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview Opt-in: Extended OCG/OCMD support.
+ *
+ * ISO 32000-2 §8.11.2.4 defines OCMD `/VE` (Visibility Expression) as a
+ * nested array `[op, operand, ...]` with ops `And`, `Or`, `Not`. This
+ * module evaluates such expressions, types `/Order` trees with embedded
+ * sub-headings (string leaves), and surfaces RBGroups + `/Intent`
+ * routing (View vs Design).
+ *
+ * @module pdf/extra/optional-content-extended
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfOptionalContentExtended = {
+    name: 'pdfOptionalContentExtended',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+
+        const VE_OPERATORS = Object.freeze(['And', 'Or', 'Not']);
+
+        function evaluateVE(ve, on) {
+            if (!ve) {
+                throw new ParseError('pdf/extra/ocgx/ve/null',
+                    'VE expression is null');
+            }
+            if (!(on instanceof Set)) {
+                throw new ParseError('pdf/extra/ocgx/ve/bad-state',
+                    'evaluateVE requires a Set of on refs',
+                    { context: { type: typeof on } });
+            }
+            if (ve.type === 'ref') {
+                return on.has(ve.num + ' ' + ve.gen);
+            }
+            if (ve.type !== 'array' || ve.items.length === 0) {
+                throw new ParseError('pdf/extra/ocgx/ve/bad-shape',
+                    'VE must be an array starting with an operator',
+                    { context: { type: ve.type } });
+            }
+            const op = ve.items[0];
+            if (!isType(op, 'name') || !VE_OPERATORS.includes(op.value)) {
+                throw new ParseError('pdf/extra/ocgx/ve/bad-op',
+                    'VE operator must be /And, /Or or /Not',
+                    { context: { actual: op && op.value } });
+            }
+            const operands = ve.items.slice(1);
+            if (op.value === 'Not') {
+                if (operands.length !== 1) {
+                    throw new ParseError('pdf/extra/ocgx/ve/not-arity',
+                        '/Not requires exactly one operand');
+                }
+                return !evaluateVE(operands[0], on);
+            }
+            if (op.value === 'And') return operands.every(o => evaluateVE(o, on));
+            return operands.some(o => evaluateVE(o, on));
+        }
+
+        function typeOrderTree(arr) {
+            if (!arr || arr.type !== 'array') {
+                throw new ParseError('pdf/extra/ocgx/order/not-array',
+                    '/Order must be an array',
+                    { context: { type: arr && arr.type } });
+            }
+            const out = [];
+            for (const it of arr.items) {
+                if (!it) continue;
+                if (it.type === 'string') {
+                    out.push({ kind: 'heading', text: it.value });
+                } else if (it.type === 'array') {
+                    out.push({ kind: 'group', children: typeOrderTree(it) });
+                } else if (it.type === 'ref') {
+                    out.push({ kind: 'ocg', ref: { num: it.num, gen: it.gen } });
+                } else {
+                    out.push({ kind: 'other', value: it });
+                }
+            }
+            return out;
+        }
+
+        function typeRBGroups(arr) {
+            if (!arr || arr.type !== 'array') {
+                throw new ParseError('pdf/extra/ocgx/rbg/not-array',
+                    '/RBGroups must be an array',
+                    { context: { type: arr && arr.type } });
+            }
+            const out = [];
+            for (const grp of arr.items) {
+                if (!grp || grp.type !== 'array') {
+                    throw new ParseError('pdf/extra/ocgx/rbg/bad-group',
+                        '/RBGroups entry must be an array',
+                        { context: { type: grp && grp.type } });
+                }
+                const refs = [];
+                for (const r of grp.items) {
+                    if (!r || r.type !== 'ref') continue;
+                    refs.push({ num: r.num, gen: r.gen });
+                }
+                out.push(refs);
+            }
+            return out;
+        }
+
+        function classifyOcgIntent(v) {
+            if (!v) return { view: false, design: false, names: [] };
+            const names = [];
+            if (v.type === 'name') names.push(v.value);
+            else if (v.type === 'array') {
+                for (const it of v.items) if (isType(it, 'name')) names.push(it.value);
+            } else {
+                throw new ParseError('pdf/extra/ocgx/intent/bad',
+                    '/Intent must be name or array of names',
+                    { context: { type: v.type } });
+            }
+            return {
+                view:   names.includes('View'),
+                design: names.includes('Design'),
+                names
+            };
+        }
+
+        return {
+            evaluateVE,
+            typeOrderTree,
+            typeRBGroups,
+            classifyOcgIntent,
+            VE_OPERATORS
+        };
+    }
+};
+

package/src/extra/pdf-a-output-intent.js

@@ -0,0 +1,112 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview Opt-in: PDF/A validation helpers.
+ *
+ * Recognises an `/OutputIntent` whose `/S` is `GTS_PDFA1` (or later
+ * profile names introduced by ISO 19005-{2..4}), extracts the
+ * conformance level letter (a/b/u/e/f) and maps the
+ * `/OutputConditionIdentifier` to a known registry profile.
+ *
+ * @module pdf/extra/pdf-a-output-intent
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfAOutputIntent = {
+    name: 'pdfAOutputIntent',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+
+        const PDFA_PROFILES = Object.freeze({
+            '1a': { part: 1, level: 'a', iso: 'ISO 19005-1:2005', notes: 'accessible' },
+            '1b': { part: 1, level: 'b', iso: 'ISO 19005-1:2005', notes: 'basic'      },
+            '2a': { part: 2, level: 'a', iso: 'ISO 19005-2:2011', notes: 'accessible' },
+            '2b': { part: 2, level: 'b', iso: 'ISO 19005-2:2011', notes: 'basic'      },
+            '2u': { part: 2, level: 'u', iso: 'ISO 19005-2:2011', notes: 'unicode'    },
+            '3a': { part: 3, level: 'a', iso: 'ISO 19005-3:2012', notes: 'accessible + embed' },
+            '3b': { part: 3, level: 'b', iso: 'ISO 19005-3:2012', notes: 'basic + embed'      },
+            '3u': { part: 3, level: 'u', iso: 'ISO 19005-3:2012', notes: 'unicode + embed'    },
+            '4':  { part: 4, level: null, iso: 'ISO 19005-4:2020', notes: 'PDF 2.0 base' },
+            '4e': { part: 4, level: 'e', iso: 'ISO 19005-4:2020', notes: 'engineering' },
+            '4f': { part: 4, level: 'f', iso: 'ISO 19005-4:2020', notes: 'embedded files allowed' }
+        });
+
+        const VALID_LEVELS = new Set(['1a', '1b', '2a', '2b', '2u',
+            '3a', '3b', '3u', '4', '4e', '4f']);
+
+        function detectPdfAProfile(dict) {
+            if (!isType(dict, 'dict')) {
+                throw new ParseError('pdf/extra/pdfa/not-dict',
+                    'OutputIntent must be a dictionary',
+                    { context: { type: dict && dict.type } });
+            }
+            const e = dict.entries;
+            const s = isType(e.S, 'name') ? e.S.value : null;
+            const ident = isType(e.OutputConditionIdentifier, 'string')
+                ? new TextDecoder('latin1').decode(e.OutputConditionIdentifier.value)
+                : null;
+            const isPdfA = s === 'GTS_PDFA1';
+            const profile = profileFromIdentifier(ident);
+            return {
+                isPdfA,
+                subtype: s,
+                identifier: ident,
+                profile,
+                part:  profile ? PDFA_PROFILES[profile].part  : null,
+                level: profile ? PDFA_PROFILES[profile].level : null,
+                catalog: profile ? PDFA_PROFILES[profile] : null,
+                raw: dict
+            };
+        }
+
+        function profileFromIdentifier(s) {
+            if (!s) return null;
+            const m = s.match(/PDF\/A[-\s]?(1[ab]|2[abu]|3[abu]|4[ef]?)/i);
+            if (!m) return null;
+            const tag = m[1].toLowerCase();
+            return VALID_LEVELS.has(tag) ? tag : null;
+        }
+
+        function validatePdfABasics(typedDoc) {
+            if (!typedDoc || typeof typedDoc !== 'object') {
+                throw new ParseError('pdf/extra/pdfa/lint/bad-doc',
+                    'validatePdfABasics requires a typed document object',
+                    { context: { type: typeof typedDoc } });
+            }
+            const errors = [];
+            const warnings = [];
+            const cat = typedDoc.catalog && typedDoc.catalog.entries;
+            if (typedDoc.encrypted) errors.push('PDF/A forbids encryption');
+            if (!cat) {
+                errors.push('catalog missing');
+                return { pass: false, errors, warnings };
+            }
+            if (!cat.Metadata) errors.push('catalog requires /Metadata XMP stream');
+            if (cat.MarkInfo && (!isType(cat.MarkInfo, 'dict'))) {
+                errors.push('/MarkInfo must be a dictionary');
+            }
+            if (!cat.OutputIntents) {
+                warnings.push('catalog has no /OutputIntents array');
+            }
+            return { pass: errors.length === 0, errors, warnings };
+        }
+
+        return {
+            detectPdfAProfile,
+            validatePdfABasics,
+            PDFA_PROFILES
+        };
+    }
+};
+