aurochs 0.10.0 → 0.12.0

package/dist/@aurochs/pdf/src/domain/document/element-transform.d.ts

@@ -8,6 +8,24 @@ export declare function getElementRotationDeg(element: PdfElement): number;
  * Preserves scale and translation; adds the delta to the existing rotation.
  */
 export declare function rotateElement(element: PdfElement, angleDeltaRad: number): PdfElement;
+/**
+ * Scale a PDF element to fit new bounds.
+ *
+ * @param element - The element to scale (immutable — returns a new instance).
+ * @param oldBounds - The element's current bounding box in PDF coordinate space (bottom-left origin).
+ * @param newBounds - The desired bounding box in PDF coordinate space (bottom-left origin).
+ */
+export declare function scaleElement(element: PdfElement, oldBounds: {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}, newBounds: {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}): PdfElement;
 /**
  * Apply a position delta to a PDF element.
  *

package/dist/@aurochs/pdf/src/domain/document/index.d.ts

@@ -4,9 +4,9 @@
  * Exports types and operations for PDF document structure.
  */
 export type { PdfElement, PdfPage, PdfDocument, PdfEmbeddedFont, PdfFontToUnicode, PdfFontMetrics, PdfTable, PdfTableRow, PdfTableCell } from './types';
-export { PDF_UNITS, PDF_PAGE_SIZES, isPdfPath, isPdfText, isPdfImage, isPdfTable } from './types';
+export { PDF_UNITS, PDF_PAGE_SIZES, isPdfPath, isPdfText, isPdfTextBlock, isPdfImage, isPdfTable } from './types';
 export type { PdfElementId } from './element-id';
 export { createElementId, parseElementId } from './element-id';
-export { getElementRotationRad, getElementRotationDeg, rotateElement, moveElement } from './element-transform';
+export { getElementRotationRad, getElementRotationDeg, rotateElement, moveElement, scaleElement } from './element-transform';
 export { updateElementInDocument, deleteElements, addElementsToPage, addPage, deletePages, duplicatePages, reorderPages, updatePageSize, } from './document-mutation';
 export { createTableCell, insertRow, removeRow, insertColumn, removeColumn, setColumnWidth, setRowHeight, mergeCells, splitCell, type TableCellRange, } from './table-mutation';

package/dist/@aurochs/pdf/src/domain/document/types.d.ts

@@ -1,9 +1,9 @@
 import { PdfImage } from '../image';
 import { PdfPath } from '../path';
-import { PdfText } from '../text';
+import { PdfText, PdfTextBlock } from '../text';
 import { CIDOrdering } from '../font';
 import { PdfGraphicsState } from '../graphics-state/types';
-export type PdfElement = PdfPath | PdfText | PdfImage | PdfTable;
+export type PdfElement = PdfPath | PdfText | PdfTextBlock | PdfImage | PdfTable;
 /** Table cell in a PDF table. */
 export type PdfTableCell = {
     readonly text: string;
@@ -191,6 +191,8 @@ export declare const PDF_UNITS: {
 export declare function isPdfPath(element: PdfElement): element is PdfPath;
 /** Type guard for `PdfText` elements. */
 export declare function isPdfText(element: PdfElement): element is PdfText;
+/** Type guard for `PdfTextBlock` elements. */
+export declare function isPdfTextBlock(element: PdfElement): element is PdfTextBlock;
 /** Type guard for `PdfImage` elements. */
 export declare function isPdfImage(element: PdfElement): element is PdfImage;
 /** Type guard for `PdfTable` elements. */

package/dist/@aurochs/pdf/src/domain/font/cmap/cmap-parser.d.ts

@@ -57,6 +57,29 @@ export declare function parseBfChar(data: string, mapping: FontMapping): number;
  * Returns maximum source hex length found.
  */
 export declare function parseBfRange(data: string, mapping: FontMapping, options?: CMapParserOptions): number;
+/**
+ * Determine whether ToUnicode diagnostics indicate severe corruption.
+ *
+ * "Severe corruption" means the ToUnicode CMap is unreliable enough that
+ * callers should fall back to CID-based decoding or other alternatives.
+ *
+ * The check is: replacement-character ratio ≥ 50% **OR** private-use ratio
+ * ≥ 50% (when PUA is treated as a corruption signal).
+ *
+ * For **symbol fonts** (Wingdings, Symbol, ZapfDingbats, etc.), PUA mappings
+ * are the correct and expected behaviour — not a corruption signal.  Callers
+ * should pass `treatPrivateUseAsCorruption: false` for such fonts so that
+ * only the replacement-character ratio is evaluated.
+ *
+ * @param diagnostics  - Parse diagnostics from {@link parseToUnicodeCMap}.
+ * @param totalEntries - Total number of entries in the byte mapping.
+ * @param options.treatPrivateUseAsCorruption
+ *   When `true` (default), a high PUA ratio counts as corruption.
+ *   Set to `false` for symbol / dingbats fonts where PUA is legitimate.
+ */
+export declare function isToUnicodeSeverelyCorrupted(diagnostics: CMapParseDiagnostics, totalEntries: number, options?: {
+    readonly treatPrivateUseAsCorruption?: boolean;
+}): boolean;
 /**
  * Convert destination hex string to Unicode string.
  * Destination is interpreted as UTF-16BE code units.

package/dist/@aurochs/pdf/src/domain/font/font-name-map.d.ts

@@ -13,6 +13,15 @@
  * For embedded fonts, returns the font name as-is (after cleanup).
  * For PDF Standard 14 fonts, maps to system font equivalents.
  *
+ * **Usage guidance**: For rendering and writing, use `FontProvider.resolve()`
+ * instead of calling this function directly. `FontProvider.resolve()` handles
+ * embedded font matching, Standard 14 mapping, system fonts, and fallback
+ * in a unified way.
+ *
+ * Direct use of this function is appropriate only for pure font name
+ * normalization without font resolution (e.g., cross-format conversion
+ * where FontProvider context is not applicable).
+ *
  * IMPORTANT: Do NOT modify font names beyond removing PDF syntax artifacts.
  * Embedded fonts use their exact names for @font-face declarations.
  * Changing the name (e.g., hyphens to spaces) would break font matching.

package/dist/@aurochs/pdf/src/domain/font/font-provider.d.ts

@@ -0,0 +1,170 @@
+import { CIDOrdering } from './types';
+import { EmbeddedFontMetrics, FontFormat } from './embedded-font';
+import { PdfFontToUnicode } from '../document/types';
+/**
+ * Origin of a resolved font.
+ *
+ * - "embedded": font binary extracted from the PDF being edited
+ * - "standard14": one of the 14 fonts guaranteed by the PDF spec (no embedding required)
+ * - "system": font registered by the application from an external source
+ */
+export type FontSource = "embedded" | "standard14" | "system";
+/**
+ * A font resolved by the FontProvider.
+ *
+ * This is the single representation used by both the renderer (cssFontFamily)
+ * and the writer (pdfBaseFont, data, toUnicode, codeByteWidth).
+ */
+export type ResolvedFont = {
+    readonly source: FontSource;
+    /** CSS font-family value for SVG / HTML rendering. */
+    readonly cssFontFamily: string;
+    /** PDF /BaseFont name for writing. */
+    readonly pdfBaseFont: string;
+    /** Font binary format (undefined for standard14 fonts). */
+    readonly format?: FontFormat;
+    /** Raw font binary for embedding (undefined for standard14). */
+    readonly data?: Uint8Array;
+    /** Font metrics in 1/1000 em units. */
+    readonly metrics?: EmbeddedFontMetrics;
+    /** CID ordering for CJK fonts. */
+    readonly ordering?: CIDOrdering;
+    /** Bytes per character code: 1 for single-byte, 2 for CID fonts. */
+    readonly codeByteWidth: 1 | 2;
+    /** ToUnicode mapping for round-trip preservation and re-encoding. */
+    readonly toUnicode?: PdfFontToUnicode;
+    /** Whether the font is bold. */
+    readonly isBold: boolean;
+    /** Whether the font is italic. */
+    readonly isItalic: boolean;
+    /** MIME type for @font-face data URL. */
+    readonly mimeType?: string;
+};
+/**
+ * Strategy for resolving a fallback font when the primary font cannot
+ * encode certain characters.
+ *
+ * The FontProvider calls this when `splitTextByEncodability()` produces
+ * non-encodable runs. The strategy returns a ResolvedFont that can handle
+ * the fallback characters, or undefined if no fallback is available.
+ *
+ * This is DI-injectable: callers can provide a custom strategy when creating
+ * the FontProvider. The default strategy falls back to Helvetica (Standard 14).
+ *
+ * @see ISO 32000-1:2008 Section 9.4.3 — Multiple Tf operators within BT...ET
+ *   are used to switch fonts for different character runs.
+ */
+export type FontFallbackStrategy = (
+/** Characters that the primary font cannot encode. */
+unencodableText: string, 
+/** The primary font that failed to encode. */
+primaryFont: ResolvedFont, 
+/** The FontProvider for looking up alternative fonts. */
+provider: FontProvider) => ResolvedFont | undefined;
+/**
+ * FontProvider — the single authority for font resolution.
+ *
+ * Created once per document session. Both rendering and writing pipelines
+ * must resolve fonts exclusively through this interface.
+ */
+export type FontProvider = {
+    /**
+     * Resolve a font by its PDF resource name and/or BaseFont name.
+     *
+     * Always returns a result — for unknown fonts, returns a best-effort
+     * resolution using the normalized font name as CSS font-family.
+     * Use `isAvailable()` to check if a font is actually registered.
+     *
+     * @param fontName - PDF resource identifier (e.g. "F1")
+     * @param baseFont - Real font name from /BaseFont entry (e.g. "ABCDEF+Helvetica")
+     * @returns Resolved font (never undefined)
+     */
+    resolve(fontName: string, baseFont?: string): ResolvedFont;
+    /**
+     * Register embedded fonts extracted from the PDF.
+     * Accepts both EmbeddedFont (from parser) and PdfEmbeddedFont (from document).
+     * Typically called once after parsing.
+     */
+    registerEmbeddedFonts(fonts: readonly FontRegistrationInput[]): void;
+    /**
+     * Register a system/external font (e.g. from user file upload).
+     */
+    registerSystemFont(options: {
+        family: string;
+        data: Uint8Array;
+        format: FontFormat;
+        mimeType: string;
+    }): void;
+    /**
+     * Generate combined @font-face CSS for all registered embedded and system fonts.
+     * This is the single source of truth for font CSS — replaces direct use of
+     * generateFontFaceStyle().
+     */
+    getAllFontFaceCss(): string;
+    /**
+     * Check if a font family is available (embedded, standard14, or system).
+     */
+    isAvailable(fontFamily: string): boolean;
+    /**
+     * Resolve a fallback font for characters that the primary font cannot encode.
+     *
+     * Uses the injected FontFallbackStrategy. Returns undefined if no fallback
+     * is available — the caller must handle this (e.g. skip the characters or
+     * raise an error to the user).
+     *
+     * @param unencodableText - The characters that need a fallback font
+     * @param primaryFont - The font that could not encode these characters
+     */
+    resolveFallback(unencodableText: string, primaryFont: ResolvedFont): ResolvedFont | undefined;
+    /**
+     * Get all registered embedded fonts.
+     * Used by the writer to embed fonts in the output PDF.
+     */
+    getEmbeddedFonts(): readonly FontRegistrationInput[];
+};
+/**
+ * Common input type for font registration.
+ * Accepts both EmbeddedFont (from parser) and PdfEmbeddedFont (from document).
+ */
+export type FontRegistrationInput = {
+    readonly fontFamily: string;
+    readonly baseFontName?: string;
+    readonly format: FontFormat | "opentype" | "truetype" | "type1" | "cff";
+    readonly data: Uint8Array;
+    readonly mimeType: string;
+    readonly metrics?: EmbeddedFontMetrics;
+    readonly toUnicode?: {
+        readonly byteMapping: ReadonlyMap<string, string>;
+        readonly sourceCodeByteLengths: readonly number[];
+    };
+    readonly ordering?: CIDOrdering;
+    readonly codeByteWidth?: 1 | 2;
+};
+/**
+ * Options for creating a FontProvider.
+ */
+export type CreateFontProviderOptions = {
+    /** Initial embedded fonts to register. */
+    readonly embeddedFonts?: readonly FontRegistrationInput[];
+    /**
+     * Strategy for resolving fallback fonts when encoding fails.
+     * When omitted, defaults to `defaultFallbackStrategy` which uses
+     * Helvetica (Standard 14) for WinAnsi-encodable characters.
+     */
+    readonly fallbackStrategy?: FontFallbackStrategy;
+};
+/**
+ * Create a FontProvider instance.
+ *
+ * Optionally accepts embedded fonts from PDF parsing to register immediately.
+ */
+export declare function createFontProvider(options?: CreateFontProviderOptions): FontProvider;
+/**
+ * Create a FontProvider from a PdfDocument.
+ *
+ * This is the canonical way to obtain a FontProvider for rendering or writing.
+ * It automatically registers the document's embedded fonts.
+ */
+export declare function createFontProviderForDocument(document: {
+    readonly embeddedFonts?: readonly FontRegistrationInput[];
+}): FontProvider;

package/dist/@aurochs/pdf/src/domain/font/font-style.d.ts

@@ -1,8 +1,15 @@
 /**
- * @file Font style detection
+ * @file Font style and classification detection
  *
- * Utilities for detecting font styles from PDF font names.
+ * Utilities for detecting font styles and classification from PDF font names.
  * Based on common PDF font naming conventions.
+ *
+ * Note on "symbol font" vs. PDF Symbolic flag (FontDescriptor Flags bit 3):
+ * The Symbolic flag means "contains glyphs outside the Adobe Standard Latin
+ * character set" — CJK fonts, Cyrillic fonts, and many embedded fonts also
+ * have this flag set. It does NOT reliably indicate a symbol/dingbats font.
+ * Therefore, symbol font detection here uses font-name heuristics rather
+ * than the Symbolic flag.
  */
 /**
  * Normalize PDF font name by removing subset prefix
@@ -29,3 +36,14 @@ export declare function isBoldFont(fontName: string): boolean;
  * - "-I" suffix
  */
 export declare function isItalicFont(fontName: string): boolean;
+/**
+ * Detect whether a PDF BaseFont name refers to a symbol / dingbats font.
+ *
+ * Symbol fonts legitimately use Private Use Area code points in their
+ * ToUnicode CMap. Callers should skip PUA-based corruption heuristics
+ * for these fonts.
+ *
+ * @param baseFont - Raw BaseFont value from the PDF font dictionary
+ *                   (e.g. "/CPNHAK+Wingdings-Regular", "Symbol")
+ */
+export declare function isSymbolFont(baseFont: string | undefined): boolean;

package/dist/@aurochs/pdf/src/domain/font/index.d.ts

@@ -5,10 +5,11 @@
  */
 export type { FontMapping, FontMetrics, FontInfo, FontMappings, CIDOrdering, } from './types';
 export { DEFAULT_FONT_METRICS } from './defaults';
-export { normalizeFontName, isBoldFont, isItalicFont } from './font-style';
+export { normalizeFontName, isBoldFont, isItalicFont, isSymbolFont } from './font-style';
+export { isPrivateUseCodePoint, containsPrivateUseCharacter } from './unicode-classification';
 export { normalizeFontFamily } from './font-name-map';
-export type { CMapParseResult, CMapParserOptions } from './cmap/cmap-parser';
-export { parseToUnicodeCMap, parseBfChar, parseBfRange, hexToString, } from './cmap/cmap-parser';
+export type { CMapParseResult, CMapParseDiagnostics, CMapParserOptions } from './cmap/cmap-parser';
+export { parseToUnicodeCMap, parseBfChar, parseBfRange, hexToString, isToUnicodeSeverelyCorrupted, } from './cmap/cmap-parser';
 export { decodeText, decodeTextWithFontInfo } from './decoding/text-decoder';
 export type { CIDFallbackMapping } from './cid/cid-ordering';
 export { getCIDFallbackMapping, detectCIDOrdering, decodeCIDFallback, } from './cid/cid-ordering';
@@ -20,3 +21,7 @@ export { hasCmapTable, injectCmapTable, repairFontForWeb } from './font-repair';
 export type { TableEntry, TrueTypeFontMetrics } from './truetype-parser';
 export { parseTrueTypeTableDirectory, hasTable, getTableTags, extractTrueTypeMetrics, normalizeMetricsTo1000, } from './truetype-parser';
 export { fontToDataUrl, generateFontFaceCss, generateFontFaceStyle, } from './font-css-generator';
+export type { FontSource, ResolvedFont, FontProvider, FontRegistrationInput, FontFallbackStrategy, CreateFontProviderOptions, } from './font-provider';
+export { createFontProvider, createFontProviderForDocument } from './font-provider';
+export type { TextEncodeResult, TextRun } from './text-encoder';
+export { encodeTextForFont, buildReverseToUnicodeMap, hexStringToUint8Array, splitTextByEncodability, } from './text-encoder';

package/dist/@aurochs/pdf/src/domain/font/text-encoder.d.ts

@@ -0,0 +1,61 @@
+import { ResolvedFont } from './font-provider';
+/**
+ * Build a reverse map from Unicode strings to source hex byte sequences.
+ *
+ * The ToUnicode CMap maps source bytes → Unicode. This inverts that:
+ * Unicode → source hex bytes.
+ *
+ * When multiple source byte sequences map to the same Unicode string,
+ * the first encountered mapping wins (consistent with PDF spec behavior
+ * where the first mapping in the CMap takes precedence).
+ *
+ * @param byteMapping - Forward mapping: hex bytes → Unicode string
+ * @returns Reverse mapping: Unicode string → hex bytes (uppercase)
+ */
+export declare function buildReverseToUnicodeMap(byteMapping: ReadonlyMap<string, string>): Map<string, string>;
+export type TextEncodeResult = {
+    /** Encoded byte sequence for the PDF content stream. */
+    readonly rawBytes: Uint8Array;
+    /** Bytes per character code in the encoded output. */
+    readonly codeByteWidth: 1 | 2;
+};
+/**
+ * Encode Unicode text to PDF byte sequences for a given resolved font.
+ *
+ * For CID fonts: uses the reverse ToUnicode mapping.
+ * For single-byte fonts: uses WinAnsiEncoding.
+ * For standard14 fonts: uses WinAnsiEncoding.
+ *
+ * @returns Encoded result, or null if any character cannot be encoded.
+ */
+export declare function encodeTextForFont(text: string, font: ResolvedFont): TextEncodeResult | null;
+/**
+ * A contiguous run of text that can be encoded with a single font.
+ *
+ * When the primary font cannot encode certain characters, the text is split
+ * into runs — some using the primary font, others requiring a fallback.
+ */
+export type TextRun = {
+    /** The text content of this run. */
+    readonly text: string;
+    /** Whether this run can be encoded by the primary font. */
+    readonly encodable: boolean;
+};
+/**
+ * Split text into runs based on whether each character is encodable
+ * by the given font.
+ *
+ * Adjacent characters with the same encodability are merged into a single run.
+ * This is the foundation for font fallback: encodable runs use the primary font,
+ * non-encodable runs use a fallback font.
+ *
+ * @param text - Unicode text to split
+ * @param font - The primary font to test encodability against
+ * @returns Array of TextRun, preserving the original character order
+ */
+export declare function splitTextByEncodability(text: string, font: ResolvedFont): readonly TextRun[];
+/**
+ * Convert a hex string (e.g. "8140AB") to Uint8Array.
+ * Each pair of hex digits becomes one byte.
+ */
+export declare function hexStringToUint8Array(hex: string): Uint8Array;

package/dist/@aurochs/pdf/src/domain/font/unicode-classification.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @file Unicode character classification utilities for PDF font handling.
+ *
+ * Provides predicates for Unicode character categories that are relevant
+ * to PDF text decoding and ToUnicode CMap diagnostics.
+ */
+/**
+ * Test whether a code point falls in a Unicode Private Use Area.
+ *
+ * Unicode defines three PUA blocks (Unicode 15.1, Section 23.5):
+ *  - BMP PUA:          U+E000 – U+F8FF       (6,400 code points)
+ *  - Supplementary PUA-A: U+F0000 – U+FFFFD  (65,534 code points)
+ *  - Supplementary PUA-B: U+100000 – U+10FFFD (65,534 code points)
+ *
+ * PUA code points are used by symbol/dingbats fonts (Wingdings, Symbol,
+ * ZapfDingbats) to map glyphs that have no standard Unicode assignment.
+ * Their presence in a ToUnicode CMap is normal for such fonts.
+ */
+export declare function isPrivateUseCodePoint(codePoint: number): boolean;
+/**
+ * Test whether a string contains any Unicode Private Use Area characters.
+ *
+ * Used by CMap diagnostics to count PUA mappings, and by the text decoder
+ * to decide whether a decoded character should be treated as "missing"
+ * when the ToUnicode CMap is suspected of corruption.
+ */
+export declare function containsPrivateUseCharacter(text: string): boolean;

package/dist/@aurochs/pdf/src/domain/graphics-state/defaults.d.ts

@@ -1,5 +1,22 @@
 import { PdfColor } from '../color';
 import { PdfGraphicsState } from './types';
+/**
+ * Resolve Pattern color space references in a graphics state to device colors.
+ *
+ * When a fill or stroke uses a Pattern color space, the `fillColor`/`strokeColor`
+ * fields contain `{ colorSpace: "Pattern", components: [] }` which carries no
+ * usable color information. The actual base color (for PaintType 2 uncolored
+ * tiling patterns) is stored in `fillPatternColor`/`strokePatternColor`.
+ *
+ * This function produces a graphics state where `fillColor`/`strokeColor` are
+ * always device-space colors that renderers and converters can use directly
+ * without additional dispatch.
+ *
+ * Pattern fills are normally rasterized to PdfImage at parse time. This
+ * resolution is for the residual case where a pattern path was not rasterized
+ * (e.g. rasterization failed or the source PDF uses a pattern only for color).
+ */
+export declare function resolvePatternColors(gs: PdfGraphicsState): PdfGraphicsState;
 export declare const DEFAULT_FILL_COLOR: PdfColor;
 export declare const DEFAULT_STROKE_COLOR: PdfColor;
 /**

package/dist/@aurochs/pdf/src/domain/graphics-state/index.d.ts

@@ -5,6 +5,6 @@
  * Color types and utilities are in domain/color.
  */
 export type { PdfLineJoin, PdfLineCap, PdfTextRenderingMode, PdfSoftMask, PdfGraphicsState, } from './types';
-export { DEFAULT_FILL_COLOR, DEFAULT_STROKE_COLOR, createDefaultGraphicsState } from './defaults';
+export { DEFAULT_FILL_COLOR, DEFAULT_STROKE_COLOR, createDefaultGraphicsState, resolvePatternColors } from './defaults';
 export type { GraphicsStateStack } from './stack';
 export { createGraphicsStateStack } from './stack';

package/dist/@aurochs/pdf/src/domain/index.d.ts

@@ -10,16 +10,17 @@ export { DEFAULT_FONT_METRICS, normalizeFontName, isBoldFont, isItalicFont, norm
 export type { PdfPoint, PdfBBox, PdfMatrix, MatrixDecomposition } from './coordinate';
 export { IDENTITY_MATRIX, multiplyMatrices, transformPoint, invertMatrix, translationMatrix, scalingMatrix, rotationMatrix, isIdentityMatrix, isSimpleTransform, getMatrixScale, getMatrixRotation, decomposeMatrix, hasShear, } from './coordinate';
 export type { PdfLineJoin, PdfLineCap, PdfTextRenderingMode, PdfSoftMask, PdfGraphicsState, GraphicsStateStack, } from './graphics-state';
-export { DEFAULT_FILL_COLOR, DEFAULT_STROKE_COLOR, createDefaultGraphicsState, createGraphicsStateStack, } from './graphics-state';
+export { DEFAULT_FILL_COLOR, DEFAULT_STROKE_COLOR, createDefaultGraphicsState, createGraphicsStateStack, resolvePatternColors, } from './graphics-state';
 export type { PdfMoveTo, PdfLineTo, PdfCurveTo, PdfCurveToV, PdfCurveToY, PdfRect, PdfClosePath, PdfPathOp, PdfPaintOp, PdfPath, } from './path';
 export { getPathBounds } from './path';
-export type { PdfText, PdfTextFontMetrics } from './text';
+export type { PdfText, PdfTextBlock, PdfTextBlockParagraph, PdfTextFontMetrics, PdfTextEditState } from './text';
+export { withTextContent, withFontFamily, withFontSize, withCharSpacing, } from './text';
 export type { PdfImage } from './image';
 export type { PdfElement, PdfPage, PdfDocument, PdfEmbeddedFont, PdfTable, PdfTableRow, PdfTableCell } from './document';
-export { PDF_UNITS, PDF_PAGE_SIZES, isPdfPath, isPdfText, isPdfImage, isPdfTable } from './document';
+export { PDF_UNITS, PDF_PAGE_SIZES, isPdfPath, isPdfText, isPdfTextBlock, isPdfImage, isPdfTable } from './document';
 export type { PdfElementId } from './document';
 export { createElementId, parseElementId } from './document';
-export { getElementRotationRad, getElementRotationDeg, rotateElement, moveElement } from './document';
+export { getElementRotationRad, getElementRotationDeg, rotateElement, moveElement, scaleElement } from './document';
 export { updateElementInDocument, deleteElements, addElementsToPage, addPage, deletePages, duplicatePages, reorderPages, updatePageSize, } from './document';
 export { createTableCell, insertRow, removeRow, insertColumn, removeColumn, setColumnWidth, setRowHeight, mergeCells, splitCell, type TableCellRange, } from './document';
 export type { PdfTokenType, PdfToken } from './content-stream';

package/dist/@aurochs/pdf/src/domain/text/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file PDF text domain
+ *
+ * Exports types for PDF text handling.
+ */
+export type { PdfText, PdfTextBlock, PdfTextBlockParagraph, PdfTextFontMetrics, PdfTextEditState } from './types';
+export { withTextContent, withFontFamily, withFontSize, withCharSpacing, } from './operations';

package/dist/@aurochs/pdf/src/domain/text/operations.d.ts

@@ -0,0 +1,29 @@
+import { PdfText } from './types';
+/**
+ * Update the text content of a PdfText element.
+ *
+ * When the text actually changes:
+ *   - rawBytes and rawText are invalidated (set to undefined)
+ *   - editState.textChanged is set to true
+ *
+ * When the text is identical to the current value, returns the element unchanged.
+ */
+export declare function withTextContent(element: PdfText, newText: string): PdfText;
+/**
+ * Change the font family of a PdfText element.
+ *
+ * Updates baseFont to the new family and invalidates rawBytes/rawText
+ * since the encoding may differ. Sets editState.fontChanged and records
+ * the resolved font family for the writer to use during re-encoding.
+ *
+ * When the font family is identical to the current value, returns unchanged.
+ */
+export declare function withFontFamily(element: PdfText, fontFamily: string): PdfText;
+/**
+ * Update the font size of a PdfText element.
+ */
+export declare function withFontSize(element: PdfText, fontSize: number): PdfText;
+/**
+ * Update the character spacing (letter-spacing) of a PdfText element.
+ */
+export declare function withCharSpacing(element: PdfText, charSpacing: number | undefined): PdfText;

package/dist/@aurochs/pdf/src/image/pixel-converter.d.ts

@@ -7,9 +7,16 @@ import { PdfColorSpace } from '../domain';
  * - 1/2/4-bit: unpacked and scaled to 8-bit (0-255)
  * - 16-bit: downsampled to 8-bit by taking the high byte
  */
-export declare function convertToRgba(data: Uint8Array, width: number, height: number, colorSpace: PdfColorSpace, bitsPerComponent: number, options?: Readonly<{
+export type ConvertToRgbaParams = {
+    readonly data: Uint8Array;
+    readonly width: number;
+    readonly height: number;
+    readonly colorSpace: PdfColorSpace;
+    readonly bitsPerComponent: number;
     readonly decode?: readonly number[];
-}>): Uint8ClampedArray;
+};
+/** Convert raw pixel data from any supported color space to RGBA. */
+export declare function convertToRgba(p: ConvertToRgbaParams): Uint8ClampedArray;
 /**
  * DeviceGray → RGBA
  * PDF Reference 8.6.4.2: 1 component (0=black, 1=white)

package/dist/@aurochs/pdf/src/index.d.ts

@@ -8,13 +8,14 @@ export { IDENTITY_MATRIX, multiplyMatrices, transformPoint, invertMatrix, transl
 export type { PdfColorSpace, PdfAlternateColorSpace, PdfColor, PdfLineJoin, PdfLineCap, PdfTextRenderingMode, PdfGraphicsState, GraphicsStateStack, } from './domain';
 export { DEFAULT_FILL_COLOR, DEFAULT_STROKE_COLOR, createDefaultGraphicsState, createGraphicsStateStack, } from './domain';
 export type { PdfMoveTo, PdfLineTo, PdfCurveTo, PdfCurveToV, PdfCurveToY, PdfRect, PdfClosePath, PdfPathOp, PdfPaintOp, PdfPath, } from './domain';
-export type { PdfText } from './domain';
+export type { PdfText, PdfTextEditState } from './domain';
+export { withTextContent, withFontFamily, withFontSize, withCharSpacing, } from './domain';
 export type { PdfImage } from './domain';
 export type { PdfElement, PdfPage, PdfDocument, PdfTable, PdfTableRow, PdfTableCell } from './domain';
 export { isPdfPath, isPdfText, isPdfImage, isPdfTable } from './domain';
 export type { PdfElementId } from './domain';
 export { createElementId, parseElementId } from './domain';
-export { getElementRotationRad, getElementRotationDeg, rotateElement, moveElement } from './domain';
+export { getElementRotationRad, getElementRotationDeg, rotateElement, moveElement, scaleElement } from './domain';
 export { updateElementInDocument, deleteElements, addElementsToPage, addPage, deletePages, duplicatePages, reorderPages, updatePageSize, } from './domain';
 export { getPathBounds } from './domain';
 export { createTableCell, insertRow, removeRow, insertColumn, removeColumn, setColumnWidth, setRowHeight, mergeCells, splitCell, type TableCellRange, } from './domain';

package/dist/@aurochs/pdf/src/native/document/document.d.ts

@@ -3,12 +3,15 @@ export type NativePdfEncryptionMode = {
     readonly mode: "reject";
 } | {
     readonly mode: "ignore";
+} | {
+    readonly mode: "auto";
 } | {
     readonly mode: "password";
     readonly password: string;
 };
 export type NativePdfLoadOptions = Readonly<{
-    readonly encryption: NativePdfEncryptionMode;
+    /** How to handle encrypted PDFs. Defaults to `"auto"` (try empty password). */
+    readonly encryption?: NativePdfEncryptionMode;
 }>;
 export type NativePdfMetadata = Readonly<{
     readonly title?: string;

package/dist/@aurochs/pdf/src/parser/color/color-space.native.d.ts

@@ -1,13 +1,46 @@
 import { NativePdfPage, PdfDict } from '../../native';
 import { ParsedIccProfile } from './icc-profile.native';
+import { PdfFunction } from '../function/types';
+type DeviceColorSpace = "DeviceGray" | "DeviceRGB" | "DeviceCMYK";
 export type ParsedNamedColorSpace = Readonly<{
     kind: "device";
-    colorSpace: "DeviceGray" | "DeviceRGB" | "DeviceCMYK";
+    colorSpace: DeviceColorSpace;
 }> | Readonly<{
     kind: "iccBased";
     n: number;
-    alternate: "DeviceGray" | "DeviceRGB" | "DeviceCMYK";
+    alternate: DeviceColorSpace;
     profile: ParsedIccProfile | null;
+}> | Readonly<{
+    kind: "separation";
+    colorantName: string;
+    alternate: DeviceColorSpace;
+    alternateComponents: number;
+    tintTransform: PdfFunction | null;
+}> | Readonly<{
+    kind: "deviceN";
+    colorantNames: readonly string[];
+    alternate: DeviceColorSpace;
+    alternateComponents: number;
+    tintTransform: PdfFunction | null;
+}> | Readonly<{
+    kind: "indexed";
+    base: DeviceColorSpace;
+    hival: number;
+    lookup: Uint8Array;
+}> | Readonly<{
+    kind: "calGray";
+    whitePoint: readonly [number, number, number];
+    gamma: number;
+}> | Readonly<{
+    kind: "calRgb";
+    whitePoint: readonly [number, number, number];
+    gamma: readonly [number, number, number];
+    matrix: readonly number[];
+}> | Readonly<{
+    kind: "lab";
+    whitePoint: readonly [number, number, number];
+    range: readonly [number, number, number, number];
 }>;
 /** Extract named color spaces from PDF page resources. */
 export declare function extractColorSpacesFromResourcesNative(page: NativePdfPage, resources: PdfDict | null): ReadonlyMap<string, ParsedNamedColorSpace>;
+export {};

package/dist/@aurochs/pdf/src/parser/core/pdf-load-error.d.ts

@@ -6,6 +6,8 @@ export type PdfLoadEncryption = {
     readonly mode: "reject";
 } | {
     readonly mode: "ignore";
+} | {
+    readonly mode: "auto";
 } | {
     readonly mode: "password";
     readonly password: string;
@@ -16,8 +18,8 @@ export type PdfLoadOptions = Readonly<{
      * Used to keep call sites explicit and to preserve flexibility for future behaviors.
      */
     readonly purpose: PdfLoadPurpose;
-    /** How to handle encrypted PDFs. */
-    readonly encryption: PdfLoadEncryption;
+    /** How to handle encrypted PDFs. Defaults to `"auto"` (try empty password). */
+    readonly encryption?: PdfLoadEncryption;
     /**
      * Historically forwarded to pdf-lib. Kept for API stability.
      * Native loader ignores this field.