pdf-oxide-fips 0.3.47

package/lib/index.js

@@ -0,0 +1,693 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+// PDF Oxide Node.js bindings - Native module loader
+import { createRequire } from 'node:module';
+import { dirname } from 'node:path';
+import { arch, platform } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { Align, AnnotationBuilder, ConversionOptionsBuilder, DocumentBuilder, EmbeddedFont, MetadataBuilder, PageBuilder, PdfBuilder, SearchOptionsBuilder, StreamingTable, } from './builders/index.js';
+import { DocumentEditor } from './document-editor.js';
+import { AccessibilityException, CertificateLoadFailed, ComplianceException, EncryptionException, ErrorCategory, ErrorSeverity, InvalidStateException, IoException, mapFfiErrorCode, OcrException, OptimizationException, ParseException, PdfException, RedactionException, RenderingException, SearchException, SignatureException, SigningFailed, UnknownError, UnsupportedFeatureException, ValidationException, wrapAsyncMethod, wrapError, wrapMethod, } from './errors.js';
+import { AnnotationManager, BatchManager, createExtractionStream, createMetadataStream, createSearchStream, ExtractionManager, ExtractionStream, LayerManager, MetadataManager, MetadataStream, OutlineManager, RenderingManager, SearchManager, SearchStream, SecurityManager, } from './managers/index.js';
+import { WorkerPool, workerPool } from './workers/index.js';
+// Create require function for CommonJS modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+// Phase 4+ managers (compiled JavaScript - use require for dynamic import)
+// Phase 9: Now imports from canonical consolidated managers in managers/
+const { OcrManager, OcrManager: OCRManager, OcrDetectionMode: OCRDetectionMode, ComplianceManager, PdfALevel, PdfXLevel, PdfUALevel, ComplianceIssueType, IssueSeverity, SignatureManager, SignatureAlgorithm, DigestAlgorithm, BarcodeManager, BarcodeFormat, BarcodeErrorCorrection, FormFieldManager, FormFieldType, FieldVisibility, ResultAccessorsManager, SearchResultProperties, FontProperties, ImageProperties, AnnotationProperties, ThumbnailManager, ThumbnailSize, ImageFormat, HybridMLManager, PageComplexity, ContentType, XfaManager, XfaFormType, XfaFieldType, CacheManager, EditingManager, AccessibilityManager, OptimizationManager, EnterpriseManager, } = require('../lib/managers/index.js');
+// OcrLanguage re-exported from canonical OcrManager
+const { OcrLanguage: OCRLanguage } = require('../lib/managers/ocr-manager.js');
+/**
+ * Platform-specific prebuild paths (relative to compiled lib/index.js).
+ * At runtime lib/index.js lives at js/lib/index.js, so ../prebuilds/
+ * resolves to js/prebuilds/.
+ */
+const PLATFORMS = {
+    darwin: {
+        x64: '../prebuilds/darwin-x64/pdf_oxide.node',
+        arm64: '../prebuilds/darwin-arm64/pdf_oxide.node',
+    },
+    linux: {
+        x64: '../prebuilds/linux-x64/pdf_oxide.node',
+        arm64: '../prebuilds/linux-arm64/pdf_oxide.node',
+    },
+    win32: {
+        x64: '../prebuilds/win32-x64/pdf_oxide.node',
+    },
+};
+/**
+ * Gets the prebuild path for the current platform and architecture
+ * @returns Path to the prebuild .node file (relative to lib/index.js)
+ * @throws Error if platform or architecture is not supported
+ */
+function getPrebuildPath() {
+    const osPaths = PLATFORMS[platform];
+    if (!osPaths) {
+        throw new Error(`Unsupported platform: ${platform}. Supported platforms: ${Object.keys(PLATFORMS).join(', ')}`);
+    }
+    const prebuildPath = osPaths[arch];
+    if (!prebuildPath) {
+        throw new Error(`Unsupported architecture: ${arch} for ${platform}. Supported architectures: ${Object.keys(osPaths).join(', ')}`);
+    }
+    return prebuildPath;
+}
+let nativeModule;
+/**
+ * Loads the native module dynamically based on platform and architecture.
+ * Prebuilt .node files are bundled under prebuilds/<triple>/ in the package.
+ * @returns Native module
+ * @throws Error if native module cannot be loaded
+ */
+function loadNativeModule() {
+    if (nativeModule) {
+        return nativeModule;
+    }
+    try {
+        const prebuildPath = getPrebuildPath();
+        try {
+            // Load the bundled prebuild .node file
+            nativeModule = require(prebuildPath);
+        }
+        catch (e) {
+            // Fallback to local build output if in development
+            if (process.env.NODE_ENV === 'development' || process.env.NAPI_DEV) {
+                try {
+                    nativeModule = require('./pdf-oxide');
+                }
+                catch {
+                    throw e;
+                }
+            }
+            else {
+                throw e;
+            }
+        }
+        return nativeModule;
+    }
+    catch (error) {
+        throw new Error(`Failed to load native module: ${error.message}`);
+    }
+}
+// Load native module
+const native = loadNativeModule();
+/**
+ * Wraps native class methods to convert errors to proper JavaScript Error subclasses.
+ * This ensures that errors thrown from native code are instanceof the appropriate Error class.
+ * @param nativeClass - The native class to wrap
+ * @param asyncMethods - Names of async methods to wrap specially
+ * @returns Wrapped class with error-handling methods
+ */
+function wrapNativeClass(nativeClass, asyncMethods = []) {
+    if (!nativeClass)
+        return nativeClass;
+    // For static methods like PdfDocument.open()
+    for (const key of Object.getOwnPropertyNames(nativeClass)) {
+        if (key !== 'prototype' &&
+            key !== 'length' &&
+            key !== 'name' &&
+            typeof nativeClass[key] === 'function') {
+            const isAsync = asyncMethods.includes(key);
+            if (isAsync) {
+                nativeClass[key] = wrapAsyncMethod(nativeClass[key], nativeClass);
+            }
+            else {
+                nativeClass[key] = wrapMethod(nativeClass[key], nativeClass);
+            }
+        }
+    }
+    // For instance methods, wrap the prototype
+    if (nativeClass.prototype) {
+        for (const key of Object.getOwnPropertyNames(nativeClass.prototype)) {
+            if (key !== 'constructor' && typeof nativeClass.prototype[key] === 'function') {
+                const isAsync = asyncMethods.includes(key);
+                const descriptor = Object.getOwnPropertyDescriptor(nativeClass.prototype, key);
+                if (descriptor && descriptor.writable) {
+                    if (isAsync) {
+                        nativeClass.prototype[key] = wrapAsyncMethod(nativeClass.prototype[key]);
+                    }
+                    else {
+                        nativeClass.prototype[key] = wrapMethod(nativeClass.prototype[key]);
+                    }
+                }
+            }
+        }
+    }
+    return nativeClass;
+}
+class PdfDocumentImpl {
+    constructor(handle) {
+        this._closed = false;
+        /** Promise-cached mutex; single Promise ensures no race on concurrent first calls. */
+        this._muPromise = null;
+        if (!handle)
+            throw new Error('Failed to open document');
+        this._handle = handle;
+    }
+    static open(path) {
+        const handle = native.openDocument(path);
+        return new PdfDocumentImpl(handle);
+    }
+    static openFromBuffer(buffer) {
+        const handle = native.openFromBuffer(buffer);
+        return new PdfDocumentImpl(handle);
+    }
+    static openWithPassword(path, password) {
+        const handle = native.openWithPassword(path, password);
+        return new PdfDocumentImpl(handle);
+    }
+    ensureOpen() {
+        if (this._closed)
+            throw new Error('Document is closed');
+    }
+    get handle() {
+        return this._handle;
+    }
+    pageCount() {
+        this.ensureOpen();
+        return native.getPageCount(this._handle);
+    }
+    getPageCount() {
+        return this.pageCount();
+    }
+    get PageCount() {
+        return this.pageCount();
+    }
+    extractText(pageIndex) {
+        this.ensureOpen();
+        return native.extractText(this._handle, pageIndex);
+    }
+    toMarkdown(pageIndex) {
+        this.ensureOpen();
+        return native.toMarkdown(this._handle, pageIndex);
+    }
+    toHtml(pageIndex) {
+        this.ensureOpen();
+        return native.toHtml(this._handle, pageIndex);
+    }
+    toPlainText(pageIndex) {
+        this.ensureOpen();
+        return native.toPlainText(this._handle, pageIndex);
+    }
+    toMarkdownAll() {
+        this.ensureOpen();
+        return native.toMarkdownAll(this._handle);
+    }
+    extractAllText() {
+        this.ensureOpen();
+        return native.extractAllText(this._handle);
+    }
+    toHtmlAll() {
+        this.ensureOpen();
+        return native.toHtmlAll(this._handle);
+    }
+    toPlainTextAll() {
+        this.ensureOpen();
+        return native.toPlainTextAll(this._handle);
+    }
+    getVersion() {
+        this.ensureOpen();
+        return native.getVersion(this._handle);
+    }
+    hasStructureTree() {
+        this.ensureOpen();
+        return native.hasStructureTree(this._handle);
+    }
+    hasXFA() {
+        this.ensureOpen();
+        return native.hasXFA(this._handle);
+    }
+    getPageWidth(pageIndex) {
+        this.ensureOpen();
+        return native.getPageWidth(this._handle, pageIndex);
+    }
+    getPageHeight(pageIndex) {
+        this.ensureOpen();
+        return native.getPageHeight(this._handle, pageIndex);
+    }
+    getPageRotation(pageIndex) {
+        this.ensureOpen();
+        return native.getPageRotation(this._handle, pageIndex);
+    }
+    searchPage(pageIndex, query, caseSensitive = false) {
+        this.ensureOpen();
+        return native.searchPage(this._handle, pageIndex, query, caseSensitive);
+    }
+    searchAll(query, caseSensitive = false) {
+        this.ensureOpen();
+        return native.searchAll(this._handle, query, caseSensitive);
+    }
+    getFormFields() {
+        this.ensureOpen();
+        return native.getFormFields(this._handle);
+    }
+    getOutline() {
+        this.ensureOpen();
+        return native.getOutline(this._handle);
+    }
+    getPageAnnotations(pageIndex) {
+        this.ensureOpen();
+        return native.getPageAnnotations(this._handle, pageIndex);
+    }
+    getEmbeddedFonts(pageIndex) {
+        this.ensureOpen();
+        return native.getEmbeddedFonts(this._handle, pageIndex);
+    }
+    getEmbeddedImages(pageIndex) {
+        this.ensureOpen();
+        return native.getEmbeddedImages(this._handle, pageIndex);
+    }
+    extractWords(pageIndex) {
+        this.ensureOpen();
+        return native.extractWords(this._handle, pageIndex);
+    }
+    extractTextLines(pageIndex) {
+        this.ensureOpen();
+        return native.extractTextLines(this._handle, pageIndex);
+    }
+    extractTables(pageIndex) {
+        this.ensureOpen();
+        return native.extractTables(this._handle, pageIndex);
+    }
+    extractPaths(pageIndex) {
+        this.ensureOpen();
+        return native.extractPaths(this._handle, pageIndex);
+    }
+    ocrExtractText(pageIndex, engineHandle) {
+        this.ensureOpen();
+        return native.ocrExtractText(this._handle, pageIndex, engineHandle);
+    }
+    /**
+     * Render a page with the full Rust `RenderOptions` surface
+     * (DPI, format, RGBA background, transparency, annotation toggle,
+     * JPEG quality). Returns the image bytes.
+     */
+    renderPageWithOptions(pageIndex, options = {}) {
+        this.ensureOpen();
+        const dpi = options.dpi ?? 150;
+        if (dpi <= 0)
+            throw new RangeError(`dpi must be > 0, got ${dpi}`);
+        const format = options.format === 'jpeg' ? 1 : 0;
+        const quality = options.jpegQuality ?? 85;
+        if (quality < 1 || quality > 100) {
+            throw new RangeError(`jpegQuality must be in 1..=100, got ${quality}`);
+        }
+        const bg = options.background ?? [1, 1, 1, 1];
+        const renderAnnotations = options.renderAnnotations === false ? 0 : 1;
+        const transparent = options.transparentBackground ? 1 : 0;
+        const imgHandle = native.renderPageWithOptions(this._handle, pageIndex, dpi, format, bg[0], bg[1], bg[2], bg[3], transparent, renderAnnotations, quality);
+        try {
+            const buf = native.pdfGetRenderedImageData(imgHandle);
+            return new Uint8Array(buf);
+        }
+        finally {
+            if (native.freeRenderedImage) {
+                native.freeRenderedImage(imgHandle);
+            }
+        }
+    }
+    /**
+     * Estimate render time (milliseconds) for a page at a given DPI.
+     * Thin wrapper around the existing `estimateRenderTime` N-API
+     * export — exposed in TS for the first time as part of gap L.
+     */
+    estimateRenderTime(pageIndex, dpi = 150) {
+        this.ensureOpen();
+        return native.estimateRenderTime(this._handle, pageIndex, dpi);
+    }
+    /**
+     * Render a page to fit inside a `width × height` pixel box, preserving
+     * aspect ratio. Picks the largest DPI such that both rendered
+     * dimensions are ≤ the target box, so the output may be smaller than
+     * `width × height` on one axis. Issue #448.
+     *
+     * @param pageIndex   zero-based page index
+     * @param width       target box width (pixels, must be > 0)
+     * @param height      target box height (pixels, must be > 0)
+     * @param format      `'png'` (default) or `'jpeg'`
+     */
+    renderPageFit(pageIndex, width, height, format = 'png') {
+        this.ensureOpen();
+        if (width <= 0 || height <= 0) {
+            throw new RangeError(`width and height must be > 0, got ${width}×${height}`);
+        }
+        const fmt = format === 'jpeg' ? 1 : 0;
+        const imgHandle = native.renderPageFit(this._handle, pageIndex, width, height, fmt);
+        try {
+            const buf = native.pdfGetRenderedImageData(imgHandle);
+            return new Uint8Array(buf);
+        }
+        finally {
+            if (native.freeRenderedImage) {
+                native.freeRenderedImage(imgHandle);
+            }
+        }
+    }
+    /** Lazy-initialises the per-instance Mutex (avoids a hard dep at load time). */
+    _getMutex() {
+        if (!this._muPromise) {
+            this._muPromise = import('async-mutex').then(({ Mutex }) => new Mutex());
+        }
+        return this._muPromise;
+    }
+    /**
+     * Async variant of {@link renderPageWithOptions} serialised through a
+     * per-instance mutex. Use when calling from `worker_threads` or `Promise.all`.
+     */
+    async renderPageWithOptionsAsync(pageIndex, options = {}) {
+        const mu = await this._getMutex();
+        return mu.runExclusive(() => this.renderPageWithOptions(pageIndex, options));
+    }
+    /**
+     * Async variant of {@link renderPageFit} serialised through a per-instance mutex.
+     */
+    async renderPageFitAsync(pageIndex, width, height, format = 'png') {
+        const mu = await this._getMutex();
+        return mu.runExclusive(() => this.renderPageFit(pageIndex, width, height, format));
+    }
+    /**
+     * Renders a page as raw premultiplied RGBA8888 pixels. No PNG/JPEG encoding
+     * overhead — useful for direct handoff to image-processing libraries.
+     * @param pageIndex Zero-based page index.
+     * @param dpi Resolution in dots per inch (default 150).
+     */
+    renderToPixmap(pageIndex, dpi = 150) {
+        this.ensureOpen();
+        if (dpi <= 0)
+            throw new RangeError(`dpi must be > 0, got ${dpi}`);
+        const { imgHandle, width, height } = native.renderPageRaw(this._handle, pageIndex, dpi);
+        try {
+            const buf = native.pdfGetRenderedImageData(imgHandle);
+            return { data: Buffer.from(buf), width, height };
+        }
+        finally {
+            if (native.freeRenderedImage)
+                native.freeRenderedImage(imgHandle);
+        }
+    }
+    /**
+     * Async variant of {@link renderToPixmap} serialised through a per-instance mutex.
+     */
+    async renderToPixmapAsync(pageIndex, dpi = 150) {
+        const mu = await this._getMutex();
+        return mu.runExclusive(() => this.renderToPixmap(pageIndex, dpi));
+    }
+    page(index) {
+        this.ensureOpen();
+        const count = this.pageCount();
+        const idx = index < 0 ? count + index : index;
+        if (idx < 0 || idx >= count)
+            throw new RangeError(`page index ${index} out of range`);
+        return new Page(this, idx);
+    }
+    [Symbol.iterator]() {
+        this.ensureOpen();
+        const count = this.pageCount();
+        let i = 0;
+        const doc = this;
+        return {
+            next() {
+                if (i >= count)
+                    return { value: undefined, done: true };
+                return { value: new Page(doc, i++), done: false };
+            },
+        };
+    }
+    /**
+     * Async iteration over the document's pages — issue #447. The body
+     * is identical to the sync iterator (page handles are constructed
+     * synchronously) but exposing this surface lets consumers `for await`
+     * uniformly with other async resources without an explicit
+     * `Promise.resolve(...)`.
+     */
+    [Symbol.asyncIterator]() {
+        this.ensureOpen();
+        const count = this.pageCount();
+        let i = 0;
+        const doc = this;
+        return {
+            async next() {
+                if (i >= count)
+                    return { value: undefined, done: true };
+                return { value: new Page(doc, i++), done: false };
+            },
+        };
+    }
+    /**
+     * Validate PDF/A conformance at a given level.
+     * @param level - "1a"|"1b"|"2a"|"2b"|"2u"|"3a"|"3b"|"3u" (default "2b")
+     */
+    validatePdfA(level = '2b') {
+        this.ensureOpen();
+        const levelMap = {
+            '1b': 0,
+            '1a': 1,
+            '2b': 2,
+            '2a': 3,
+            '2u': 4,
+            '3b': 5,
+            '3a': 6,
+            '3u': 7,
+        };
+        const levelInt = levelMap[level];
+        if (levelInt === undefined)
+            throw new RangeError(`Unknown PDF/A level: "${level}"`);
+        return native.validatePdfALevel(this._handle, levelInt);
+    }
+    /**
+     * Convert document to PDF/A conformance in-place.
+     * @param level - "1b"|"2b"|"2u"|"3b" etc. (default "2b")
+     * @returns true if the document is fully PDF/A-compliant after conversion (false if errors remain, e.g. fonts not embeddable without the rendering feature)
+     */
+    convertToPdfA(level = '2b') {
+        this.ensureOpen();
+        const levelMap = {
+            '1b': 0,
+            '1a': 1,
+            '2b': 2,
+            '2a': 3,
+            '2u': 4,
+            '3b': 5,
+            '3a': 6,
+            '3u': 7,
+        };
+        const levelInt = levelMap[level];
+        if (levelInt === undefined)
+            throw new RangeError(`Unknown PDF/A level: "${level}"`);
+        return native.convertToPdfA(this._handle, levelInt);
+    }
+    /**
+     * Return the current document bytes (including any in-place modifications
+     * made by convertToPdfA).
+     */
+    toBuffer() {
+        this.ensureOpen();
+        return native.documentGetSourceBytes(this._handle);
+    }
+    close() {
+        if (!this._closed && this._handle) {
+            native.closeDocument(this._handle);
+            this._closed = true;
+        }
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+}
+class Page {
+    constructor(doc, index) {
+        this._cache = new Map();
+        this._doc = doc;
+        this._index = index;
+    }
+    get index() {
+        return this._index;
+    }
+    get width() {
+        if (!this._cache.has('width'))
+            this._cache.set('width', this._doc.getPageWidth(this._index));
+        return this._cache.get('width');
+    }
+    get height() {
+        if (!this._cache.has('height'))
+            this._cache.set('height', this._doc.getPageHeight(this._index));
+        return this._cache.get('height');
+    }
+    get rotation() {
+        if (!this._cache.has('rotation'))
+            this._cache.set('rotation', this._doc.getPageRotation(this._index));
+        return this._cache.get('rotation');
+    }
+    text() {
+        return this._doc.extractText(this._index);
+    }
+    markdown() {
+        return this._doc.toMarkdown(this._index);
+    }
+    html() {
+        return this._doc.toHtml(this._index);
+    }
+    plainText() {
+        return this._doc.toPlainText(this._index);
+    }
+    words() {
+        return this._doc.extractWords(this._index);
+    }
+    lines() {
+        return this._doc.extractTextLines(this._index);
+    }
+    tables() {
+        return this._doc.extractTables(this._index);
+    }
+    images() {
+        return this._doc.getEmbeddedImages(this._index);
+    }
+    paths() {
+        return this._doc.extractPaths(this._index);
+    }
+    annotations() {
+        return this._doc.getPageAnnotations(this._index);
+    }
+    fonts() {
+        return this._doc.getEmbeddedFonts(this._index);
+    }
+    search(query, caseSensitive = false) {
+        return this._doc.searchPage(this._index, query, caseSensitive);
+    }
+    toString() {
+        return `Page(index=${this._index})`;
+    }
+}
+class PdfImpl {
+    constructor(handle) {
+        this._closed = false;
+        if (!handle)
+            throw new Error('Failed to create PDF');
+        this._handle = handle;
+    }
+    static fromMarkdown(markdown) {
+        return new PdfImpl(native.pdfFromMarkdown(markdown));
+    }
+    static fromHtml(html) {
+        return new PdfImpl(native.pdfFromHtml(html));
+    }
+    static fromText(text) {
+        return new PdfImpl(native.pdfFromText(text));
+    }
+    static fromImage(path) {
+        return new PdfImpl(native.pdfFromImage(path));
+    }
+    static fromImageBytes(data) {
+        return new PdfImpl(native.pdfFromImageBytes(data));
+    }
+    static fromHtmlCss(html, css, fontBytes) {
+        return new PdfImpl(native.pdfFromHtmlCss(html, css, fontBytes));
+    }
+    static fromHtmlCssWithFonts(html, css, families, fonts) {
+        if (families.length !== fonts.length) {
+            throw new Error(`fromHtmlCssWithFonts: families.length (${families.length}) must equal fonts.length (${fonts.length})`);
+        }
+        return new PdfImpl(native.pdfFromHtmlCssWithFonts(html, css, families, fonts));
+    }
+    ensureOpen() {
+        if (this._closed)
+            throw new Error('PDF handle is closed');
+    }
+    save(path) {
+        this.ensureOpen();
+        native.pdfSave(this._handle, path);
+    }
+    saveToBytes() {
+        this.ensureOpen();
+        return native.pdfSaveToBytes(this._handle);
+    }
+    pageCount() {
+        this.ensureOpen();
+        return native.pdfGetPageCount(this._handle);
+    }
+    close() {
+        if (!this._closed && this._handle) {
+            native.pdfFree(this._handle);
+            this._closed = true;
+        }
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+}
+// Generate a 1D barcode as a vector SVG string.
+// format: 0=Code128, 1=Code39, 2=EAN13, 3=EAN8, 4=UPCA, 5=ITF, 6=Code93, 7=Codabar.
+function generateBarcodeSvg(data, format = 0, sizePx = 300) {
+    const handle = native.generateBarcode(format, data);
+    try {
+        return native.barcodeGetSVG(handle, sizePx);
+    }
+    finally {
+        native.freeBarcode(handle);
+    }
+}
+// Generate a QR code as a vector SVG string.
+// errorCorrection: 0=Low, 1=Medium, 2=Quartile, 3=High.
+function generateQrCodeSvg(data, errorCorrection = 1, sizePx = 300) {
+    const handle = native.generateQRCode(data, errorCorrection);
+    try {
+        return native.barcodeGetSVG(handle, sizePx);
+    }
+    finally {
+        native.freeBarcode(handle);
+    }
+}
+// Export as ES module
+const getVersion = native.getVersion;
+const getPdfOxideVersion = native.getPdfOxideVersion;
+const getActiveCryptoProvider = native.getActiveCryptoProvider;
+const isFipsCryptoAvailable = native.isFipsCryptoAvailable;
+const useFipsCryptoProvider = native.useFipsCryptoProvider;
+const PdfDocument = PdfDocumentImpl;
+const Pdf = PdfImpl;
+const PdfError = PdfException;
+const PageSize = native.PageSize;
+const Rect = native.Rect;
+const Point = native.Point;
+const Color = native.Color;
+const ConversionOptions = native.ConversionOptions;
+const SearchOptions = native.SearchOptions;
+const SearchResult = native.SearchResult;
+const TextSearcher = native.TextSearcher;
+// RFC 3161 Timestamp + TSA Client — standalone, re-exported from
+// their own modules so downstream users get the full API surface.
+export { Timestamp, TimestampHashAlgorithm } from './timestamp.js';
+export { TsaClient } from './tsa-client.js';
+export { AccessibilityException, AccessibilityManager, 
+// v0.3.39 — DocumentBuilder tables (#393)
+Align, AnnotationBuilder, AnnotationManager, AnnotationProperties, BarcodeErrorCorrection, BarcodeFormat, BarcodeManager, 
+// Phase 2.5: Batch Processing API
+BatchManager, CacheManager, CertificateLoadFailed, Color, ComplianceException, ComplianceIssueType, ComplianceManager, ContentType, ConversionOptions, ConversionOptionsBuilder, createExtractionStream, createMetadataStream, createSearchStream, DigestAlgorithm, 
+// Write-side fluent API
+DocumentBuilder, 
+// Editor mutation API
+DocumentEditor, EditingManager, EmbeddedFont, EncryptionException, EnterpriseManager, 
+// Error utilities
+ErrorCategory, ErrorSeverity, ExtractionManager, ExtractionStream, FieldVisibility, FontProperties, FormFieldManager, FormFieldType, generateBarcodeSvg, generateQrCodeSvg, getActiveCryptoProvider, getPdfOxideVersion, 
+// Version info
+getVersion, HybridMLManager, ImageFormat, ImageProperties, InvalidStateException, IoException, IssueSeverity, isFipsCryptoAvailable, LayerManager, MetadataBuilder, MetadataManager, MetadataStream, mapFfiErrorCode, OCRDetectionMode, OCRLanguage, OCRManager, OcrException, 
+// Managers (Phase 4+, consolidated in Phase 9)
+OcrManager, OptimizationException, OptimizationManager, 
+// Managers (Phase 1-3: Core)
+OutlineManager, Page, PageBuilder, PageComplexity, 
+// Types
+PageSize, ParseException, Pdf, PdfALevel, 
+// Builders
+PdfBuilder, 
+// Main classes
+PdfDocument, 
+// Error types
+PdfError, PdfException, PdfUALevel, PdfXLevel, Point, Rect, RedactionException, RenderingException, RenderingManager, ResultAccessorsManager, SearchException, SearchManager, SearchOptions, SearchOptionsBuilder, SearchResult, SearchResultProperties, 
+// Phase 2.4: Stream API
+SearchStream, SecurityManager, SignatureAlgorithm, SignatureException, SignatureManager, SigningFailed, 
+// v0.3.39 — managed streaming-table adapter (#393)
+StreamingTable, 
+// Utilities
+TextSearcher, ThumbnailManager, ThumbnailSize, UnknownError, UnsupportedFeatureException, useFipsCryptoProvider, ValidationException, 
+// Worker Threads API
+WorkerPool, workerPool, wrapAsyncMethod, wrapError, wrapMethod, XfaFieldType, XfaFormType, XfaManager, };