* {
  filter: none !important;
  backdrop-filter: none !important;
}

.sheet-page-container {
  height: calc(100% - 0.5px);
  overflow: hidden;
}

.spatial-budget-sandbox {
  contain: layout style size !important;
  position: fixed !important;
  top: -10000px !important;
  left: -10000px !important;
  pointer-events: none !important;
  visibility: hidden !important;
}

await page.evaluate(() => document.fonts.ready);

@page {
  size: 210mm 297mm;
  margin: 0;
}

export interface SnapshotOptions {
  stripInteractive?: boolean;
  inlineAssets?: boolean;
  allowedOrigins?: string[];
  extraStyles?: string;
}

export class DOMSnapshotSerializer {
  public static async serialize(
    sourceElement: HTMLElement,
    options: SnapshotOptions = {}
  ): Promise<string> {
    // 1. Ensure all web fonts are loaded
    await document.fonts.ready;

    // 2. Deep clone the live DOM node
    const clone = sourceElement.cloneNode(true) as HTMLElement;

    // 3. Security sanitization: strip script, iframe, embed tags and on* attributes
    const dangerousTags = clone.querySelectorAll('script, iframe, object, embed, applet');
    dangerousTags.forEach((el) => el.remove());

    const allElements = clone.querySelectorAll('*');
    allElements.forEach((el) => {
      Array.from(el.attributes).forEach((attr) => {
        if (attr.name.toLowerCase().startsWith('on')) {
          el.removeAttribute(attr.name);
        }
      });
    });

    // 4. Extract and lock computed CSS custom properties onto :root
    const computed = window.getComputedStyle(sourceElement);
    const propertiesToLock = [
      '--cv-primary-color',
      '--cv-bg-color',
      '--cv-font-scale',
      '--cv-gap-scale',
      '--cv-padding-scale',
      '--cv-line-height',
      '--cv-sidebar-width'
    ];

    let rootVars = ':root {\n';
    for (const prop of propertiesToLock) {
      const val = computed.getPropertyValue(prop).trim();
      if (val) rootVars += `  ${prop}: ${val};\n`;
    }
    rootVars += '}\n';

    // 5. Strip non-print interactive controls
    if (options.stripInteractive !== false) {
      const interactive = clone.querySelectorAll(
        '[data-cv-interactive="true"], button, .no-print, [aria-hidden="true"]'
      );
      interactive.forEach((el) => el.remove());
    }

    // 6. Securely inline verified image assets as Base64
    if (options.inlineAssets !== false) {
      const images = Array.from(clone.querySelectorAll('img'));
      for (const img of images) {
        const src = img.getAttribute('src');
        if (src && !src.startsWith('data:')) {
          try {
            const base64 = await this.safeUrlToBase64(src, options.allowedOrigins);
            img.setAttribute('src', base64);
          } catch {
            // Keep original src if offline conversion fails
          }
        }
      }
    }

    // 7. Assemble standalone HTML document
    return `<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Document Snapshot</title>
  <style>
    ${rootVars}
    @page { margin: 0; }
    * { -webkit-print-color-adjust: exact !important; print-color-adjust: exact !important; }
    * { filter: none !important; backdrop-filter: none !important; }
    body { margin: 0; padding: 0; background: transparent; }
    ${options.extraStyles || ''}
  </style>
</head>
<body>
  ${clone.outerHTML}
</body>
</html>`;
  }

  private static async safeUrlToBase64(url: string, allowedOrigins?: string[]): Promise<string> {
    const parsed = new URL(url, window.location.href);
    if (!['http:', 'https:'].includes(parsed.protocol)) {
      throw new Error(`Disallowed protocol: ${parsed.protocol}`);
    }
    if (allowedOrigins && !allowedOrigins.includes(parsed.origin) && parsed.origin !== window.location.origin) {
      throw new Error(`Origin not allowed: ${parsed.origin}`);
    }
    const res = await fetch(url);
    const blob = await res.blob();
    return new Promise((resolve, reject) => {
      const reader = new FileReader();
      reader.onloadend = () => resolve(reader.result as string);
      reader.onerror = reject;
      reader.readAsDataURL(blob);
    });
  }
}

export interface CustomPageDimensions {
  widthMm: number;
  heightMm: number;
  name?: string;
}

export type PageFormat = 'a4' | 'a3' | 'a5' | 'letter' | 'legal' | 'tabloid' | 'custom';

export class PageGeometryEngine {
  private static readonly PRESETS: Record<Exclude<PageFormat, 'custom'>, CustomPageDimensions> = {
    a4: { widthMm: 210, heightMm: 297, name: 'ISO A4' },
    a3: { widthMm: 297, heightMm: 420, name: 'ISO A3' },
    a5: { widthMm: 148, heightMm: 210, name: 'ISO A5' },
    letter: { widthMm: 215.9, heightMm: 279.4, name: 'US Letter' },
    legal: { widthMm: 215.9, heightMm: 355.6, name: 'US Legal' },
    tabloid: { widthMm: 279.4, heightMm: 431.8, name: 'Tabloid (11x17)' }
  };

  public static getDimensions(format: PageFormat, custom?: CustomPageDimensions) {
    const dim = format === 'custom' && custom ? custom : this.PRESETS[format as keyof typeof this.PRESETS] || this.PRESETS.a4;
    const widthPt = (dim.widthMm * 72) / 25.4;
    const heightPt = (dim.heightMm * 72) / 25.4;
    const widthPx = (dim.widthMm * 96) / 25.4;
    const heightPx = (dim.heightMm * 96) / 25.4;

    return {
      name: dim.name || 'Custom',
      widthMm: dim.widthMm,
      heightMm: dim.heightMm,
      widthPt: Number(widthPt.toFixed(2)),
      heightPt: Number(heightPt.toFixed(2)),
      widthPx: Number(widthPx.toFixed(2)),
      heightPx: Number(heightPx.toFixed(2)),
      // Epsilon-buffered maximum height to prevent LayoutUnit quantization blank pages
      heightBudgetPx: Number((heightPx - 0.5).toFixed(2))
    };
  }

  public static applyRuntimeGeometry(doc: Document, format: PageFormat, custom?: CustomPageDimensions): void {
    const dim = this.getDimensions(format, custom);
    let styleEl = doc.getElementById('runtime-page-geometry') as HTMLStyleElement;
    if (!styleEl) {
      styleEl = doc.createElement('style');
      styleEl.id = 'runtime-page-geometry';
      doc.head.appendChild(styleEl);
    }

    styleEl.textContent = `
      :root {
        --cv-page-width: ${dim.widthMm}mm;
        --cv-page-height: ${dim.heightMm}mm;
        --cv-page-width-px: ${dim.widthPx}px;
        --cv-page-height-px: ${dim.heightPx}px;
      }
      @page {
        size: ${dim.widthMm}mm ${dim.heightMm}mm;
        margin: 0;
      }
      .sheet-page-container {
        width: ${dim.widthMm}mm;
        min-height: ${dim.heightMm}mm;
        max-height: calc(${dim.heightMm}mm - 0.5px);
        box-sizing: border-box;
        overflow: hidden;
      }
    `;
  }
}

# cv_pdf_pool.py: High-Throughput Browser Context Pool
import asyncio
import logging
from typing import Optional
from playwright.async_api import async_playwright, Browser, BrowserContext, Playwright

logger = logging.getLogger("pdf_pool")

class PlaywrightPDFPool:
    def __init__(self, max_concurrency: int = 4, max_jobs_before_recycle: int = 500):
        self.max_concurrency = max_concurrency
        self.max_jobs_before_recycle = max_jobs_before_recycle
        self.semaphore = asyncio.Semaphore(max_concurrency)
        self.job_counter = 0
        self.playwright: Optional[Playwright] = None
        self.browser: Optional[Browser] = None
        self._lock = asyncio.Lock()

    async def initialize(self):
        async with self._lock:
            if self.browser and self.browser.is_connected():
                return
            self.playwright = await async_playwright().start()
            self.browser = await self.playwright.chromium.launch(
                headless=True,
                args=[
                    "--disable-background-networking",
                    "--disable-gpu",
                    "--disable-dev-shm-usage",
                    "--no-sandbox",
                    "--font-render-hinting=none"
                ]
            )
            self.job_counter = 0
            logger.info("Playwright PDF Pool initialized with warm Chromium instance.")

    async def render_pdf(
        self,
        html_content: str,
        width_mm: float = 210.0,
        height_mm: float = 297.0
    ) -> bytes:
        await self.initialize()

        async with self.semaphore:
            self.job_counter += 1
            if self.job_counter >= self.max_jobs_before_recycle:
                logger.info("Recycling browser process after %d jobs.", self.job_counter)
                await self.recycle()

            # Create isolated context for the request
            context: BrowserContext = await self.browser.new_context(
                viewport={"width": int(width_mm * 96 / 25.4), "height": int(height_mm * 96 / 25.4)},
                device_scale_factor=1.0
            )

            try:
                page = await context.new_page()

                # Abort tracking and off-target external requests
                await page.route(
                    "**/*",
                    lambda route: route.abort() if route.request.resource_type in ["media", "websocket"] else route.continue_()
                )

                # Load HTML with networkidle guarantee
                await page.set_content(html_content, wait_until="networkidle")
                await page.evaluate("document.fonts.ready")

                # Generate tagged, vector-clean PDF via CDP
                pdf_bytes = await page.pdf(
                    width=f"{width_mm}mm",
                    height=f"{height_mm}mm",
                    print_background=True,
                    prefer_css_page_size=True,
                    tagged=True,
                    margin={"top": "0mm", "right": "0mm", "bottom": "0mm", "left": "0mm"}
                )
                return pdf_bytes
            finally:
                await context.close()

    async def recycle(self):
        async with self._lock:
            if self.browser:
                await self.browser.close()
            if self.playwright:
                await self.playwright.stop()
            self.browser = None
            self.playwright = None
            await self.initialize()

    async def shutdown(self):
        async with self._lock:
            if self.browser:
                await self.browser.close()
            if self.playwright:
                await self.playwright.stop()

// CVPageViewportScaler.tsx: Optical scaling without DOM reflow
import React, { useRef, useState, useEffect } from 'react';

interface ScalerProps {
  children: React.ReactNode;
  pageWidthPx?: number; // Default: 793.70 (A4)
  zoomMode?: 'auto' | '100' | 'fit-width' | number;
}

export const CVPageViewportScaler: React.FC<ScalerProps> = ({
  children,
  pageWidthPx = 793.70,
  zoomMode = 'auto'
}) => {
  const containerRef = useRef<HTMLDivElement>(null);
  const [scale, setScale] = useState<number>(1.0);

  useEffect(() => {
    if (typeof zoomMode === 'number') {
      setScale(zoomMode);
      return;
    }
    if (zoomMode === '100') {
      setScale(1.0);
      return;
    }

    const updateScale = () => {
      if (!containerRef.current) return;
      const availableWidth = containerRef.current.clientWidth - 32; // 16px gutter
      if (availableWidth <= 0) return;

      if (availableWidth < pageWidthPx || zoomMode === 'fit-width') {
        const calculatedScale = Math.min(1.2, Math.max(0.4, availableWidth / pageWidthPx));
        setScale(calculatedScale);
      } else {
        setScale(1.0);
      }
    };

    updateScale();
    const observer = new ResizeObserver(updateScale);
    if (containerRef.current) observer.observe(containerRef.current);
    return () => observer.disconnect();
  }, [pageWidthPx, zoomMode]);

  return (
    <div
      ref={containerRef}
      className="cv-page-viewport-scaler-wrapper"
      style={{ width: '100%', display: 'flex', justifyContent: 'center', overflow: 'auto' }}
    >
      <div
        className="cv-page-viewport-scaler"
        style={{
          transform: `scale(${scale})`,
          transformOrigin: 'top center',
          width: `${pageWidthPx}px`,
          flexShrink: 0,
          transition: 'transform 0.15s ease-out'
        }}
      >
        {children}
      </div>
    </div>
  );
};

/* Print Invariance Override: Optical Zoom completely collapses in @media print */
@media print {
  .cv-page-viewport-scaler-wrapper {
    overflow: visible !important;
    display: block !important;
    width: 100% !important;
    margin: 0 !important;
    padding: 0 !important;
  }

  .cv-page-viewport-scaler {
    transform: none !important;
    width: var(--cv-page-width, 210mm) !important;
    margin: 0 !important;
    padding: 0 !important;
  }
}

# pdf_post_processor.py
import io
import pikepdf

def post_process_pdf_a2b(
    pdf_bytes: bytes,
    title: str = "Document",
    author: str = "System",
    subject: str = "Standard Report"
) -> bytes:
    """Post-process a Chromium tagged PDF into compliant PDF/A-2b and PDF/UA-1."""
    pdf = pikepdf.open(io.BytesIO(pdf_bytes))

    # 1. Update Document Info Dictionary
    with pdf.open_metadata() as meta:
        meta["dc:title"] = title
        meta["dc:creator"] = [author]
        meta["dc:description"] = subject
        meta["pdfaid:part"] = "2"
        meta["pdfaid:conformance"] = "B"
        meta["pdfuaid:part"] = "1"

    # 2. Attach sRGB Output Intent if not present
    if "/OutputIntents" not in pdf.Root:
        icc_profile_data = b"..." # Embed standard sRGB2014 ICC profile stream
        icc_stream = pdf.make_stream(icc_profile_data)
        icc_stream["/N"] = 3

        output_intent = pdf.make_indirect({
            "/Type": pikepdf.Name("/OutputIntent"),
            "/S": pikepdf.Name("/GTS_PDFA1"),
            "/OutputConditionIdentifier": pikepdf.String("sRGB IEC61966-2.1"),
            "/Info": pikepdf.String("sRGB IEC61966-2.1"),
            "/DestOutputProfile": icc_stream
        })
        pdf.Root["/OutputIntents"] = pdf.make_array([output_intent])

    # 3. Save linearized (Fast Web View)
    out_buf = io.BytesIO()
    pdf.save(out_buf, linearize=True)
    return out_buf.getvalue()

# pdf_integrity_auditor.py
import io
import pikepdf

class PDFVectorIntegrityAuditor:
    @staticmethod
    def audit(pdf_bytes: bytes) -> dict:
        pdf = pikepdf.open(io.BytesIO(pdf_bytes))
        num_pages = len(pdf.pages)

        findings = {
            "num_pages": num_pages,
            "has_struct_tree_root": "/StructTreeRoot" in pdf.Root,
            "all_pages_vector": True,
            "raster_fallback_detected": False,
            "pua_characters_count": 0,
            "fonts": []
        }

        for i, page in enumerate(pdf.pages):
            # Check for high-res vector content vs raster fallback
            images = page.images
            for img_name, img_obj in images.items():
                w, h = img_obj.Width, img_obj.Height
                # If image dimensions closely match page pixel dimensions at 72 DPI, Skia raster fallback occurred
                if 580 <= w <= 620 and 780 <= h <= 850:
                    findings["raster_fallback_detected"] = True
                    findings["all_pages_vector"] = False

            # Check fonts for valid /ToUnicode mapping
            if "/Resources" in page and "/Font" in page["/Resources"]:
                for font_name, font_dict in page["/Resources"]["/Font"].items():
                    font_info = {
                        "name": str(font_name),
                        "has_to_unicode": "/ToUnicode" in font_dict
                    }
                    findings["fonts"].append(font_info)

        return findings