Add TIFF output device with multi-page and CMYK support

New output device that renders PostScript to TIFF via Cairo + Pillow.
Features single-page (one .tif per page) and multi-page (--multipage-tiff)
modes, with optional RGB-to-CMYK conversion (--cmyk) using ICC profiles.

Also removes accidentally committed code-quality-audit file and bumps
version to 0.9.2.

Author: AndyCappDev

README.md

@@ -3,7 +3,7 @@
 <p align="center"><strong>A modern, open-source PostScript interpreter written in Python.</strong></p>
 
 <p align="center">
-  <a href="https://github.com/AndyCappDev/postforge/releases"><img src="https://img.shields.io/badge/Version-0.9.1-green.svg" alt="Version 0.9.0"></a>
+  <a href="https://github.com/AndyCappDev/postforge/releases"><img src="https://img.shields.io/badge/Version-0.9.2-green.svg" alt="Version 0.9.0"></a>
   <a href="LICENSE.txt"><img src="https://img.shields.io/badge/License-AGPL--3.0-blue.svg" alt="License: AGPL-3.0"></a>
   <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/Python-3.13%2B-blue.svg" alt="Python 3.13+"></a>
 </p>
@@ -13,7 +13,7 @@
 PostForge is a complete PostScript interpreter that faithfully implements the
 PostScript Level 2 specification while adding selected Level 3 enhancements.
 It reads PostScript files and produces PNG images, PDF documents, SVG files,
-or renders them in an interactive Qt display window.
+TIFF images, or renders them in an interactive Qt display window.
 
 PostForge is designed as an open-source alternative to GhostScript for use
 cases where Python integration, transparency, and debuggability matter more
@@ -52,9 +52,10 @@ See the [sample gallery](docs/samples.md) for larger rendered examples.
   exploration, debugging, and experimentation
 - **Cython-Accelerated Execution** — Optional Cython-compiled execution loop
   providing 15–40% speedup depending on workload
-- **Multiple Output Formats** — PNG, PDF, and SVG output via Cairo graphics
-  backend, plus an interactive Qt display window with a PostScript command
-  prompt; extensible architecture makes it straightforward to add new devices
+- **Multiple Output Formats** — PNG, PDF, SVG, and TIFF output via Cairo
+  graphics backend, plus an interactive Qt display window with a PostScript
+  command prompt; TIFF supports multi-page and CMYK output for prepress
+  workflows; extensible architecture makes it straightforward to add new devices
 - **PDF Font Embedding** — Type 1 font reconstruction and subsetting,
   TrueType/CID font extraction with CIDToGIDMap and ToUnicode support
 - **EPS Support** — Automatic page cropping to EPS content dimensions with
@@ -154,6 +155,15 @@ pf -d pdf samples/tiger.ps
 # Save as SVG → pf_output/tiger-0001.svg
 pf -d svg samples/tiger.ps
 
+# Save as TIFF → pf_output/tiger-0001.tif
+pf -d tiff samples/tiger.ps
+
+# Multi-page TIFF → pf_output/document.tif
+pf -d tiff --multipage-tiff document.ps
+
+# CMYK TIFF for prepress → pf_output/tiger-0001.tif
+pf -d tiff --cmyk samples/tiger.ps
+
 # Render an EPS file (auto-crops to content)
 pf -d png samples/fancy.eps
 
@@ -164,7 +174,7 @@ pf -o result.png --output-dir renders samples/tiger.ps
 pf -d pdf --pages 1-3,7 document.ps
 
 # SVG with text rendered as path outlines instead of <text> elements
-pf --text-as-paths -d svg samples/tiger.ps
+pf --text-as-paths -d svg samples/test1.ps
 
 # Pipe PostScript from stdin
 cat document.ps | pf -d png -
@@ -242,7 +252,7 @@ most rendering tasks.*
 - [Architecture Overview](docs/developer/architecture-overview.md) — How PostForge works internally
 - [Implementing Operators](docs/developer/operator-implementation.md) — Adding new PostScript operators
 - [Testing Guide](docs/developer/testing-guide.md) — Writing and running PostScript-based tests
-- [Visual Regression Testing](docs/developer/visual-regression-testing.md) — PNG, PDF, and SVG visual comparison
+- [Visual Regression Testing](docs/developer/visual-regression-testing.md) — PNG, PDF, SVG, and TIFF visual comparison
 - [Adding Output Devices](docs/developer/adding-output-devices.md) — Creating new output backends
 - [Profiling](docs/developer/profiling.md) — Performance and memory analysis
 

docs/developer/adding-output-devices.md

@@ -5,13 +5,14 @@ device takes the PostScript display list — the accumulated graphics operations
 from a page — and renders it to some output format (image file, PDF, screen
 display, etc.).
 
-PostForge ships with four devices:
+PostForge ships with five devices:
 
 | Device | Output | Complexity |
 |--------|--------|------------|
 | **PNG** | One PNG file per page | Simple — stateless, single-page |
 | **PDF** | Single multi-page PDF | Complex — persistent state, font embedding |
 | **SVG** | One SVG file per page | Moderate — post-processing for text elements |
+| **TIFF** | One TIFF per page or multi-page | Moderate — optional multi-page accumulation, CMYK conversion |
 | **Qt** | Interactive window | Complex — live rendering, zoom/pan |
 
 The PNG device is the simplest and is used as the primary example throughout
@@ -542,6 +543,17 @@ for font matching. Each page is a separate `.svg` file.
 Key features: text as selectable/searchable elements, CSS font-family
 fallbacks, Cairo-based vector rendering.
 
+### TIFF (`postforge/devices/tiff/`)
+
+Renders to a Cairo ImageSurface (like PNG), then converts to a PIL Image for
+TIFF encoding via Pillow. Supports single-page (one `.tif` per page) and
+multi-page (all pages in one `.tif`) modes. Optional CMYK output via ICC
+profile conversion (sRGB→CMYK using the system CMYK profile). ~200 lines of
+code.
+
+Key features: multi-page accumulation with `finalize()`, CMYK conversion via
+ImageCms, ICC profile embedding, LZW compression, DPI metadata.
+
 ### Qt (`postforge/devices/qt/`)
 
 The default preview device — when you run `./postforge.sh samples/tiger.ps`

docs/developer/architecture-overview.md

@@ -12,8 +12,8 @@ Every PostScript program flows through the same pipeline:
 ```
                                                   ┌──────────────┐
 PostScript Source ──► Tokenizer ──► Execution ──► │ Display List │──► Output Device
-  (.ps file,          extracts       Engine       │  (per page)  │    (PNG, PDF,
-   string, or         tokens from    (exec_exec)  └──────────────┘     SVG, Qt)
+  (.ps file,          extracts       Engine       │  (per page)  │    (PNG, PDF, SVG,
+   string, or         tokens from    (exec_exec)  └──────────────┘     TIFF, Qt)
    interactive)       byte streams
 ```
 
@@ -480,30 +480,27 @@ without involving Cairo at all.
 ### Device Architecture
 
 ```
-                         ┌────────────────────────────────┐
-                         │  Shared Cairo Rendering        │
-                         │  (devices/common/)             │
-                         │                                │
-                         │  cairo_renderer.py  - dispatch │
-                         │  cairo_images.py    - images   │
-                         │  cairo_patterns.py  - patterns │
-                         │  cairo_shading.py   - shading  │
-                         └──────┬───────┬───────┬─────────┘
-                                │       │       │
-                    ┌───────────┘       │       └───────────┐
-                    ▼                   ▼                   ▼
-          ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐
-          │  PNG     │   │  PDF     │   │  SVG     │   │  Qt      │
-          │  device  │   │  device  │   │  device  │   │  device  │
-          └──────────┘   └──────────┘   └──────────┘   └──────────┘
-                                        │
-                                ┌───────┴─────────┐
-                                │ Font embedding  │
-                                │ (font_embedder, │
-                                │  cid_font_      │
-                                │  embedder,      │
-                                │  pdf_injector)  │
-                                └─────────────────┘
+                    ┌────────────────────────────────────────────────────────────────┐
+                    │                   Shared Cairo Rendering                       │
+                    │                    (devices/common/)                           │
+                    │                                                                │
+                    │  cairo_renderer.py - dispatch     cairo_patterns.py - patterns │
+                    │  cairo_images.py   - images       cairo_shading.py  - shading  │
+                    └─────┬────────────┬────────────┬─────────────┬────────────┬─────┘
+                          │            │            │             │            │
+                          ▼            ▼            ▼             ▼            ▼
+                     ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
+                     │   PNG    │ │   PDF    │ │   SVG    │ │   TIFF   │ │    Qt    │
+                     │  device  │ │  device  │ │  device  │ │  device  │ │  device  │
+                     └──────────┘ └────┬─────┘ └──────────┘ └──────────┘ └──────────┘
+                                       │
+                              ┌────────┴────────┐
+                              │ Font embedding  │
+                              │ (font_embedder, │
+                              │  cid_font_      │
+                              │  embedder,      │
+                              │  pdf_injector)  │
+                              └─────────────────┘
 ```
 
 **PNG** (`postforge/devices/png/png.py`) — Creates a Cairo ImageSurface, calls
@@ -522,14 +519,21 @@ elements with CSS font-family fallback chains. This can be overridden with
 `--text-as-paths` to render text as path outlines instead. Each page produces
 a separate `.svg` file.
 
+**TIFF** (`postforge/devices/tiff/tiff.py`) — Renders to a Cairo ImageSurface
+(like PNG), then converts to a PIL Image for TIFF encoding via Pillow. Supports
+single-page (one `.tif` per page) and multi-page (all pages in one `.tif` via
+`--multipage-tiff`). Optional CMYK output via ICC profile conversion
+(`--cmyk`), with the ICC profile embedded in the TIFF for downstream color
+management.
+
 **Qt** (`postforge/devices/qt/qt.py`) — Interactive display window. Renders to
 a Cairo ImageSurface and displays it in a Qt widget. In interactive mode, the
 display updates live as display list elements are added; in batch mode, it
 updates on `showpage`.
 
 ### PostScript-Side Device Setup
 
-The PostScript configuration files (e.g., `png.ps`, `pdf.ps`, `svg.ps`) define the page
+The PostScript configuration files (e.g., `png.ps`, `pdf.ps`, `svg.ps`, `tiff.ps`) define the page
 device dictionary — page size, resolution, margins, color space, and
 Install/BeginPage/EndPage procedures. When a device is selected, this
 dictionary is loaded and merged into the graphics state's `page_device`.
@@ -651,6 +655,7 @@ A quick reference to the directory structure:
 | `postforge/devices/common/` | Shared Cairo rendering backend |
 | `postforge/devices/png/` | PNG output device |
 | `postforge/devices/pdf/` | PDF output device + font embedding |
+| `postforge/devices/tiff/` | TIFF output device (multi-page, CMYK) |
 | `postforge/devices/qt/` | Interactive Qt display |
 | `postforge/utils/` | Memory analysis, profiling |
 | `postforge/resources/Init/` | PostScript initialization scripts |

docs/developer/code-quality-audit-2026-02-20.md

@@ -35,7 +35,7 @@ python -m postforge samples/tiger.ps  # After pip install -e .
 |-----------|---------|
 | `postforge/core/` | PostScript execution infrastructure (types, tokenizer, error handling, color spaces) |
 | `postforge/operators/` | PostScript language operators organized by functional area |
-| `postforge/devices/` | Output devices (PNG, PDF, SVG, Qt) |
+| `postforge/devices/` | Output devices (PNG, PDF, SVG, TIFF, Qt) |
 | `postforge/utils/` | System utilities (memory analysis, profiling) |
 | `postforge/resources/` | PostScript resource files (fonts, encodings, initialization scripts, device configs) |
 | `unit_tests/` | PostScript-based test suite |

docs/developer/contributing.md

@@ -6,7 +6,8 @@ This catches unintended visual changes introduced by code modifications.
 
 Three output devices are tested: **PNG** (direct pixel output), **PDF**
 (rasterized via PyMuPDF at 300 DPI), and **SVG** (rasterized via PyMuPDF
-at 300 DPI). All three are tested by default.
+at 300 DPI). All three are tested by default. The TIFF device uses the same
+Cairo rendering pipeline as PNG and is not separately tested.
 
 ## Requirements