feat(render): raport PDF przez LaTeX jako osobna usluga (PRE-24)

Ostatnia z osmiu wskazowek partnerow. Nowa usluga services/render sklada raport:
generuje plik posredni .tex i kompiluje go XeLaTeX-em do PDF.

OSOBNY komponent, nie czesc prezentacji — ta sama zasada co przy izolacji
swissepha (LOG-27). TeX Live wazy setki megabajtow; w obrazie produktu
spowalnialby kazdy build, a tak aktualizuje sie niezaleznie i jego awaria nie
kladzie aplikacji, tylko przycisk „Pobierz PDF".

SZYFROWANIE, o ktore prosiles: lacze prezentacja↔render idzie tak samo jak
pozostale, ale z WLASNYM, TRZECIM kluczem (LINK_KEY_PRESENTATION_RENDER). Osobny,
bo tym laczem plynie CALY raport — dane urodzeniowe i opisy z baz — wiec przejecie
go nie moze otwierac lacza do logiki ani do danych. Fail-closed: bez klucza pod
nie wstaje. Test kopii link_crypto obejmuje teraz cztery uslugi.

Uklad PDF wg prosby: imie i nazwisko -> wprowadzone dane -> RYSUNEK kosmogramu
-> interpretacja natalna -> predykcje okresowe. Test pilnuje kolejnosci.

Dwie rzeczy, ktore wyszly dopiero przy skladaniu tego kawalka:

1. KOSMOGRAM NIE NADAWAL SIE DO PDF. Uzywa zmiennych CSS (var(--line)) i klasy
   .glyph, ktorej font podaje styles.css — a samodzielny konwerter SVG→PDF nie zna
   naszego arkusza. Wyszlyby czarne kreski BEZ SYMBOLI. Stad wariant „print":
   konkretne kolory na bialym tle i font glifow wpisany wprost w rysunek. Przy
   okazji zalatwia to etap 4 planu kola (wariant do druku).

2. UCIECZKA ZNAKOW LATEXA byla zepsuta — i zlapal to moj wlasny test. Zamiana
   „\” na \textbackslash{} szla w tej samej petli co nawiasy, wiec kolejne
   podmiany ucieklyby nawiasy dopiero co wstawione: wychodzilo
   \textbackslash\{\}. Poprawka: ukosnik chowany pod znacznik zastepczy i
   rozwijany na koncu. To nie kosmetyka — niezauwazony „%” komentuje RESZTE LINII,
   wiec zdanie od modelu urywaloby sie w polowie, a PDF powstawalby normalnie,
   tylko krotszy. Test na wrogim tekscie sprawdza tez, ze \end{document} ani
   \input{} nie wyrwa sie z dokumentu.

Usluga nie zapisuje nic poza katalogiem tymczasowym, ktory sprzata po sobie;
w manifescie readOnlyRootFilesystem + emptyDir na /tmp. /health raportuje
obecnosc xelatex i rsvg-convert, zeby zepsuty obraz bylo widac od razu.

Zweryfikowane na zywo (TestClient uslugi render): zadanie bez szyfrowania
z POPRAWNYM tokenem -> 400; obcy klucz -> 400 i tajny opis nie wraca; wlasciwy
klucz -> zadanie dochodzi do aplikacji, tresci baz NIE MA na kablu, odpowiedz
zaszyfrowana. Manifesty przechodza kubectl apply --dry-run=server na zywym
klastrze.

CZEGO NIE SPRAWDZILEM: samej kompilacji PDF. W tym srodowisku nie ma ani TeX
Live, ani dzialajacego runtime'u kontenerow (docker CLI jest, daemon nie) —
probowalem zbudowac obraz i sie nie dalo. Sprawdzone jest wszystko dookola:
generowanie .tex, ucieczka znakow, szyfrowanie, kontrakt API, samowystarczalnosc
SVG. Pierwsze uruchomienie na klastrze trzeba obejrzec — dlatego PRE-24 zostaje
jako „W trakcie", nie „Zrobione".

Instrukcja wdrozenia: docs/wdrozenie-render-pdf.md (klucz, obraz, merge,
weryfikacja, znane ograniczenia).

Testy: 15 nowych (render) + 14 (lacze i wariant druku w prezentacji).
Calosc: prezentacja 131, logika 265/1 skip, render 15.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

services/render/Dockerfile

@@ -0,0 +1,31 @@
+# Usługa render: składa raport PDF (PRE-24).
+#
+# Obraz jest CIĘŻKI (TeX Live) i właśnie dlatego stoi osobno — patrz app/main.py.
+# Dobieramy pakiety wąsko, zamiast brać texlive-full (kilka GB):
+#   texlive-xetex              — silnik XeLaTeX (unicode + fonty systemowe),
+#   texlive-latex-recommended  — geometry, graphicx,
+#   texlive-fontspec... (w xetex) — wybór fontu systemowego,
+#   fonts-dejavu-core          — polskie znaki ORAZ glify astrologiczne (♄ ♓ ☉),
+#   librsvg2-bin               — rsvg-convert: SVG kosmogramu → PDF.
+FROM python:3.12-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        texlive-xetex \
+        texlive-latex-recommended \
+        fonts-dejavu-core \
+        librsvg2-bin \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+
+# Sprawdzenie przy budowie: brak narzędzia ma wyjść TERAZ, nie przy pierwszym
+# raporcie na produkcji.
+RUN xelatex --version > /dev/null && rsvg-convert --version > /dev/null \
+    && echo "xelatex + rsvg-convert OK"
+
+EXPOSE 8004
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8004"]

services/render/app/compile.py

@@ -0,0 +1,77 @@
+"""Kompilacja raportu do PDF (PRE-24).
+
+Dwa kroki zewnętrzne, oba w katalogu tymczasowym, który po sobie sprzątamy:
+  1. SVG kosmogramu → PDF (`rsvg-convert`). LaTeX nie wstawia SVG wprost;
+     zamiana na PDF zachowuje wektor, więc rysunek zostaje ostry przy dowolnym
+     powiększeniu.
+  2. .tex → PDF (`xelatex`).
+
+Świadomie NIE logujemy treści raportu — to dane urodzeniowe i opisy z baz.
+Do logu idzie wyłącznie ogon komunikatów LaTeXa przy błędzie, bo bez niego
+diagnoza jest niemożliwa.
+"""
+from __future__ import annotations
+
+import logging
+import pathlib
+import shutil
+import subprocess
+import tempfile
+
+from app.latex import build
+
+log = logging.getLogger("astrololo.render")
+
+WHEEL_SVG = "wheel.svg"
+WHEEL_PDF = "wheel.pdf"
+DOC = "report"
+TIMEOUT = 120          # xelatex na dużym tekście potrzebuje chwili
+
+
+class RenderError(Exception):
+    """Kompilacja się nie udała — z komunikatem nadającym się do pokazania."""
+
+
+def _run(cmd: list[str], cwd: pathlib.Path) -> subprocess.CompletedProcess:
+    return subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, timeout=TIMEOUT)
+
+
+def _svg_to_pdf(svg: str, work: pathlib.Path) -> str | None:
+    """Zwraca nazwę pliku PDF z kosmogramem albo None, gdy nie ma czego rysować."""
+    if not svg or not svg.strip():
+        return None
+    (work / WHEEL_SVG).write_text(svg, encoding="utf-8")
+    proc = _run(["rsvg-convert", "-f", "pdf", "-o", WHEEL_PDF, WHEEL_SVG], work)
+    if proc.returncode != 0 or not (work / WHEEL_PDF).exists():
+        # Brak rysunku nie może wywalić całego raportu — tekst jest ważniejszy.
+        log.warning("konwersja kosmogramu nie udała się: %s", (proc.stderr or "")[-300:])
+        return None
+    return WHEEL_PDF
+
+
+def to_pdf(report: dict) -> bytes:
+    """Raport (dict) → bajty PDF. Rzuca RenderError, gdy LaTeX nie zbuduje pliku."""
+    with tempfile.TemporaryDirectory(prefix="astrololo-render-") as tmp:
+        work = pathlib.Path(tmp)
+        wheel = _svg_to_pdf(report.get("wheel_svg") or "", work)
+        (work / f"{DOC}.tex").write_text(build(report, wheel), encoding="utf-8")
+
+        proc = _run(
+            ["xelatex", "-interaction=nonstopmode", "-halt-on-error", f"{DOC}.tex"],
+            work,
+        )
+        pdf = work / f"{DOC}.pdf"
+        if not pdf.exists():
+            tail = (proc.stdout or "")[-1200:]
+            log.error("xelatex nie zbudował PDF-a; ogon logu: %s", tail)
+            raise RenderError("LaTeX nie zbudował dokumentu. Ogon logu: " + tail[-400:])
+        return pdf.read_bytes()
+
+
+def toolchain_ready() -> dict:
+    """Czy narzędzia są na miejscu — do /health, żeby awarię obrazu widzieć od razu,
+    a nie przy pierwszym raporcie."""
+    return {
+        "xelatex": bool(shutil.which("xelatex")),
+        "rsvg-convert": bool(shutil.which("rsvg-convert")),
+    }

services/render/app/latex.py

@@ -0,0 +1,131 @@
+"""Budowa dokumentu LaTeX raportu (PRE-24).
+
+Układ wg prośby partnerów:
+  1. imię i nazwisko,
+  2. wprowadzone dane,
+  3. rysunek kosmogramu,
+  4. interpretacja natalna,
+  5. predykcje okresowe.
+
+Silnik: XeLaTeX. Nie pdflatex — tekst zawiera polskie znaki ORAZ glify
+astrologiczne (♄ ♓ ☉ …), a te wymagają silnika unicode'owego z fontem systemowym.
+DejaVu Sans ma jedno i drugie, dlatego jest fontem głównym.
+"""
+from __future__ import annotations
+
+# Znaki, które w LaTeXu mają własne znaczenie.
+#
+# Odwrotnego ukośnika NIE MA na tej liście celowo. Jego zamiennik
+# (`\textbackslash{}`) sam zawiera nawiasy klamrowe, więc gdyby szedł w tej samej
+# pętli, kolejne podmiany uciekłyby nawiasy, które dopiero co wstawiliśmy —
+# i zamiast ukośnika wyszedłby dosłowny tekst `\textbackslash\{\}`. Dlatego
+# ukośnik chowamy najpierw pod znacznik zastępczy, a rozwijamy na samym końcu.
+_ESCAPES = [
+    ("{", r"\{"),
+    ("}", r"\}"),
+    ("$", r"\$"),
+    ("&", r"\&"),
+    ("#", r"\#"),
+    ("_", r"\_"),
+    ("%", r"\%"),
+    ("~", r"\textasciitilde{}"),
+    ("^", r"\textasciicircum{}"),
+]
+
+# Znak spoza tekstu użytkownika — nie da się go wpisać, więc nie da się nim
+# oszukać ucieczki.
+_BACKSLASH_MARK = "\x00astrololo-backslash\x00"
+
+
+def esc(text: object) -> str:
+    """Ucieka znaki specjalne LaTeXa.
+
+    Najgroźniejszy jest `%`: bez ucieczki komentuje RESZTĘ LINII, więc tekst od
+    modelu urwałby się w środku zdania i nikt by tego nie zauważył — PDF
+    powstałby normalnie, tylko krótszy. Dlatego to nie kosmetyka, a warunek
+    poprawności raportu.
+    """
+    out = "" if text is None else str(text)
+    out = out.replace("\\", _BACKSLASH_MARK)      # schowaj, żeby nie ucierpiał niżej
+    for ch, rep in _ESCAPES:
+        out = out.replace(ch, rep)
+    return out.replace(_BACKSLASH_MARK, r"\textbackslash{}")
+
+
+def _paragraphs(text: str) -> str:
+    """Tekst od modelu → akapity LaTeXa.
+
+    Model oddziela akapity pustą linią. Zamieniamy je na osobne akapity, a same
+    złamania wiersza w środku akapitu zostawiamy LaTeXowi do złożenia.
+    """
+    blocks = [b.strip() for b in str(text or "").split("\n\n")]
+    return "\n\n".join(esc(b).replace("\n", " ") for b in blocks if b)
+
+
+PREAMBLE = r"""\documentclass[11pt,a4paper]{article}
+\usepackage{fontspec}
+\usepackage[margin=2.4cm]{geometry}
+\usepackage{graphicx}
+% DejaVu Sans ma i polskie znaki, i glify astrologiczne — jeden font na oba
+% zadania oszczędza nam dobierania fontu zapasowego.
+\setmainfont{DejaVu Sans}
+\setlength{\parindent}{0pt}
+\setlength{\parskip}{0.6em}
+\pagestyle{plain}
+\begin{document}
+"""
+
+
+def build(report: dict, wheel_pdf: str | None = None) -> str:
+    """Składa źródło .tex. `wheel_pdf` to nazwa pliku z kosmogramem (już PDF)."""
+    person = str(report.get("person") or "").strip()
+    data = report.get("data") or {}
+    natal = report.get("natal") or {}
+    predictions = report.get("predictions") or []
+
+    parts = [PREAMBLE]
+
+    # ── 1. imię i nazwisko ──────────────────────────────────────────────
+    parts.append(r"{\Huge\bfseries " + esc(person or "Raport astrologiczny") + r"\par}")
+    parts.append(r"\vspace{0.3em}")
+
+    # ── 2. wprowadzone dane ─────────────────────────────────────────────
+    rows = [
+        ("Data urodzenia", data.get("date")),
+        ("Godzina (lokalna)", data.get("time")),
+        ("Offset względem GMT", data.get("tz_offset")),
+        ("Szerokość", data.get("lat")),
+        ("Długość", data.get("lon")),
+        ("Miejsce", data.get("place")),
+        ("System domów", data.get("house_system")),
+        ("Zodiak", data.get("zodiac")),
+    ]
+    parts.append(r"\begin{tabular}{@{}ll@{}}")
+    for label, value in rows:
+        if value not in (None, ""):
+            parts.append(esc(label) + r" & " + esc(value) + r"\\")
+    parts.append(r"\end{tabular}")
+    parts.append(r"\vspace{1em}")
+
+    # ── 3. kosmogram ────────────────────────────────────────────────────
+    if wheel_pdf:
+        parts.append(r"\begin{center}")
+        parts.append(r"\includegraphics[width=0.82\textwidth]{" + wheel_pdf + r"}")
+        parts.append(r"\end{center}")
+        parts.append(r"\vspace{0.5em}")
+
+    # ── 4. interpretacja natalna ────────────────────────────────────────
+    if natal.get("text"):
+        parts.append(r"\section*{Interpretacja natalna}")
+        parts.append(_paragraphs(natal["text"]))
+
+    # ── 5. predykcje okresowe ───────────────────────────────────────────
+    if predictions:
+        parts.append(r"\section*{Predykcje okresowe}")
+        for p in predictions:
+            span = f"{p.get('from_date', '')} – {p.get('to_date', '')}"
+            parts.append(r"\subsection*{" + esc(span) + r"}")
+            parts.append(_paragraphs(p.get("text")))
+
+    parts.append(r"\end{document}")
+    return "\n".join(parts) + "\n"

services/render/app/link_crypto.py

@@ -0,0 +1,525 @@
+"""Szyfrowanie łączy między warstwami (PRE-16 / LOG-33).
+
+Do tej pory warstwy rozmawiały ze sobą zwykłym HTTP-em wewnątrz klastra. Token
+międzywarstwowy (LOG-32) mówił KTO pyta, ale nie ukrywał CZEGO dotyczy odpowiedź
+— a płyną nią surowe wiersze oryginalnych baz interpretacyjnych, czyli rdzeń
+produktu. Kto podsłuchał ruch wewnątrz sieci (drugi pod, port mirror na switchu,
+zrzut z węzła), miał je w całości.
+
+Ten moduł zamyka tę drogę: **AES-256-GCM** na ciele każdego żądania i odpowiedzi.
+GCM daje jednocześnie poufność i uwierzytelnienie — cudzy albo podmieniony bajt
+nie odszyfruje się w ogóle, więc nie ma osobnego problemu „zaszyfrowane, ale
+podatne na modyfikację".
+
+**Dwa niezależne klucze**, po jednym na parę rozmówców:
+  * ``LINK_KEY_PRESENTATION_LOGIC`` — prezentacja ↔ logika,
+  * ``LINK_KEY_LOGIC_DATA``        — logika ↔ dane.
+Dzięki temu przejęcie klucza prezentacji nie daje dostępu do warstwy danych,
+gdzie leżą całe bazy. Logika trzyma oba, bo rozmawia w obie strony.
+
+Z każdego klucza łącza wyprowadzamy **osobne podklucze na kierunek** (HKDF).
+Żądanie i odpowiedź nigdy nie szyfrują się tym samym kluczem, więc powtórzenie
+losowej jednorazówki w jedną stronę nie osłabia drugiej.
+
+Format ramki (bo strumień odpowiedzi może iść kawałkami — patrz okno postępu):
+
+    [4 bajty długości][magia "AL1"][12 bajtów jednorazówki][szyfrogram + znacznik]
+
+Do materiału uwierzytelnianego (AAD) wchodzą kierunek, ścieżka, znacznik czasu
+i numer ramki. Skutek: ramki nie da się przekleić do innego endpointu, odtworzyć
+po czasie (dopuszczalny poślizg ``MAX_SKEW``) ani przestawić w strumieniu.
+
+Bez ustawionego klucza moduł **przepuszcza ruch otwartym tekstem** (dev, zgodność
+wstecz) i krzyczy o tym przy starcie. Gdy klucz JEST ustawiony, warstwa serwerowa
+działa fail-closed: nieszyfrowane żądanie dostaje odmowę, żeby przypadkowa
+regresja po stronie klienta nie oznaczała cichego powrotu do jawnego ruchu.
+"""
+from __future__ import annotations
+
+import base64
+import binascii
+import logging
+import os
+import struct
+import time
+from typing import Iterable, Iterator
+
+from cryptography.exceptions import InvalidTag
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+
+log = logging.getLogger("astrololo.link")
+
+MAGIC = b"AL1"
+VERSION = "v1"
+NONCE_BYTES = 12
+KEY_BYTES = 32                      # AES-256
+LENGTH_PREFIX = 4
+MAX_FRAME = 64 * 1024 * 1024        # zapora przed alokacją z podanej długości
+MAX_SKEW_SECONDS = 300.0
+
+HEADER_ENC = "X-Astrololo-Enc"
+HEADER_TS = "X-Astrololo-Enc-Ts"
+CONTENT_TYPE = "application/vnd.astrololo.enc"
+
+ENV_PRESENTATION_LOGIC = "LINK_KEY_PRESENTATION_LOGIC"
+ENV_LOGIC_DATA = "LINK_KEY_LOGIC_DATA"
+# Trzecia para: prezentacja ↔ render (PRE-24). Osobny klucz, jak przy pozostałych —
+# usługa render dostaje CAŁY raport (dane urodzeniowe + opisy z baz), więc przejęcie
+# jej klucza nie może otwierać łącza do logiki ani do danych.
+ENV_PRESENTATION_RENDER = "LINK_KEY_PRESENTATION_RENDER"
+ENV_REQUIRED = "LINK_ENCRYPTION_REQUIRED"
+
+REQUEST, RESPONSE = b"req", b"res"
+
+# Sondy k8s pukają tu bez klucza i tak ma zostać — inaczej pierwsza literówka
+# w sekrecie kładłaby pody zamiast pokazać błąd w aplikacji.
+PUBLIC_PATHS = frozenset({"/health"})
+
+
+class LinkError(Exception):
+    """Cokolwiek poszło nie tak z kopertą — celowo bez szczegółów na zewnątrz."""
+
+
+# --------------------------------------------------------------------- klucze
+
+def parse_key(raw: str) -> bytes:
+    """Klucz z konfiguracji: hex (64 znaki) albo base64. Zawsze 32 bajty."""
+    text = raw.strip()
+    if not text:
+        raise LinkError("pusty klucz łącza")
+    try:
+        key = bytes.fromhex(text)
+    except ValueError:
+        try:
+            key = base64.b64decode(text, validate=True)
+        except (binascii.Error, ValueError) as exc:
+            raise LinkError("klucz łącza nie jest ani hexem, ani base64") from exc
+    if len(key) != KEY_BYTES:
+        raise LinkError(
+            f"klucz łącza ma {len(key)} B zamiast {KEY_BYTES} — wygeneruj przez "
+            f"`openssl rand -hex 32`"
+        )
+    return key
+
+
+def key_from_env(env_name: str) -> bytes | None:
+    """Klucz albo None. Zły klucz to wyjątek OD RAZU — nie przy pierwszym żądaniu."""
+    raw = os.getenv(env_name, "")
+    return parse_key(raw) if raw.strip() else None
+
+
+def encryption_required() -> bool:
+    """Czy brak klucza ma być błędem, a nie cichym powrotem do jawnego ruchu.
+
+    Serwer sam z siebie broni się fail-closed, ale to za mało: klient BEZ klucza
+    wysyła pytanie otwartym tekstem i dopiero potem dostaje odmowę — czyli treść
+    zapytania zdążyła już przelecieć przez sieć. Ta flaga zatrzymuje go, zanim
+    cokolwiek opuści proces. Ustawiana razem z kluczami we wdrożeniu.
+    """
+    return os.getenv(ENV_REQUIRED, "").strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _subkey(link_key: bytes, direction: bytes) -> bytes:
+    return HKDF(
+        algorithm=hashes.SHA256(), length=KEY_BYTES, salt=None,
+        info=b"astrololo/link/" + direction,
+    ).derive(link_key)
+
+
+class Link:
+    """Jedna para rozmówców: klucz plus wyprowadzone z niego podklucze."""
+
+    def __init__(self, link_key: bytes) -> None:
+        self._by_direction = {
+            REQUEST: AESGCM(_subkey(link_key, REQUEST)),
+            RESPONSE: AESGCM(_subkey(link_key, RESPONSE)),
+        }
+
+    # ---------------------------------------------------------- pojedyncza ramka
+
+    def _aad(self, direction: bytes, path: str, stamp: str, seq: int) -> bytes:
+        return b"|".join([MAGIC, direction, path.encode("utf-8"),
+                          stamp.encode("ascii"), str(seq).encode("ascii")])
+
+    def seal(self, direction: bytes, path: str, stamp: str, seq: int,
+             plaintext: bytes) -> bytes:
+        nonce = os.urandom(NONCE_BYTES)
+        sealed = self._by_direction[direction].encrypt(
+            nonce, plaintext, self._aad(direction, path, stamp, seq))
+        return MAGIC + nonce + sealed
+
+    def open(self, direction: bytes, path: str, stamp: str, seq: int,
+             frame: bytes) -> bytes:
+        if not frame.startswith(MAGIC):
+            raise LinkError("ramka bez znacznika astrololo")
+        body = frame[len(MAGIC):]
+        if len(body) <= NONCE_BYTES:
+            raise LinkError("ramka za krótka")
+        nonce, sealed = body[:NONCE_BYTES], body[NONCE_BYTES:]
+        try:
+            return self._by_direction[direction].decrypt(
+                nonce, sealed, self._aad(direction, path, stamp, seq))
+        except InvalidTag as exc:
+            # Jeden komunikat na wszystkie przypadki: zły klucz, podmieniony bajt,
+            # przeklejenie z innej ścieżki, przestawiona ramka. Rozróżnianie ich
+            # na zewnątrz podpowiadałoby atakującemu, w co trafił.
+            raise LinkError("nie udało się odszyfrować — zły klucz albo naruszone dane") from exc
+
+    # ------------------------------------------------------------ strumień ramek
+
+    def seal_stream(self, direction: bytes, path: str, stamp: str,
+                    chunks: Iterable[bytes]) -> Iterator[bytes]:
+        for seq, chunk in enumerate(chunks):
+            yield frame_out(self.seal(direction, path, stamp, seq, chunk))
+
+    def open_stream(self, direction: bytes, path: str, stamp: str,
+                    raw: bytes) -> Iterator[bytes]:
+        for seq, frame in enumerate(frames_in(raw)):
+            yield self.open(direction, path, stamp, seq, frame)
+
+    def open_all(self, direction: bytes, path: str, stamp: str, raw: bytes) -> bytes:
+        return b"".join(self.open_stream(direction, path, stamp, raw))
+
+
+# ---------------------------------------------------------------- ramkowanie
+
+def frame_out(payload: bytes) -> bytes:
+    return struct.pack(">I", len(payload)) + payload
+
+
+def frames_in(raw: bytes) -> Iterator[bytes]:
+    """Rozbiera bufor na ramki. Ucięty strumień to błąd, nie cicha strata danych."""
+    offset = 0
+    while offset < len(raw):
+        if offset + LENGTH_PREFIX > len(raw):
+            raise LinkError("urwana ramka (brak nagłówka długości)")
+        (size,) = struct.unpack(">I", raw[offset:offset + LENGTH_PREFIX])
+        if size > MAX_FRAME:
+            raise LinkError("ramka ponad dopuszczalny rozmiar")
+        offset += LENGTH_PREFIX
+        if offset + size > len(raw):
+            raise LinkError("urwana ramka (za mało danych)")
+        yield raw[offset:offset + size]
+        offset += size
+
+
+def unframe_incremental(buffer: bytearray) -> Iterator[bytes]:
+    """Wyjmuje z bufora KOMPLETNE ramki i zjada je; resztę zostawia na później.
+
+    Dla odbioru na żywo: kawałki przychodzą podzielone dowolnie i ramka potrafi
+    rozjechać się między dwa odczyty.
+    """
+    while True:
+        if len(buffer) < LENGTH_PREFIX:
+            return
+        (size,) = struct.unpack(">I", buffer[:LENGTH_PREFIX])
+        if size > MAX_FRAME:
+            raise LinkError("ramka ponad dopuszczalny rozmiar")
+        if len(buffer) < LENGTH_PREFIX + size:
+            return
+        frame = bytes(buffer[LENGTH_PREFIX:LENGTH_PREFIX + size])
+        del buffer[:LENGTH_PREFIX + size]
+        yield frame
+
+
+# ------------------------------------------------------------- świeżość ruchu
+
+def stamp_now() -> str:
+    return f"{time.time():.3f}"
+
+
+def check_stamp(stamp: str) -> None:
+    """Odrzuca ramki spoza okna czasowego — inaczej podsłuchane żądanie dałoby się
+    odtworzyć w dowolnym momencie w przyszłości."""
+    try:
+        sent = float(stamp)
+    except (TypeError, ValueError) as exc:
+        raise LinkError("brak albo błędny znacznik czasu") from exc
+    if abs(time.time() - sent) > MAX_SKEW_SECONDS:
+        raise LinkError("znacznik czasu poza dopuszczalnym oknem")
+
+
+# =========================================================== strona serwerowa
+
+class LinkCryptoMiddleware:
+    """Rozszyfrowuje wchodzące żądania i zaszyfrowuje wychodzące odpowiedzi.
+
+    Napisane jako czyste ASGI, nie ``@app.middleware("http")``, bo trzeba
+    podmienić CIAŁO żądania jeszcze zanim zobaczy je FastAPI, oraz przepuścić
+    odpowiedź strumieniową kawałek po kawałku, bez zbierania jej w pamięci.
+    """
+
+    def __init__(self, app, link: Link | None, layer: str) -> None:
+        self.app = app
+        self.link = link
+        self.layer = layer
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "http" or self.link is None or scope["path"] in PUBLIC_PATHS:
+            return await self.app(scope, receive, send)
+
+        path = scope["path"]
+        headers = {k.decode("latin-1").lower(): v.decode("latin-1") for k, v in scope["headers"]}
+
+        if headers.get(HEADER_ENC.lower()) != VERSION:
+            # Fail-closed. Klucz jest ustawiony, więc jawne żądanie oznacza albo
+            # pomyłkę w konfiguracji, albo kogoś obcego — w obu wypadkach nie
+            # chcemy po cichu wrócić do jawnego ruchu.
+            log.warning("warstwa %s: odrzucone żądanie bez szyfrowania łącza (%s)",
+                        self.layer, path)
+            return await _refuse(send, "Łącze międzywarstwowe wymaga szyfrowania.")
+
+        stamp = headers.get(HEADER_TS.lower(), "")
+        try:
+            check_stamp(stamp)
+            plaintext = self.link.open_all(REQUEST, path, stamp, await _read_body(receive))
+        except LinkError as exc:
+            log.warning("warstwa %s: %s (%s)", self.layer, exc, path)
+            return await _refuse(send, "Nie udało się odczytać zaszyfrowanego żądania.")
+
+        scope = dict(scope)
+        scope["headers"] = _rewritten_headers(scope["headers"], len(plaintext))
+        await self.app(scope, _replay(plaintext, receive), self._sealing_send(send, path))
+
+    def _sealing_send(self, send, path: str):
+        state: dict = {"stamp": "", "seq": 0}
+
+        async def sealing(message):
+            if message["type"] == "http.response.start":
+                state["stamp"] = stamp_now()
+                keep = [(k, v) for k, v in message.get("headers", [])
+                        if k.lower() not in (b"content-length", b"content-type")]
+                message = dict(message)
+                message["headers"] = keep + [
+                    (b"content-type", CONTENT_TYPE.encode()),
+                    (HEADER_ENC.lower().encode(), VERSION.encode()),
+                    (HEADER_TS.lower().encode(), state["stamp"].encode()),
+                ]
+                return await send(message)
+
+            if message["type"] == "http.response.body":
+                chunk = message.get("body", b"")
+                sealed = b""
+                if chunk:
+                    sealed = frame_out(self.link.seal(
+                        RESPONSE, path, state["stamp"], state["seq"], chunk))
+                    state["seq"] += 1
+                return await send({"type": "http.response.body", "body": sealed,
+                                   "more_body": message.get("more_body", False)})
+
+            return await send(message)
+
+        return sealing
+
+
+def _rewritten_headers(raw: Iterable[tuple[bytes, bytes]], length: int):
+    """Po odszyfrowaniu ciało ma inną długość i zwykły typ — inaczej FastAPI
+    próbowałby sparsować JSON o cudzej deklarowanej wielkości."""
+    kept = [(k, v) for k, v in raw if k.lower() not in (b"content-length", b"content-type")]
+    kept.append((b"content-length", str(length).encode()))
+    if length:
+        kept.append((b"content-type", b"application/json"))
+    return kept
+
+
+async def _read_body(receive) -> bytes:
+    body = bytearray()
+    while True:
+        message = await receive()
+        if message["type"] == "http.disconnect":
+            raise LinkError("rozłączenie w trakcie odbioru żądania")
+        body += message.get("body", b"")
+        if not message.get("more_body", False):
+            return bytes(body)
+
+
+def _replay(body: bytes, original):
+    """Podstawia odszyfrowane ciało jako jedyną porcję wejścia dla aplikacji.
+
+    Po oddaniu ciała oddajemy głos ORYGINALNEMU `receive`, zamiast od razu
+    zgłaszać rozłączenie. Odpowiedź strumieniowa nasłuchuje bowiem rozłączenia
+    równolegle do wysyłania i przerywa się, gdy je zobaczy — na skróconej wersji
+    okno postępu dostawało pustą odpowiedź, choć zwykłe żądania działały.
+    """
+    delivered = False
+
+    async def receive():
+        nonlocal delivered
+        if delivered:
+            return await original()
+        delivered = True
+        return {"type": "http.request", "body": body, "more_body": False}
+
+    return receive
+
+
+async def _refuse(send, detail: str) -> None:
+    """Odmowa leci JAWNIE — rozmówca właśnie pokazał, że nie umie odszyfrować,
+    więc zaszyfrowany komunikat o błędzie byłby dla niego nieczytelny."""
+    payload = f'{{"detail":"{detail}"}}'.encode("utf-8")
+    await send({"type": "http.response.start", "status": 400, "headers": [
+        (b"content-type", b"application/json"),
+        (b"content-length", str(len(payload)).encode()),
+    ]})
+    await send({"type": "http.response.body", "body": payload})
+
+
+def install(app, env_name: str, layer: str):
+    """Podpina szyfrowanie łącza. Wołać PO `security.install`, żeby także odmowa
+    tokenowa (401) wracała zaszyfrowana — inaczej klient by jej nie odczytał."""
+    link_key = key_from_env(env_name)
+    if link_key is None and encryption_required():
+        # Celowo wywracamy start. Ta sama zasada co przy sekrecie logowania:
+        # wolimy widoczną awarię niż usługę, która wstała i po cichu nie chroni
+        # niczego. Pod w CrashLoop widać od razu, jawny ruch — nie.
+        raise LinkError(
+            f"{ENV_REQUIRED} jest włączone, ale {env_name} nie ustawiony — "
+            f"warstwa {layer} nie wystartuje bez klucza łącza"
+        )
+    if link_key is None:
+        log.warning(
+            "UWAGA: %s nie ustawiony — warstwa %s rozmawia z sąsiadem JAWNYM tekstem, "
+            "więc treść baz interpretacyjnych jest widoczna dla każdego, kto podsłucha "
+            "ruch wewnątrz sieci.", env_name, layer,
+        )
+        return None
+    link = Link(link_key)
+    app.add_middleware(LinkCryptoMiddleware, link=link, layer=layer)
+    log.info("warstwa %s: łącze szyfrowane (AES-256-GCM, klucz z %s)", layer, env_name)
+    return link
+
+
+# ============================================================ strona kliencka
+
+def call(client, method: str, url: str, *, payload=None,
+         headers: dict[str, str] | None = None, link: Link | None) -> bytes:
+    """Żądanie do sąsiedniej warstwy; zwraca odszyfrowane ciało odpowiedzi.
+
+    Ścieżkę do materiału uwierzytelnianego bierzemy Z URL-a, a nie z osobnego
+    argumentu — gdyby klient i serwer liczyły ją inaczej, każde żądanie kończyłoby
+    się niejasnym błędem odszyfrowania.
+    """
+    import json as _json
+
+    import httpx
+
+    request_headers = dict(headers or {})
+    if link is None:
+        if encryption_required():
+            # Zatrzymujemy się PRZED wysłaniem. Gdyby polecieć jawnie i dopiero
+            # zebrać odmowę, pytanie byłoby już na kablu — a to właśnie ono niesie
+            # sygnifikatory, o które pytamy bazę.
+            raise LinkError(
+                f"{ENV_REQUIRED} jest włączone, ale brak klucza łącza — żądanie "
+                f"NIE zostało wysłane, żeby jego treść nie poszła jawnym tekstem"
+            )
+        response = client.request(method, url, json=payload, headers=request_headers)
+        response.raise_for_status()
+        return response.content
+
+    path = httpx.URL(url).path
+    stamp = stamp_now()
+    plaintext = b"" if payload is None else _json.dumps(payload).encode("utf-8")
+    body = frame_out(link.seal(REQUEST, path, stamp, 0, plaintext))
+    request_headers.update({HEADER_ENC: VERSION, HEADER_TS: stamp,
+                            "Content-Type": CONTENT_TYPE})
+
+    response = client.request(method, url, content=body, headers=request_headers)
+    if response.status_code >= 400 and response.headers.get(HEADER_ENC) != VERSION:
+        log.error("łącze %s odmówiło: %s", path, response.text[:200])
+    response.raise_for_status()
+    if response.headers.get(HEADER_ENC) != VERSION:
+        raise LinkError("odpowiedź przyszła nieszyfrowana, choć klucz łącza jest ustawiony")
+    reply_stamp = response.headers.get(HEADER_TS, "")
+    check_stamp(reply_stamp)
+    return link.open_all(RESPONSE, path, reply_stamp, response.content)
+
+
+def call_json(client, method: str, url: str, *, payload=None,
+              headers: dict[str, str] | None = None, link: Link | None):
+    import json as _json
+
+    return _json.loads(call(client, method, url, payload=payload,
+                            headers=headers, link=link))
+
+
+def open_response_stream(response, link: Link | None) -> Iterator[bytes]:
+    """Odbiór odpowiedzi płynącej kawałkami (okno postępu).
+
+    Ramka potrafi rozjechać się między dwa odczyty z gniazda, więc składamy ją
+    w buforze zamiast zakładać, że każdy kawałek to komplet.
+    """
+    if link is None:
+        yield from response.iter_bytes()
+        return
+    if response.headers.get(HEADER_ENC) != VERSION:
+        raise LinkError("strumień przyszedł nieszyfrowany, choć klucz łącza jest ustawiony")
+    stamp = response.headers.get(HEADER_TS, "")
+    check_stamp(stamp)
+    path = response.request.url.path
+    buffer = bytearray()
+    seq = 0
+    for chunk in response.iter_bytes():
+        buffer += chunk
+        for frame in unframe_incremental(buffer):
+            yield link.open(RESPONSE, path, stamp, seq, frame)
+            seq += 1
+    if buffer:
+        raise LinkError("strumień urwał się w połowie ramki")
+
+
+def stream_lines(client, url: str, *, payload, headers: dict[str, str] | None = None,
+                 link: Link | None) -> Iterator[str]:
+    """Strumieniowe POST zwracające kolejne NIEPUSTE linie NDJSON — na żywo.
+
+    Dla okna postępu: linie muszą docierać w trakcie pracy, nie na końcu, więc
+    czytamy strumień, a nie całe ciało. Gdy łącze ma klucz, żądanie jest
+    pieczętowane, a odpowiedź odszyfrowywana ramka po ramce; granice ramek NIE
+    pokrywają się z granicami linii, więc sklejamy bajty w buforze i tniemy je
+    dopiero na znakach nowej linii.
+
+    Bez klucza zachowuje się jak dotąd (surowy strumień), żeby dev bez sekretów
+    działał bez zmian.
+    """
+    import json as _json
+
+    import httpx as _httpx
+
+    request_headers = dict(headers or {})
+    if link is None:
+        if encryption_required():
+            # Ten sam kontrakt co w `call`: nie wypuszczamy jawnego żądania, gdy
+            # szyfrowanie jest wymagane. Bez tego serwer owszem odrzuca (400), ale
+            # ciało żądania — tu dane urodzenia — zdążyłoby już pójść w eter.
+            raise LinkError(
+                f"{ENV_REQUIRED} jest włączone, ale brak klucza łącza — strumień "
+                f"NIE został wysłany, żeby jego treść nie poszła jawnym tekstem"
+            )
+        with client.stream("POST", url, json=payload, headers=request_headers) as response:
+            response.raise_for_status()
+            for text_line in response.iter_lines():
+                if text_line:
+                    yield text_line
+        return
+
+    path = _httpx.URL(url).path
+    stamp = stamp_now()
+    body = frame_out(link.seal(REQUEST, path, stamp, 0, _json.dumps(payload).encode("utf-8")))
+    request_headers.update({HEADER_ENC: VERSION, HEADER_TS: stamp, "Content-Type": CONTENT_TYPE})
+    with client.stream("POST", url, content=body, headers=request_headers) as response:
+        response.raise_for_status()
+        buffer = bytearray()
+        for plain in open_response_stream(response, link):
+            buffer += plain
+            while True:
+                nl = buffer.find(b"\n")
+                if nl < 0:
+                    break
+                text_line = bytes(buffer[:nl])
+                del buffer[:nl + 1]
+                if text_line:
+                    yield text_line.decode("utf-8")
+        if buffer:
+            yield bytes(buffer).decode("utf-8")

services/render/app/main.py

@@ -0,0 +1,62 @@
+"""Warstwa RENDER — usługa składająca raport PDF (PRE-24).
+
+OSOBNA usługa, nie część prezentacji, z tego samego powodu co silnik swisseph
+(LOG-27): TeX Live waży setki megabajtów. Trzymanie go w obrazie produktu
+spowalniałoby każdy build i deploy, a tak aktualizuje się niezależnie i awaria
+renderu nie kładzie aplikacji.
+
+Rozmawia TYLKO z prezentacją, po szyfrowanym łączu (własny, trzeci klucz —
+dostaje cały raport: dane urodzeniowe i opisy z baz). W klastrze wystawiona jako
+ClusterIP, bez wejścia z zewnątrz.
+
+Świadomie nie zapisuje niczego na dysk poza katalogiem tymczasowym, który sprząta
+po sobie — raport nie może zostawiać śladu w kontenerze.
+"""
+from __future__ import annotations
+
+import logging
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import Response
+
+from app import link_crypto, security
+from app.compile import RenderError, to_pdf, toolchain_ready
+
+log = logging.getLogger("astrololo.render")
+
+app = FastAPI(title="astrololo · usługa render (PDF)")
+security.install(app, "render")            # token międzywarstwowy (LOG-32)
+# Szyfrowanie łącza od prezentacji. PO security.install, żeby także odmowa
+# tokenowa wracała zaszyfrowana — inaczej klient nie umiałby jej odczytać.
+link_crypto.install(app, link_crypto.ENV_PRESENTATION_RENDER, "render")
+
+
+@app.post("/pdf")
+def build_pdf(report: dict) -> Response:
+    """Raport (JSON) → PDF. Wejście: person, data, wheel_svg, natal, predictions.
+
+    Zwracamy surowe bajty PDF-a, nie base64 — łącze i tak jest szyfrowane, więc
+    kodowanie tylko rozdmuchałoby odpowiedź o trzecią część.
+    """
+    if not isinstance(report, dict):
+        raise HTTPException(422, "Oczekiwano obiektu JSON z raportem.")
+    try:
+        pdf = to_pdf(report)
+    except RenderError as e:
+        raise HTTPException(500, str(e))
+    except FileNotFoundError as e:                 # brak xelatex/rsvg w obrazie
+        raise HTTPException(503, f"Brak narzędzia w obrazie usługi render: {e}")
+    return Response(
+        content=pdf,
+        media_type="application/pdf",
+        headers={"Content-Disposition": 'attachment; filename="raport.pdf"'},
+    )
+
+
+@app.get("/health")
+def health() -> dict:
+    """Raportuje też obecność narzędzi — dzięki temu zepsuty obraz widać od razu,
+    a nie dopiero przy pierwszym raporcie."""
+    tools = toolchain_ready()
+    return {"status": "ok" if all(tools.values()) else "degraded",
+            "layer": "render", "tools": tools}

services/render/app/security.py

@@ -0,0 +1,50 @@
+"""Uwierzytelnianie międzywarstwowe (LOG-32).
+
+Warstwa logiczna oddaje treść baz interpretacyjnych, więc samo zalogowanie w
+prezentacji nie wystarczy — bez tego kontrolera wystarczyłoby uderzyć w logikę
+z pominięciem UI. Gdy ustawiono INTERNAL_TOKEN, każde żądanie (poza /health)
+musi go przynieść w nagłówku X-Astrololo-Token.
+
+Bez INTERNAL_TOKEN kontrola jest wyłączona (dev / zgodność wstecz) — wtedy przy
+starcie leci ostrzeżenie.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import secrets
+
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+log = logging.getLogger("astrololo.security")
+
+HEADER = "X-Astrololo-Token"
+PUBLIC_PATHS = frozenset({"/health"})
+
+
+def token() -> str:
+    """Czytany leniwie — konfiguracja może się zmienić bez importu modułu."""
+    return os.getenv("INTERNAL_TOKEN", "")
+
+
+def enabled() -> bool:
+    return bool(token())
+
+
+def install(app, layer: str) -> None:
+    if not enabled():
+        log.warning(
+            "UWAGA: INTERNAL_TOKEN nie ustawiony — warstwa %s przyjmuje żądania od "
+            "kogokolwiek, kto ma do niej dostęp sieciowy.", layer,
+        )
+
+    @app.middleware("http")
+    async def _guard(request: Request, call_next):
+        if request.url.path in PUBLIC_PATHS or not enabled():
+            return await call_next(request)
+        got = request.headers.get(HEADER, "")
+        if not secrets.compare_digest(got, token()):
+            return JSONResponse({"detail": "Brak lub błędny token międzywarstwowy."},
+                                status_code=401)
+        return await call_next(request)

services/render/requirements.txt

@@ -0,0 +1,4 @@
+fastapi>=0.115
+uvicorn[standard]>=0.34
+# Szyfrowanie łącza z prezentacją (PRE-16/PRE-24): AES-256-GCM + HKDF
+cryptography>=44.0

services/render/tests/test_latex.py

@@ -0,0 +1,130 @@
+"""Generowanie źródła LaTeX raportu (PRE-24).
+
+Najważniejsza część to UCIECZKA znaków specjalnych. Kompilacji tu nie
+uruchomimy (brak TeX Live w tym środowisku), ale to i tak nie ona jest tu
+najbardziej krucha: błędna ucieczka nie wywala kompilacji, tylko po cichu psuje
+treść — najgorszy możliwy wynik, bo PDF powstaje i wygląda poprawnie.
+"""
+import pytest
+
+from app.latex import build, esc
+
+
+# ─────────────────────────── ucieczka znaków specjalnych ────────────────
+
+def test_percent_is_escaped():
+    """NAJGROŹNIEJSZY przypadek: `%` bez ucieczki komentuje resztę linii, więc
+    zdanie urywa się w środku, a PDF powstaje normalnie — tylko krótszy."""
+    out = esc("wzrost o 50% w tym okresie")
+    assert r"50\%" in out
+    assert "w tym okresie" in out
+
+
+def test_backslash_is_escaped_first():
+    """Odwrotny ukośnik musi iść pierwszy, inaczej zepsulibyśmy ucieczki
+    wstawione później (np. `\\%` zamieniłoby się w coś innego)."""
+    assert esc("a\\b") == r"a\textbackslash{}b"
+
+
+def test_all_specials_are_escaped():
+    for ch in ("$", "&", "#", "_", "%", "{", "}"):
+        assert ch not in esc(ch).replace("\\" + ch, ""), f"{ch} nie zostało uciec­zone"
+
+
+def test_tilde_and_caret_use_commands():
+    assert esc("~") == r"\textasciitilde{}"
+    assert esc("^") == r"\textasciicircum{}"
+
+
+def test_polish_and_glyphs_pass_through():
+    """XeLaTeX bierze unicode wprost — polskich znaków ani glifów nie ruszamy."""
+    text = "Zażółć gęślą jaźń ♄ ♓ ☉"
+    assert esc(text) == text
+
+
+def test_escape_handles_none_and_numbers():
+    assert esc(None) == ""
+    assert esc(42) == "42"
+
+
+# ─────────────────────────────── układ dokumentu ─────────────────────────
+
+def _report(**over):
+    base = {
+        "person": "Jan Kowalski",
+        "data": {"date": "1984-04-30", "time": "11:20", "tz_offset": 2,
+                 "lat": 50.0647, "lon": 19.945, "place": "Kraków",
+                 "house_system": "whole_sign", "zodiac": "tropical"},
+        "natal": {"text": "Interpretacja natalna.\n\nDrugi akapit."},
+        "predictions": [
+            {"from_date": "2026-01-01", "to_date": "2026-03-31", "text": "Pierwszy kwartał."},
+            {"from_date": "2026-07-01", "to_date": "2026-09-30", "text": "Trzeci kwartał."},
+        ],
+    }
+    base.update(over)
+    return base
+
+
+def test_document_is_complete():
+    tex = build(_report())
+    assert tex.startswith(r"\documentclass")
+    assert tex.rstrip().endswith(r"\end{document}")
+
+
+def test_uses_unicode_engine_setup():
+    """XeLaTeX + fontspec — bez tego polskie znaki i glify nie wyjdą."""
+    tex = build(_report())
+    assert r"\usepackage{fontspec}" in tex
+    assert r"\setmainfont" in tex
+
+
+def test_section_order_matches_the_brief():
+    """Prośba partnerów: imię → dane → rysunek → natalna → predykcje."""
+    tex = build(_report(), wheel_pdf="wheel.pdf")
+    person = tex.index("Jan Kowalski")
+    data = tex.index("Data urodzenia")
+    wheel = tex.index("includegraphics")
+    natal = tex.index("Interpretacja natalna")
+    preds = tex.index("Predykcje okresowe")
+    assert person < data < wheel < natal < preds
+
+
+def test_person_name_opens_the_document():
+    tex = build(_report())
+    body = tex.split(r"\begin{document}")[1]
+    assert body.index("Jan Kowalski") < 80, "imię ma być na samym początku"
+
+
+def test_all_predictions_are_included():
+    tex = build(_report())
+    assert "2026-01-01" in tex and "2026-07-01" in tex
+    assert "Pierwszy kwartał" in tex and "Trzeci kwartał" in tex
+
+
+def test_paragraphs_are_preserved():
+    """Model oddziela akapity pustą linią — mają zostać akapitami, nie zlepkiem."""
+    tex = build(_report())
+    assert "Interpretacja natalna." in tex and "Drugi akapit." in tex
+    assert "Interpretacja natalna.\n\nDrugi akapit." in tex
+
+
+def test_hostile_text_cannot_break_the_document():
+    """Tekst od modelu jest wejściem z ZEWNĄTRZ — nie może wstrzyknąć polecenia
+    ani urwać dokumentu."""
+    nasty = r"100% \end{document} \input{/etc/passwd} $x_1$ #& {}"
+    tex = build(_report(natal={"text": nasty}))
+    body = tex.split(r"\begin{document}")[1]
+    assert body.count(r"\end{document}") == 1, "tekst urwał dokument"
+    assert r"\input{" not in body
+
+
+def test_missing_parts_are_simply_absent():
+    """Niekompletny materiał ma dać krótszy raport, nie wyjątek."""
+    tex = build({"person": "", "data": {}})
+    assert r"\begin{document}" in tex and r"\end{document}" in tex
+    assert "Raport astrologiczny" in tex          # zapas, gdy brak imienia
+
+
+def test_wheel_is_optional():
+    assert "includegraphics" not in build(_report())
+    assert "includegraphics" in build(_report(), wheel_pdf="wheel.pdf")