# plot-archive_2026Q2D092W14_Thu02Apr_194922305_X.md

```plaintext
[MiB 176.2] └──┬ 📂 cad-cs                      ./cad-cs/
[MiB 1.214]    ├─── 📂 .git                     ./.git/
[KiB 3.423]    ├─── 📂 .github                  ./.github/
[MiB 2.260]    ├──┬ 📂 .prompt                  ./.prompt/
[KiB 15.57]    │  ├─── 📂 .err                  ./.prompt/.err/
[  B     0]    │  ├──• 📄 .gitkeep              ./.prompt/.gitkeep
[  B     0]    │  ├─── 📂 .helpers              ./.prompt/.helpers/
[MiB 1.226]    │  ├─── 📂 .src                  ./.prompt/.src/
[MiB 1.018]    │  └──• 📄 info.log              ./.prompt/info.log
[KiB 1.641]    ├──• ⚙️ .rustfmt.toml           ./.rustfmt.toml
[KiB 200.5]    ├─── 📂 .vscode                  ./.vscode/
[KiB 16.69]    ├──• 📝 ARCHITECTURE.md          ./ARCHITECTURE.md
[  B     0]    ├──• 📝 AUTHORS.md               ./AUTHORS.md
[  B     0]    ├──• 📝 CHANGELOG.md             ./CHANGELOG.md
[  B 676.0]    ├──• 📝 CHEATSHEET.md            ./CHEATSHEET.md
[KiB 1.716]    ├──• ⚙️ Cargo.toml              ./Cargo.toml
[KiB 37.53]    ├──• ⚙️ Makefile.toml           ./Makefile.toml
[  B     0]    ├──• 📝 README.md                ./README.md
[KiB 2.515]    ├──• 📝 ROADMAP.md               ./ROADMAP.md
[KiB 11.59]    ├──• 📝 TODO.md                  ./TODO.md
[KiB 9.580]    ├──┬ 📂 examples                 ./examples/
[KiB 4.011]    │  ├──• 🦀 basic_usage.rs        ./examples/basic_usage.rs
[KiB 5.568]    │  └──• 🦀 playground.rs         ./examples/playground.rs
[KiB 64.98]    ├──┬ 📂 src                      ./src/
[  B 429.0]    │  ├──• 🦀 lib.rs                ./src/lib.rs
[KiB 1.142]    │  ├──• 🦀 libs.rs               ./src/libs.rs
[KiB 63.42]    │  └──┬ 📂 libs                  ./src/libs/
[  B 222.0]    │     ├──• 🦀 angle.rs           ./src/libs/angle.rs
[KiB 6.964]    │     ├──┬ 📂 angle              ./src/libs/angle/
[  B 765.0]    │     │  ├──• 🦀 abstracts.rs    ./src/libs/angle/abstracts.rs
[KiB 5.341]    │     │  ├──• 🦀 math.rs         ./src/libs/angle/math.rs
[  B 897.0]    │     │  └──• 🦀 model.rs        ./src/libs/angle/model.rs
[KiB 1.378]    │     ├──• 🦀 consts.rs          ./src/libs/consts.rs
[KiB 2.068]    │     ├──• 🦀 cs.rs              ./src/libs/cs.rs
[KiB 49.64]    │     ├──┬ 📂 cs                 ./src/libs/cs/
[KiB 7.079]    │     │  ├──• 🦀 abstracts.rs    ./src/libs/cs/abstracts.rs
[  B 1016]    │     │  ├──• 🦀 core.rs          ./src/libs/cs/core.rs
[KiB 8.179]    │     │  ├──┬ 📂 core            ./src/libs/cs/core/
[KiB 3.624]    │     │  │  ├──• 🦀 d2.rs        ./src/libs/cs/core/d2.rs
[KiB 4.555]    │     │  │  └──• 🦀 d3.rs        ./src/libs/cs/core/d3.rs
[  B 625.0]    │     │  ├──• 🦀 helper.rs       ./src/libs/cs/helper.rs
[KiB 4.119]    │     │  ├──┬ 📂 helper          ./src/libs/cs/helper/
[KiB 1.102]    │     │  │  ├──• 🦀 d2.rs        ./src/libs/cs/helper/d2.rs
[KiB 3.016]    │     │  │  └──• 🦀 d3.rs        ./src/libs/cs/helper/d3.rs
[KiB 2.527]    │     │  ├──• 🦀 macros.rs       ./src/libs/cs/macros.rs
[KiB 5.828]    │     │  ├──• 🦀 math.rs         ./src/libs/cs/math.rs
[KiB 14.34]    │     │  ├──┬ 📂 math            ./src/libs/cs/math/
[KiB 3.500]    │     │  │  ├──• 🦀 d2.rs        ./src/libs/cs/math/d2.rs
[KiB 10.84]    │     │  │  └──• 🦀 d3.rs        ./src/libs/cs/math/d3.rs
[KiB 4.811]    │     │  ├──• 🦀 model.rs        ./src/libs/cs/model.rs
[  B 765.0]    │     │  ├──• 🦀 types.rs        ./src/libs/cs/types.rs
[  B 420.0]    │     │  └──• 🦀 utils.rs        ./src/libs/cs/utils.rs
[KiB 2.267]    │     ├──• 🦀 frac.rs            ./src/libs/frac.rs
[  B 902.0]    │     └──• 🦀 tolerance.rs       ./src/libs/tolerance.rs
[MiB 172.3]    └─── 📂 target                   ./target/
```

### 001: `./.prompt/.gitkeep`

```text

```

### 002: `./.prompt/info.log`

> *(Read error / file is not UTF-8)*

### 003: `./.rustfmt.toml`

```toml
# Wymagane dla zaawansowanych opcji formatowania importów i komentarzy
unstable_features = true

hard_tabs = true
max_width = 100
edition = "2024"
newline_style = "Auto"

# KOMENDY: 
# rustfmt --print-config default
# rustfmt --help=config

# Skracanie inicjalizacji struktur
use_field_init_shorthand = true

# Złoto dla bibliotek matematycznych
use_small_heuristics = "Max"

# Nowoczesna obsługa błędów
use_try_shorthand = true

# Importy (use)
reorder_imports = true
imports_granularity = "Crate"
group_imports = "StdExternalCrate"
imports_layout = "HorizontalVertical"

# formatowanie kodu w komentarzach potrójnych
format_code_in_doc_comments = true
normalize_doc_attributes = true

# --- WALKA Z NADMIARNYMI ENTERAMI ---

overflow_delimited_expr = true
where_single_line = true

# Formatowanie struktur i bloków
brace_style = "PreferSameLine"
control_brace_style = "AlwaysSameLine"
indent_style = "Block"

# Pozwala na krótkie funkcje w jednej linii (np. proste gettery)
fn_single_line = true

# Pozwala trzymać proste 'if-else' w jednej linii
single_line_if_else_max_width = 60

# Zwiększa limit dla tablic i list (kluczowe przy Twoim Cs([x, y, z]))
array_width = 80
attr_fn_like_width = 80

# Pozwala na definicję prostych struktur w jednej linii
struct_lit_single_line = true

# Zwiększa szerokość dla wywołań funkcji zanim zostaną rozbite pionowo
fn_call_width = 80

# Agresywne łączenie elementów sterujących (np. if let)
combine_control_expr = true

# Usuwa zbędne puste linie, które rustfmt czasem zostawia
blank_lines_upper_bound = 1

# ---- INNE ----

hex_literal_case = "Upper"
```

### 004: `./ARCHITECTURE.md`

```markdown
# 🏛️ Architektura i Konwencje Nazewnicze `cad-cs`

Poniższy dokument stanowi legendę i klucz symboli używanych w całym ekosystemie struktur `Cs<N>` oraz operacji matematycznych. Przestrzeganie tej konwencji pozwala na natychmiastowe zrozumienie typu operacji po samej nazwie metody.

## 🧭 Ćwiartki i oktanty

Zmienna `q` (od ang. _quadrant_) określa numer ćwiartki (w 2D) lub oktantu (w 3D) w układzie kartezjańskim.

- **2D (Płaszczyzna XY):** Wartości od `1` do `4`
  - `1`: (+X, +Y) | `2`: (-X, +Y) | `3`: (-X, -Y) | `4`: (+X, -Y)
- **3D (Przestrzeń XYZ):** Wartości od `1` do `8`
  - Górna półprzestrzeń (+Z): `1` do `4` (jak w 2D)
  - Dolna półprzestrzeń (-Z): `5`: (+X, +Y, -Z) | `6`: (-X, +Y, -Z) | `7`: (-X, -Y, -Z) | `8`: (+X, -Y, -Z)

### Wizualizacja znakowa (`q_sign`)

Alternatywna reprezentacja logiczna dla ćwiartki/oktantu, zwracająca tablicę znaków kierunkowych.

- **2D:** `["+", "-"]` (np. dla punktu `-1.0, 2.0` → `q=2`, `q_sign=["-", "+"]`)
- **3D:** `["+", "-", "+"]` (np. dla punktu `-1.0, -2.0, 3.0` → `q=3`, `q_sign=["-", "-", "+"]`)

---

## 📐 Typy Współrzędnych i DTO

Sufiksy przy metodach (np. `to_rf_from_xy()`) oraz nazwy obiektów DTO (Domain Transfer Objects) bezpośrednio wskazują na rodzaj układu.

| Symbol    | Klasa DTO            | Opis Układu                                                                                   |
| :-------- | :------------------- | :-------------------------------------------------------------------------------------------- |
| **`xy`**  | `CoordsXy`           | Współrzędne 2D kartezjańskie (x,y) na płaszczyźnie XY lub lub wektor (x,y) lub płaszczyzna XY |
| **`xz`**  |                      | Współrzędne 2D kartezjańskie (x,z) na płaszczyźnie XZ lub lub wektor (x,z) lub płaszczyzna XZ |
| **`yz`**  |                      | Współrzędne 2D kartezjańskie (y,z) na płaszczyźnie YZ lub lub wektor (y,z) lub płaszczyzna YZ |
| **`rf`**  | `CoordsPolar`        | Współrzędne 2D biegunowe/cylindryczne (R, Φ)                                                  |
| **`rfx`** | `CoordsCylindricalX` | Współrzędne 3D cylindryczne względem osi X (R_yz, Φ, X)                                       |
| **`rfy`** | `CoordsCylindricalY` | Współrzędne 3D cylindryczne względem osi Y (R_xz, Φ, Y)                                       |
| **`rfz`** | `CoordsCylindricalZ` | Współrzędne 3D cylindryczne względem osi Z (R_xy, Φ, Z)                                       |
| **`xyz`** | `CoordsXyz`          | Współrzędne 3D kartezjańskie (x,y,z) / Przestrzeń XYZ                                         |
| **`rft`** | `CoordsSpherical`    | Współrzędne 3D sferyczne (R, Φ, Θ)                                                            |

---

## 🔄 Kąty (Azymuty i Inklinacje)

Litery używane do oznaczania kątów różnią się w zależności od ich funkcji w przestrzeni:

- **`f` (Φ / Azymut):** Kąt obrotu w płaszczyźnie 2D
  - w płaszczyźnie XY/XZ/YZ lub
  - w układach sferycznych RΦΘ lub
  - w ukłądach cylindrycznych RΦX/RΦY/RΦZ.
- **`t` (Θ / Inklinacja):** Kąt odchylenia
  - (np. w układzie sferycznym od osi Z/Y/X).

**Klucze metod konwersji kątowych:**

- `y_x` (czyli `f_y_x`) → $\arctan(\frac{y}{x})$ – azymut w płaszczyźnie XY
- `z_x` (czyli `f_z_x`) → $\arctan(\frac{z}{x})$ – azymut w płaszczyźnie XZ
- `z_y` (czyli `f_z_y`) → $\arctan(\frac{z}{y})$ – azymut w płaszczyźnie YZ
- `x_rxyz` (czyli `t_xr`) → $\arccos(\frac{x}{rxyz})$ – inklinacja względem osi X
- `y_rxyz` (czyli `t_yr`) → $\arccos(\frac{y}{rxyz})$ – inklinacja względem osi Y
- `z_rxyz` (czyli `t_z_r`) → $\arccos(\frac{z}{rxyz})$ – inklinacja względem osi Z

---

## 📏 Promienie, Długości i Projekcje

- **`{x, y, z}`** – Bazowe współrzędne 2D/3D kartezjańskie.
- **`r`** – Uniwersalny promień / długość wektora.
- **`rxy`** – Długość rzutu wektora na płaszczyznę 2D XY.
- **`rxz`** – Długość rzutu wektora na płaszczyznę 2D XZ.
- **`ryz`** – Długość rzutu wektora na płaszczyznę 2D YZ.
- **`rxyz`** – Pełna długość wektora w przestrzeni 3D.

---

## 🛠️ Podstawowe Operacje Wektorowe

Biblioteka implementuje matematykę przestrzenną zgodną z nazewnictwem algebraicznym:

- `add`, `sub` – Dodawanie i odejmowanie wektorów (Translacja).
- `dot` – Iloczyn skalarny (Dot product). Zwraca wartość `f64`.
- `cross` – Iloczyn wektorowy (Tylko 3D). Zwraca nowy wektor ortogonalny.
- `perp` – Wektor prostopadły w lewo/CCW (Tylko 2D).
- `angle_between` – Zwraca kąt między dwoma wektorami.
- `normalize_r<plaszczyzna>_projection` – Normalizuje wektor w taki sposób, aby jego rzut na daną płaszczyznę (np. XY) miał długość 1.0.

---

## ⚖️ Fundamenty Numeryczne

Biblioteka opiera się na stałej `EPSILON_SPATIAL = 1e-9`.
Wszelkie porównania logiczne (równość punktów, zerowanie wektorów) MUSZĄ przechodzić przez funkcje `is_zero` lub `is_equal`.
Wartości kątowe są zawsze procesowane w `f64` (radiany), a konwersja na stopnie/DMS służy wyłącznie do prezentacji lub I/O.

---

## 📐 Rygor Wymiarowości (`Cs<N>`)

Projekt `cad-cs` świadomie rezygnuje z obsługi geometrii wielowymiarowej (N > 3).

- **Cs2 (N=2):** Reprezentacja płaszczyzny XY.
- **Cs3 (N=3):** Reprezentacja przestrzeni XYZ.

Ograniczenie to jest wymuszone na poziomie kompilacji poprzez trait `Dim`. Próba użycia struktur dla innych wartości `N` skutkuje błędem kompilacji, co gwarantuje stabilność algorytmów geometrycznych.

### Inicjalizacja Makrowa

W celu uproszczenia składni i zapewnienia bezpieczeństwa typów, stosowane są makra:

- `cs!`: Wymusza podanie dokładnie 2 lub 3 argumentów, automatycznie rzutując je na `f64`.
- `dms! / dms_angle!`: Standardowe wejście dla danych geodezyjnych/kątowych, izolujące logikę przeliczeń DMS -> Radiany od reszty systemu.

---

## ⌨️ Ergonomia Programistyczna (Shorthand API)

Biblioteka udostępnia globalne funkcje pomocnicze w module `angle`, które skracają proces inicjalizacji typów opakowanych.

- Zamiast pełnej ścieżki `Angle::from_deg(90.0)`, programista może użyć bezpośredniej funkcji `deg(90.0)`.
- Wszystkie funkcje pomocnicze są oznaczone jako `#[inline]`, co eliminuje narzut wywołania funkcji (zero-cost abstraction).
- Wykorzystanie `#[rustfmt::skip]` przy tych funkcjach jest świadomym zabiegiem mającym na celu utrzymanie maksymalnej gęstości pionowej kodu API.

---

## ➗ Reprezentacja Wymierna i Aproksymacja

W celu poprawy czytelności danych wyjściowych (np. w logach i interfejsach użytkownika), biblioteka oferuje mechanizm konwersji liczb zmiennoprzecinkowych na ułamki zwykłe.

- **Algorytm:** Wykorzystujemy ułamki łańcuchowe, co pozwala na znalezienie najlepszego przybliżenia wymiernego dla danej liczby `f64`.
- **Precyzja:** Proces aproksymacji jest sterowany przez jądro `tolerance`. Gdy różnica między wartością a ułamkiem spadnie poniżej `EPSILON_SPATIAL`, algorytm kończy pracę.
- **Limity:** Mianownik jest ograniczony do wartości 1 000 000, co zapobiega generowaniu skomplikowanych ułamków dla liczb zaszumionych numerycznie.

---

## 📦 Modele Koordynacji (DTO)

Biblioteka separuje surowe obliczenia na `Cs<N>` od struktur wejściowych/wyjściowych (DTO).

- **Separacja:** Struktury w `model.rs` służą do czytelnej inicjalizacji danych i komunikacji z zewnętrznymi modułami (np. UI lub bazą danych).
- **Konwersja:** Każda struktura DTO posiada implementację `Into<Cs<N>>`, co pozwala na bezproblemowe przejście do wydajnych operacji wektorowych.
- **DMS Standard:** Przyjęto system `Nz90Ex0`, gdzie szerokość geograficzna (N/S) jest procesowana przed długością (E/W), co jest zgodne ze standardami ISO 6709.

---

## 📐 Płaszczyzny Robocze i Układy Cylindryczne

Biblioteka `cad-cs` wspiera pełną ortogonalność układów współrzędnych. Poza standardową płaszczyzną XY, zaimplementowano natywne wsparcie dla płaszczyzn XZ i YZ:

- **XY / Oś Z:** Standardowa orientacja "z góry". Układ cylindryczny bazuje na promieniu `r_d2`.
- **XZ / Oś Y:** Orientacja "z boku" (front/back). Układ cylindryczny bazuje na promieniu `r_d2`.
- **YZ / Oś X:** Orientacja "z boku" (left/right). Układ cylindryczny bazuje na promieniu `r_d2`.

Taka struktura pozwala na bezpośrednie rzutowanie punktów 3D na dowolną z trzech głównych płaszczyzn kartezjańskich bez konieczności ręcznej zamiany składowych wektora przed obliczeniami biegunowymi.

---

## 🔡 Semantyka Znaków (AbstractSignStrExt)

Biblioteka mapuje wartości liczbowe na reprezentacje tekstowe zgodnie ze standardami inżynieryjnymi i geodezyjnymi:

- **Matematyka Ogólna:** Wartości `>= 0` otrzymują znak `+`.
- **Geodezja (Szerokość):** Wartości `>= 0` mapowane są na `N` (Północ), wartości `< 0` na `S` (Południe).
- **Geodezja (Długość):** Wartości `>= 0` mapowane są na `E` (Wschód), wartości `< 0` na `W` (Zachód).

Implementacja oparta na traitach rozszerzających (`Extension Traits`) pozwala na wywoływanie tych metod bezpośrednio na typach prymitywnych (`f64`, `i8`, `i16`), co upraszcza kodowanie warstwy UI i logowania.

---

## 🔄 Rdzeń Konwersji (Core)

Struktura `core/` zarządza przepływem danych między modelami bezpiecznymi (DTO) a jądrem obliczeniowym `Cs<N>`.

- **Wzorzec Shorthand:** Metody `new_as_..._from_...` pozwalają na używanie struktury `Cs<N>` jako tymczasowego kontenera na parametry (np. R, Φ), co redukuje potrzebę tworzenia wielu małych alokacji na stosie przed konwersją na wektor końcowy.
- **Efektywność:** Wszystkie konwersje trygonometryczne wykorzystują metodę `sin_cos()`, co na większości nowoczesnych procesorów pozwala na obliczenie obu wartości w jednym cyklu jednostki FPU.

### Orientacja w rzutach bocznych

W celu zachowania spójności z prawoskrętnym układem współrzędnych, definicje kątów w układach cylindrycznych są następujące:

- **Oś X (YZ):** Kąt zero leży na dodatniej osi Y, rośnie w stronę dodatniej osi Z.
- **Oś Y (XZ):** Kąt zero leży na dodatniej osi X, rośnie w stronę dodatniej osi Z.
- **Oś Z (XY):** Kąt zero leży na dodatniej osi X, rośnie w stronę dodatniej osi Y.

Wszystkie operacje bazują na strukturze tablicowej, co pozwala na optymalizację pętli przez kompilator (unrolling).

---

## 🧮 Operacje Wektorowe i Norma

Wszystkie operacje bazują na strukturze tablicowej, co pozwala na optymalizację pętli przez kompilator (unrolling).

- **Dot Product:** Bazowy mechanizm dla rzutowania i obliczeń kątowych.
- **2D Cross:** Realizowany jako wyznacznik macierzy 2x2, zwraca skalar reprezentujący zorientowane pole powierzchni.
- **3D Cross:** Zwraca wektor prostopadły, kluczowy dla obliczeń normalnych powierzchni w CAD.
- **Normalizacja:** Implementujemy `normalize_r_projection`, która chroni przed błędem dzielenia przez zero (Division by Zero) dzięki integracji z `tolerance::is_zero`.

## 📐 Algebra Wektorowa (Generic Math)

Moduł `math.rs` implementuje operacje wektorowe przy użyciu stałych generycznych (`const generics`).

- **Wspólna Implementacja:** Dzięki ograniczeniu `where Cs<N>: Dim`, metody takie jak `dot()`, `add()` czy `normalize_r_projection()` są definiowane raz dla wszystkich wspieranych wymiarów.
- **Wykorzystanie tablic:** Operacje bazują na `std::array::from_fn`, co pozwala kompilatorowi na agresywną optymalizację pętli i potencjalną automatyczną wektoryzację.
- **Przeciążanie Operatorów:** Biblioteka implementuje standardowe traity z `std::ops`, umożliwiając intuicyjny zapis równań matematycznych (`a + b * 2.0`).

## 🗺️ Geodezja i Rzuty 2D

Moduł `math/d2.rs` wykracza poza standardową geometrię euklidesową, wprowadzając funkcje dedykowane dla systemów informacji geograficznej (GIS):

- **Model ECEF (Earth-Centered, Earth-Fixed):** Metoda `to_ecef_from_rad_sn_we` pozwala na bezpośrednią konwersję współrzędnych sferycznych (szerokość/długość) na trójwymiarowy wektor kartezjański, co stanowi pomost między danymi GPS a silnikiem CAD.
- **Dualizm Azymutalny:** Biblioteka rozróżnia azymut matematyczny (mierzony od osi X) od azymutu geodezyjnego (mierzony od osi Y/Północy), co eliminuje błędy interpretacji danych wejściowych.
- **Analiza Kwadrantowa:** Wbudowana obsługa ćwiartek i znaków kierunkowych (`q()`, `q_sign()`) ułatwia logikę decyzyjną w algorytmach przycinania i nawigacji.

## 🌐 Geometria Przestrzenna i Geodezja (3D)

Moduł `math/d3.rs` stanowi fundament dla zaawansowanych operacji CAD i GIS:

- **Analiza rzutowa:** System natywnie wspiera obliczenia promieni (`rxy`, `rxz`, `ryz`) oraz azymutów na trzech głównych płaszczyznach kartezjańskich. Pozwala to na płynne przechodzenie między widokami roboczymi (góra/front/bok).
- **Normalizacja rzutowa:** Unikalne funkcje `normalize_*_projection` umożliwiają operacje na wektorach kierunkowych rzutowanych na płaszczyzny, co jest kluczowe w algorytmach oświetlenia i rzutowania prostopadłego.
- **Model ECEF/DMS:** Pełna implementacja dwukierunkowej konwersji między kartezjańskim układem odśrodkowym (ECEF) a geodezyjnym formatem DMS (Stopnie, Minuty, Sekundy). System uwzględnia osobliwość numeryczną w jądrze Ziemi (r=0).
- **Podział Oktantowy:** System `q()` rozszerza analizę ćwiartek do przestrzeni 3D, identyfikując jeden z ośmiu obszarów przestrzeni.

---

## 📝 Prezentacja i Diagnostyka (Debug Print)

Moduł `debug_print.rs` separuje logikę wyświetlania od matematycznego jądra, implementując traity rozszerzające `AbstractHelperCs2` i `AbstractHelperCs3`.

- **Wizualizacja Układów:** Każdy typ współrzędnych posiada unikalny identyfikator emoji, co ułatwia analizę logów w złożonych procesach konwersji (np. z rzutu walcowego na sferyczny).
- **Semantyka DMS:** Wyświetlanie współrzędnych geograficznych naśladuje standardowe interfejsy GIS, wykorzystując zera wiodące dla minut i sekund oraz automatyczne mapowanie znaków na litery kierunkowe (N, S, E, W).
- **Elastyczność Kątowa:** Dzięki integracji z `AngleFmt`, diagnostyka może odbywać się w radianach, stopniach lub ułamkach PI, zależnie od kontekstu debugowanego problemu.

---

## 🚪 Architektura API (Facade Pattern)

Mimo głębokiego i rygorystycznego podziału wewnętrznego plików (np. separacja `math/d2.rs` i `core/d3.rs`), biblioteka stosuje wzorzec Fasady (Facade) w głównym pliku `cs.rs`.

- **Spłaszczenie (Flattening):** Za pomocą instrukcji `pub use` krytyczne struktury (`Cs`, `Cs2`, moduły DTO) są wyciągane na najwyższy poziom modułu. Użytkownik wywołuje `cad_cs::Cs2`, nie wiedząc o istnieniu `cad_cs::cs::model::Cs2`.
- **Niejawne Ładowanie Implementacji:** Ze względu na specyfikę kompilatora Rusta, metody przypięte przez `impl Cs<N>` w podmodułach (np. z `math.rs`) są automatycznie dostępne dla każdego obiektu `Cs<N>` bez konieczności ich ręcznego importowania przez użytkownika końcowego.

---

## 🗂️ Top-Level Architektura (libs.rs)

Biblioteka została podzielona na cztery fundamentalne, ortogonalne filary, zdefiniowane w `src/libs.rs`:

- **`tolerance`:** Baza całego systemu. Zapewnia bezpieczne porównywanie wartości zmiennoprzecinkowych `f64`. Pozostałe moduły bezwzględnie na nim polegają.
- **`frac` i `angle`:** Moduły pomocnicze, izolujące logikę specyficzną dla ułamków oraz jednostek miar kątowych (Type Safety).
- **`cs` (Coordinate System):** Główne jądro wektorowe i geodezyjne (CAD/GIS). Konsumuje usługi pozostałych trzech modułów w celu dostarczenia bezpiecznego interfejsu numerycznego.

---

## 🚪 Punkt Wejścia (Crate Root)

Plik `src/lib.rs` jest celowo zredukowany do absolutnego minimum.

- **Delegacja Logiki:** Cała architektura i logika domenowa została wyeksportowana do katalogu `src/libs/` oraz zdefiniowana w `src/libs.rs`.
- **Czystość Przestrzeni Nazw:** Zabezpiecza to główny obszar roboczy przed bałaganem i ułatwia ewentualne wydzielenie części kodu do osobnych crate'ów (np. w przypadku monorepo workspace) w przyszłości.

---

## 💡 Wzorce Użycia (Usage Patterns)

Biblioteka `cad-cs` promuje dwa główne wzorce inicjalizacji i transferu danych, co zostało udokumentowane w katalogu `examples/`:

1. **Szybka Inicjalizacja (Zero-cost):** Użycie makr `cs!` oraz `dms!` do bezpośredniego wstrzykiwania surowych danych numerycznych w postaci wektorów. Zoptymalizowane pod kątem wydajności.
2. **Bezpieczna Inicjalizacja (Type-safe):** Wykorzystanie struktur DTO (np. `CoordsSpherical`) z implementacją traitów `Into/From`. Zabezpiecza przed pomyleniem kolejności parametrów wejściowych (np. R z Azymutem).

---

```

### 005: `./AUTHORS.md`

```markdown

```

### 006: `./CHANGELOG.md`

```markdown

```

### 007: `./CHEATSHEET.md`

```markdown
# 🛠️ Cad-Cs: Workflow & Cheatsheet

Ten plik zawiera osobiste notatki, triki i skróty przyspieszające pracę nad projektem w środowisku VS Code.

---

## 🔍 VS Code: Precyzyjne Wyszukiwanie i Zamiana (Search & Replace)

Kiedy robisz globalny refaktor (np. zmianę nazw struktur DTO lub metod), użyj poniższego filtru, aby uniknąć przypadkowej modyfikacji logów, plików wygenerowanych w `.history/` czy folderu `target/`.

Wklej poniższą linijkę w pole **"files to include"** (pliki do uwzględnienia) w panelu globalnego wyszukiwania (`Ctrl + Shift + F`):

```text
./src/**/*.rs, ./examples/**/*.rs, ./ARCHITECTURE.md, ./TODO.md, ./ROADMAP.md

```

### 008: `./Cargo.toml`

```toml
[package]
name = "cad-cs"
version = "0.1.0-beta.1"
authors = ["Jan Roman Cisowski „j-Cis”"]
edition = "2024"
rust-version = "1.94.0"
description = "Calculations on Coordinate Systems (2D/3D geometry, vectors, transformations)"
license = "MIT OR Apache-2.0"
readme = "README.md"
repository = "https://github.com/j-Cis/cad-cs"
documentation = "https://docs.rs/cad-cs"

keywords = ["geometry", "math", "coordinates", "cad", "vector"]
categories = ["mathematics", "science","science::geo", "algorithms","graphics"]

exclude = [
	".history/",
	".err/",
	".github/",
	".vscode/",
	".temp/",
	".rustfmt.toml",
	"Makefile.toml",
	"TODO.md",
	"ROADMAP.md",
	"AUTHORS.md",
	"CHANGELOG.md",
	"CHEATSHEET.md",
	".gitignore",
	".gitattributes"
]

resolver = "3"

[package.metadata.cargo]
edition = "2024"

[dependencies]

[profile.release]
lto = true          # Kompilator optymalizuje kod na poziomie całego projektu
codegen-units = 1   # Wolniejsza kompilacja, ale szybszy kod wynikowy
panic = "abort"     # (Opcjonalnie) Mniejsze binarki, brak odwijania stosu przy błędach

[package.metadata.docs.rs]
all-features = true      # Dokumentuje wszystko, co zdefiniowaliśmy w [features]
rustdoc-args = ["--cfg", "docsrs"]

# ==========================================
# Globalna konfiguracja lintów (Analiza kodu)
# ==========================================
[lints.rust]
# Kategorycznie zabraniamy używania bloków `unsafe` w całym projekcie
unsafe_code = "forbid"
# Ostrzegamy o nieużywanych importach, zmiennych i funkcjach
# unused = "warn"
#
[lints.clippy]
# Włączamy surowsze reguły, ale jako ostrzeżenia (nie zepsują kompilacji)
# pedantic = "warn"
# Możemy tu też wyciszyć globalnie to, co nas irytuje (opcjonalnie):
too_many_arguments = "allow"
```

### 009: `./Makefile.toml`

```toml
[config]
skip_core_tasks = true

# ====================================================
# 🗃️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗃️
# 🗃️🗂️                                           🗂️🗃️
# 🗃️🗂️            USUWANIE FOLDERÓW              🗂️🗃️ 
# 🗃️🗂️                                           🗂️🗃️
# 🗃️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗂️🗃️
# ====================================================

[tasks.clear-contents-of-err-folder-under-prompt]
description = "Czyści zawartość folderu .prompt\\.err, ale zachowuje sam katalog"
command = "powershell"
args = [
	"-Command", 
	"if (Test-Path '.prompt\\.err\\*') { Remove-Item -Path '.prompt\\.err\\*' -Recurse -Force }; Write-Host 'Folder .prompt\\.err zostal wyczyszczony.'"
]

[tasks.ensure-prompt-and-err-folders-exist]
description = "Przygotowanie folderu .prompt\\.err"
command = "powershell"
args = [
	"-Command",
	"if (-Not (Test-Path .prompt\\.err)) { New-Item -ItemType Directory -Path .prompt\\.err | Out-Null }"
]

[tasks.clear-contents-of-src-folder-under-prompt]
description = "Czyści zawartość folderu .prompt\\.src, ale zachowuje sam katalog"
command = "powershell"
args = [
	"-Command", 
	"if (Test-Path '.prompt\\.src\\*') { Remove-Item -Path '.prompt\\.src\\*' -Recurse -Force }; Write-Host 'Folder .prompt\\.src zostal wyczyszczony.'"
]

[tasks.ensure-prompt-and-src-folders-exist]
description = "Przygotowanie folderu .prompt\\.src"
command = "powershell"
args = [
	"-Command",
	"if (-Not (Test-Path .prompt\\.src)) { New-Item -ItemType Directory -Path .prompt\\.src | Out-Null }"
]

[tasks.clear-contents-of-helpers-folder-under-prompt]
description = "Czyści zawartość folderu .prompt\\.helpers, ale zachowuje sam katalog"
command = "powershell"
args = [
	"-Command", 
	"if (Test-Path '.prompt\\.helpers\\*') { Remove-Item -Path '.prompt\\.helpers\\*' -Recurse -Force }; Write-Host 'Folder .prompt\\.helpers zostal wyczyszczony.'"
]

[tasks.ensure-prompt-and-helpers-folders-exist]
description = "Przygotowanie folderu .prompt\\.helpers"
command = "powershell"
args = [
	"-Command",
	"if (-Not (Test-Path .prompt\\.helpers)) { New-Item -ItemType Directory -Path .prompt\\.helpers | Out-Null }"
]

# ====================================================
# 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
# 🟩📑                                          📑🟩
# 🟩📑           GENEROWANIE PLIKÓW             📑🟩
# 🟩📑                                          📑🟩
# 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
# ====================================================

[tasks.snapshot-filetree-includes]
description = "Generuje snapshot struktury istotnych plików projektu"
command = "cargo"
args = [
	"plot", "-o", "./.prompt/.src/", 
	"-p", "./target/+", "-p", "!./target/", 
	"-p", "./.git/+", "-p", "!./.git/", 
	"-x", "-v", "grid", "--save-address", "-b", "-a", "--lang", "en"
]

[tasks.snapshot-filetree-excludes]
description = "Generuje snapshot struktury nie-istotnych plików projektu"
command = "cargo"
args = [
	"plot", "-o", "./.prompt/.src/", 
	"-p", "./target/+", "-p", "!./target/", 
	"-p", "./.git/+", "-p", "!./.git/", 
	"-m", "-v", "grid", "--save-address", "-b", "-a", "--lang", "en"
]

[tasks.snapshot-total-source-code]
description = "Generuje snapshot istotnych plików kodu źródłowego"
command = "cargo"
args = [
	"plot", "-o", "./.prompt/.src/", 
	"-p", "./target/+", "-p", "!./target/", 
	"-p", "./.git/+", "-p", "!./.git/", 
	"-p", "./.github/+", "-p", "!./.github/", 
	"-p", "./.vscode/+", "-p", "!./.vscode/", 
	"-p", "./.prompt/.src/+", "-p", "!./.prompt/.src/", 
	"-p", "./.prompt/.err/+", "-p", "!./.prompt/.err/", 
	"-p", "./LICENSE-APACHE", "-p", "./LICENSE-MIT", "-p", "*.lock", 
	"-p", ".gitattributes", "-p", ".gitignore", 
	"-x", "-v", "grid", "--save-archive", "-b", "-a", "--lang", "en"
]

# ----------------------------------------------------------------------------------------------------------------------------------------------------

# ----------------------------------------------------------------------------------------------------------------------------------------------------


[tasks.fmt-c2-cargo]
description = "Automatyczna naprawa błędów rustc"
ignore_errors = true
command = "powershell"
args = [
	"-Command", 
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Write-Host ' 👉🏼 2/7: 📖 Naprawa rustc (cargo fix)...'; cargo fix --allow-dirty --allow-no-vcs --all-targets --all-features *> .prompt/.err/c2_cargo_fix.log"
]

[tasks.fmt-c3-clippy]
description = "Automatyczna naprawa sugestii Clippy"
ignore_errors = true
command = "powershell"
args = [
	"-Command", 
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Write-Host ' 👉🏼3/7: 📖 Naprawa lintera (clippy --fix)...'; cargo clippy --fix --allow-dirty --all-targets --all-features *> .prompt/.err/c3_clippy_fix.log"
]

[tasks.fmt-c4-fmt-nightly-by-rustfmt-file-config]
description = "Standardowe formatowanie cargo +nightly fmt"
ignore_errors = true
command = "powershell"
args = [
	"-Command", 
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Write-Host ' 👉🏼 4/7: 📖 Formatowanie kodu (cargo +nightly fmt)...'; cargo +nightly fmt *> .prompt/.err/c4_cargo_fmt.log"
]

[tasks.fmt-c5-diag-package-list]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command", 
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Write-Host ' 👉🏼 5/7: 📖 Zrzut listy plików paczki (cargo package)...'; cargo package --list --allow-dirty *> .prompt/.err/c5_package_list.log"
]

[tasks.fmt-c6-diag-verify]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command", 
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Write-Host ' 👉🏼 6/7: 📖 Weryfikacja struktury (cargo verify-project)...'; cargo verify-project *> .prompt/.err/c6_verify_project.log"
]

[tasks.fmt-c7-diag-audit]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command", 
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Write-Host ' 👉🏼 7/7: 📖 Audyt bezpieczeństwa (cargo audit)...'; cargo audit *> .prompt/.err/c7_security_audit.log"
]

# ----------------------------------------------------------------------------------------------------------------------------------------------------

[tasks.err-diag-o0-fmt]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command",
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; cargo +nightly fmt -- --check *> .prompt/.err/o0_fmt_check.log"
]

[tasks.err-diag-o1-check]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command",
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; cargo check --message-format short *> .prompt/.err/o1_check.log"
]

[tasks.err-diag-o2-examples]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command",
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; cargo check --examples *> .prompt/.err/o2_check_examples.log"
]

[tasks.err-diag-o3-clippy-basic]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command",
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; cargo clippy *> .prompt/.err/o3_clippy.log"
]

[tasks.err-diag-o4-clippy-strict]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command",
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; cargo clippy --all-targets --all-features -- -D warnings *> .prompt/.err/o4_clippy_strict.log"
]

[tasks.err-diag-o5-release-build]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command",
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; cargo build --release *> .prompt/.err/o5_build_release.log"
]

[tasks.err-diag-o6-doc-gen]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command",
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; cargo doc --no-deps --document-private-items *> .prompt/.err/o6_doc_check.log"
]

[tasks.err-diag-o7-test-compile]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command",
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; cargo test --no-run *> .prompt/.err/o7_test_compile.log"
]

[tasks.err-diag-o8-test-run]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command",
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; cargo test --verbose *> .prompt/.err/o8_test_run.log"
]

[tasks.err-diag-o9-test-doc]
dependencies = ["ensure-prompt-and-err-folders-exist"]
ignore_errors = true
command = "powershell"
args = [
	"-Command",
	"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; cargo test --doc *> .prompt/.err/o9_test_doc.log"
]


# ====================================================
# ------ KOMENDY JEDNOSTKOWE :
# ------
# ------ ------ GENEROWANIE DOKUMENTACJI
# ====================================================

[tasks.doc-full]
description = "Generuje najobszerniejszą dokumentację (prywatne API, wszystkie features i targety) i otwiera w przeglądarce"
command = "cargo"
args = [
    "doc",
    "--no-deps",
    "--document-private-items",
    "--all-features",
    "--examples",
    "--open"
]

# ====================================================
# 🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙
# 🆙                                               🆙
# 🆙               KONTROLA STANU                  🆙 
# 🆙            PUNKTU PRZYWRACANIA                🆙 
# 🆙                                               🆙
# 🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙
# ====================================================

# [tasks.fmt-c0-pre-op-snapshot-restore-point]
# description = "Tworzy bezpieczny commit, jeśli są niezatwierdzone zmiany"
# command = "powershell"
# args = [
# 	"-Command",
# 	"Write-Host '📦 Zabezpieczanie pracy...'; if (git status --porcelain) { git add .; git commit -m 'chore: pre-operation backup'; Write-Host '✅ Zmiany zapisane w Gicie.' } else { Write-Host 'ℹ️ Brak zmian do zapisu.' }"
# ]


[tasks.fmt-c0-pre-op-snapshot-restore-point-draft]
description = "Wstępny snapshot (Zrzut obecnego stanu + prośba o zapis IDE)"
command = "powershell"
args = [
    "-Command",
    """
    $OutputEncoding = [System.Text.Encoding]::UTF8; [Console]::OutputEncoding = [System.Text.Encoding]::UTF8;
    Write-Host '📦 Zabezpieczanie obecnego stanu dysku (Wstępny zrzut)...';
    
    git add .;
    if (git status --porcelain) { 
        git commit -m 'chore: pre-operation backup (stan wstępny)'; 
        Write-Host '✔️ Wstępny commit wykonany.' -ForegroundColor Green;
    } else { 
        Write-Host 'ℹ️ Brak zmian na dysku do wstępnego commita.' -ForegroundColor DarkGray;
    }

    Write-Host "`n`n";
    Write-Host '=====================================================' -ForegroundColor Red;
    Write-Host ' ⚠️  UWAGA: ZAPISZ PLIKI W EDYTORZE!  ⚠️ ' -ForegroundColor Yellow;
    Write-Host '=====================================================' -ForegroundColor Red;
    Write-Host '1. Wciśnij teraz w VS Code skrót: Ctrl + K, a potem S' -ForegroundColor Cyan;
    Write-Host '2. Kiedy kropki na zakładkach znikną, uruchom główny snapshot:' -ForegroundColor White;
    Write-Host '👉 cargo make fmt-c0-pre-op-snapshot-restore-point' -ForegroundColor Magenta;
    Write-Host "`n`n";
    """
]

[tasks.fmt-c0-pre-op-snapshot-restore-point]
description = "Główny snapshot (Zabezpiecza stan plików w Gicie)"
command = "powershell"
args = [
    "-Command",
    """
    $OutputEncoding = [System.Text.Encoding]::UTF8; [Console]::OutputEncoding = [System.Text.Encoding]::UTF8;
    Write-Host '📦 Weryfikacja i zabezpieczanie plików (Główny zrzut)...';
    
    git add .;
    if (git status --porcelain) { 
        git commit -m 'chore: pre-operation backup (stan finalny)'; 
        Write-Host '✔️ Snapshot gotowy. Pliki zabezpieczone w Gicie!' -ForegroundColor Green;
    } else { 
        Write-Host 'ℹ️ Brak zmian do zapisu. Wszystko jest zsynchronizowane.' -ForegroundColor DarkGray;
    }
    """
]

# ====================================================
# ------ KOMENDY JEDNOSTKOWE :
# ------
# ------ ------ WALKA Z BIAŁYMI ZNAKAMI
# ====================================================

[tasks.fmt-c1-fmt-whitespace]
description = "Usuwa puste spacje z końców linii (naprawa błędu rustfmt)"
command = "powershell"
args = [
	"-Command",
	"Write-Host '🧹 Sprzątanie spacji...'; Get-ChildItem -Recurse *.rs | ForEach-Object { $content = Get-Content $_; $content | ForEach-Object { $_.TrimEnd() } | Set-Content $_ }; Write-Host '✅ Pliki .rs są teraz czyste.'"
]

# ====================================================
# 🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙
# 🆙                                               🆙
# 🆙               KONTROLA STANU                  🆙 
# 🆙     ZARZĄDZANIE WERSJONOWANIEM (WORKFLOW)     🆙 
# 🆙                                               🆙
# 🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙🆙
# ====================================================

# ----------------------------------------------------
# A. ZAMKNIĘCIE CYKLU
# ----------------------------------------------------
[tasks.v-finish-dist]
description = "Publikuje stabilną dystrybucję (odcina sufiksy, np. rc.7 -> 0.5.0)"
command = "powershell"
args = ["-Command", "$base = $env:CARGO_MAKE_CRATE_VERSION.Split('-')[0]; cargo set-version $base"]

# ----------------------------------------------------
# B-D. OTWIERANIE NOWEGO CYKLU (Tworzy czyste płótno do pracy)
# ----------------------------------------------------
[tasks.v-start-patch]
description = "Otwiera cykl poprawkowy (np. 0.5.0 -> 0.5.1-dev.1)"
command = "powershell"
args = ["-Command", "$v=$env:CARGO_MAKE_CRATE_VERSION.Split('-')[0].Split('.'); $new_v=\"$($v[0]).$($v[1]).$([int]$v[2]+1)-dev.1\"; cargo set-version $new_v"]

[tasks.v-start-minor]
description = "Otwiera nowy cykl funkcji (np. 0.5.0 -> 0.6.0-dev.1)"
command = "powershell"
args = ["-Command", "$v=$env:CARGO_MAKE_CRATE_VERSION.Split('-')[0].Split('.'); $new_v=\"$($v[0]).$([int]$v[1]+1).0-dev.1\"; cargo set-version $new_v"]

[tasks.v-start-major]
description = "Otwiera nowy cykl fundamentów (np. 0.5.0 -> 1.0.0-dev.1)"
command = "powershell"
args = ["-Command", "$v=$env:CARGO_MAKE_CRATE_VERSION.Split('-')[0].Split('.'); $new_v=\"$([int]$v[0]+1).0.0-dev.1\"; cargo set-version $new_v"]

# ----------------------------------------------------
# E-F. BIEŻĄCA PRACA I AWANSE (Silnik organicznego tworzenia)
# ----------------------------------------------------
[tasks.v-next--point]
description = "Podbija punkt w obecnej fazie prerelease (np. dev.1 -> dev.2)"
command = "cargo"
args = ["set-version", "--bump", "prerelease"]

[tasks.v-next--phase]
description = "Awansuje projekt do kolejnej fazy (dev -> snapshot -> alpha -> beta -> rc)"
command = "powershell"
args = [
    "-Command", 
    """
    $base = $env:CARGO_MAKE_CRATE_VERSION.Split('-')[0];
    $suffix = $env:CARGO_MAKE_CRATE_VERSION.Split('-')[1];
    if (-not $suffix) { Write-Host '❌ Jesteś na stabilnej wersji! Użyj v-start-*, aby zacząć nowy cykl.'; exit 1 }
    
    $current_phase = $suffix.Split('.')[0];
    switch ($current_phase) {
        'dev'      { $next = 'snapshot.1' }
        'snapshot' { $next = 'alpha.1' }
        'alpha'    { $next = 'beta.1' }
        'beta'     { $next = 'rc.1' }
        'rc'       { Write-Host '❌ Jesteś w fazie RC! Użyj v-finish-dist, aby wydać stabilną dystrybucję.'; exit 1 }
        default    { Write-Host \"❌ Nieznana faza: $current_phase\"; exit 1 }
    }
    
    cargo set-version \"$base-$next\";
    Write-Host \"✅ Awansowano z $current_phase na fazę: $($next.Split('.')[0].ToUpper())\" -ForegroundColor Green;
    """
]

# ----------------------------------------------------
# G. TAGOWANIE WERSJI
# ----------------------------------------------------

[tasks.v-add-hashtag]
description = "Commituje zmiany, pobiera hasz i tworzy lokalny tag wersji (bez pusha)"
command = "powershell"
args = [
    "-Command",
    """
    $OutputEncoding = [System.Text.Encoding]::UTF8; [Console]::OutputEncoding = [System.Text.Encoding]::UTF8;
    
    # 1) Odczyt wersji z Cargo.toml
    $ver = $env:CARGO_MAKE_CRATE_VERSION
    Write-Host "`n📦 1/5: Wykryto wersję Cargo.toml: v$ver" -ForegroundColor Cyan;
    
    # 2) git add .
    Write-Host '➕ 2/5: Dodawanie plików do indeksu (git add .)...';
    git add .;
    
    # 3) git commit
    Write-Host '📝 3/5: Tworzenie commitu wydania...';
    if (git status --porcelain) {
        git commit -m "chore: release v$ver";
        Write-Host '✔️ Commit utworzony pomyślnie.' -ForegroundColor Green;
    } else {
        Write-Host 'ℹ️ Repozytorium jest czyste, przypinam tag do aktualnego stanu.' -ForegroundColor DarkGray;
    }
    
    # 4) Pobranie hasza ostatniego commitu
    $hash = git rev-parse --short HEAD
    Write-Host "🔍 4/5: Odczytano hasz commitu: $hash" -ForegroundColor Yellow;
    
    # 5) Utworzenie tagu (składnia: git tag v[wersja] [hasz])
    Write-Host "🏷️ 5/5: Przypinanie tagu v$ver do commitu $hash...";
    if (git tag -l "v$ver") { git tag -d "v$ver" | Out-Null }
    git tag "v$ver" $hash;
    
    Write-Host "`n✅ Wydanie v$ver pomyślnie zakończone - rozważ opublikowanie w rejestrze crates i na GitHubie!" -ForegroundColor Green;
    """
]

# ----------------------------------------------------
# H. PUBLIKOWANIE OTAGOWANEJ WERSJI
# ----------------------------------------------------

[tasks.v--pub-crates]
description = "Publikuje najnowszą wersję paczki w rejestrze crates.io"
command = "cargo"
args = ["publish"]

[tasks.v--pub-github]
description = "Wypycha kod (gałąź main) oraz lokalne tagi na GitHuba"
command = "powershell"
args = [
    "-Command",
    """
    $OutputEncoding = [System.Text.Encoding]::UTF8; [Console]::OutputEncoding = [System.Text.Encoding]::UTF8;
    
    Write-Host "`n🚀 1/2: Wypychanie kodu (gałąź main) na GitHuba..." -ForegroundColor Magenta;
    git push origin main;
    
    Write-Host "`n🏷️ 2/2: Wypychanie tagów na serwer..." -ForegroundColor Cyan;
    git push origin main --tags;
    
    Write-Host "`n✅ Publikacja na GitHubie zakończona sukcesem!" -ForegroundColor Green;
    """
]


# ====================================================
# 🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪
# 🟪                                               🟪
# 🟪             KOMENDY ZBIORCZE                  🟪 
# 🟪                                               🟪
# 🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪🟪
# ====================================================

[tasks.snapshot-code]
description = "Wykonuje kompleksowe snapshote: struktury plików oraz źródłowego kodu"
dependencies = [
	"ensure-prompt-and-src-folders-exist",
	"snapshot-filetree-includes", 
	"snapshot-filetree-excludes",
	"snapshot-total-source-code"
]

[tasks.snapshot-fresh-diag-err]
description = "Czyści folder src i generuje nowe snapshoty (Serial execution)"
run_task = { name = [
	"clear-contents-of-src-folder-under-prompt", 
	"snapshot-code"
], parallel = false }


[tasks.snapshot-diag-err-save]
description = "Uruchamia pełną diagnostykę Cargo"
run_task = { name = [
	"ensure-prompt-and-err-folders-exist",
	"err-diag-o0-fmt",
	"err-diag-o1-check",
	"err-diag-o2-examples",
	"err-diag-o3-clippy-basic",
	"err-diag-o4-clippy-strict",
	"err-diag-o5-release-build",
	"err-diag-o6-doc-gen",
	"err-diag-o7-test-compile",
	"err-diag-o8-test-run",
	"err-diag-o9-test-doc",
	"doc-full"
], parallel = false }


[tasks.snapshot-diag-fmt-safe]
description = "Pełny cykl: Backup -> Spacje -> Clippy Fix -> Cargo Fmt -> Cargo package list -> Cargo Audit"
run_task = { name = [
	"ensure-prompt-and-err-folders-exist",
	"fmt-c0-pre-op-snapshot-restore-point", 
	"fmt-c1-fmt-whitespace", 
	"fmt-c2-cargo",
	"fmt-c3-clippy", 
	"fmt-c4-fmt-nightly-by-rustfmt-file-config",
	"fmt-c5-diag-package-list",
	"fmt-c6-diag-verify",
	"fmt-c7-diag-audit"
], parallel = false }

[tasks.snapshot-fresh-diag]
description = "Czyści folder err i generuje nowe snapshoty (Serial execution)"
run_task = { name = [
	"clear-contents-of-err-folder-under-prompt", 
	"snapshot-diag-fmt-safe",
	"snapshot-diag-err-save"
], parallel = false }

[tasks.info]
description = "KOMPLETNY KONTEKST (Clean -> Fix/Fmt -> Diag -> Snapshot): Przygotowuje idealny stan projektu dla AI"
run_task = { name = [
    "clear-contents-of-err-folder-under-prompt",
    "clear-contents-of-src-folder-under-prompt", 
    "snapshot-diag-fmt-safe", 
    "snapshot-diag-err-save",
    "snapshot-code", 
], parallel = false }

[tasks.info-tofile]
description = "Wykonuje pełny cykl (info) w tle i zapisuje zrzut z konsoli do pliku .prompt/info.log"
category = "Combo"
command = "powershell"
args = [
    "-Command",
    """
    $OutputEncoding = [System.Text.Encoding]::UTF8; [Console]::OutputEncoding = [System.Text.Encoding]::UTF8;
    if (-Not (Test-Path .prompt)) { New-Item -ItemType Directory -Path .prompt | Out-Null }
    
    Write-Host "`n⏳ Uruchamiam pełny cykl (cargo make info)..." -ForegroundColor Cyan;
    Write-Host "📝 Wszystkie logi z konsoli lecą do: .prompt\\info.log" -ForegroundColor DarkGray;
    
    cargo make info *> .\\.prompt\\info.log;
    
    Write-Host "`n✅ Zakończono! Kontekst przygotowany, a przebieg zapisany w .prompt\\info.log`n" -ForegroundColor Green;
    """
]

# ====================================================
# 📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖
# 📖                                               📖
# 📖📖📖📖           P  O  M  O  C          📖📖📖📖 
# 📖                                               📖
# 📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖📖
# ====================================================


[tasks.HELP]
description = "Wyświetla listę wszystkich autorskich komend, opisów i aliasów"
category = "Zarządzanie"
command = "cargo"
args = ["make", "--list-all-steps", "--output-format", "short-description"]

[tasks.help]
description = "Wyświetla statyczną, sformatowaną tabelę ze wszystkimi komendami i aliasami"
category = "Pomoc"
command = "powershell"
args = [
    "-Command",
    '''
    $OutputEncoding = [System.Text.Encoding]::UTF8; [Console]::OutputEncoding = [System.Text.Encoding]::UTF8;
    Write-Host @'

## 📘 **Tabela tematyczna: opis → alias → task**

### 🟦 **A. Usuwanie / przygotowanie folderów**

| Opis | Alias | Task |
|------|--------|-------|
| Czyści `.prompt/.err` | e_clean / f_clean | clear-contents-of-err-folder-under-prompt |
| Tworzy `.prompt/.err` | — | ensure-prompt-and-err-folders-exist |
| Czyści `.prompt/.src` | a_clean | clear-contents-of-src-folder-under-prompt |
| Tworzy `.prompt/.src` | — | ensure-prompt-and-src-folders-exist |
| Czyści `.prompt/.helpers` | — | clear-contents-of-helpers-folder-under-prompt |
| Tworzy `.prompt/.helpers` | — | ensure-prompt-and-helpers-folders-exist |

---

### 🟩 **B. Snapshoty plików z zapisem do `./.prompt/.src/**.md`**

| Opis | Alias | Task |
|------|--------|-------|
| Snapshot istotnych plików | a_f_i | snapshot-filetree-includes |
| Snapshot nieistotnych plików | a_f_e | snapshot-filetree-excludes |
| Snapshot kodu źródłowego | a_doc | snapshot-total-source-code |
| Kompletny snapshot (includes + excludes + source) | a | snapshot-code |
| Czyści src + snapshoty | — | snapshot-fresh-diag-err |

---

### 🟫 **C. Formatowanie i diagnostyka (fmt-c\*) & (err-diag-o\*) z zapisem do `./.prompt/.err/**.log`**

| Opis | Alias | Task |
|------|--------|-------|
| Pełna diagnostyka Cargo | e | snapshot-diag-err-save |
| Pełny cykl: backup → whitespace → fix → fmt → audit | f | snapshot-diag-fmt-safe |
| Czyści err + pełna diagnostyka | — | snapshot-fresh-diag |

#### 🟨 **C1. (zmiany plików) Formatowanie i diagnostyka (fmt-c\*) z zapisem do `./.prompt/.err/**.log`**

| Opis | Alias | Task |
|------|--------|-------|
| PUNKT PRZYWRACANIA 1/2 | b0 | fmt-c0-pre-op-snapshot-restore-point-draft |
| PUNKT PRZYWRACANIA 2/2 | b | fmt-c0-pre-op-snapshot-restore-point |
| Usuwanie spacji końcowych | — | fmt-c1-fmt-whitespace |
| cargo fix | — | fmt-c2-cargo |
| clippy --fix | — | fmt-c3-clippy |
| cargo +nightly fmt | — | fmt-c4-fmt-nightly-by-rustfmt-file-config |
| cargo package --list | — | fmt-c5-diag-package-list |
| cargo verify-project | — | fmt-c6-diag-verify |
| cargo audit | — | fmt-c7-diag-audit |

---

#### 🟧 **C2. (bez zmian) Diagnostyka błędów (err-diag-o\*) z zapisem do `./.prompt/.err/**.log`**

| Opis | Alias | Task |
|------|--------|-------|
| cargo fmt --check | — | err-diag-o0-fmt |
| cargo check | — | err-diag-o1-check |
| cargo check --examples | — | err-diag-o2-examples |
| cargo clippy | — | err-diag-o3-clippy-basic |
| cargo clippy -D warnings | — | err-diag-o4-clippy-strict |
| cargo build --release | — | err-diag-o5-release-build |
| cargo doc | — | err-diag-o6-doc-gen |
| cargo test --no-run | — | err-diag-o7-test-compile |
| cargo test --verbose | — | err-diag-o8-test-run |
| cargo test --doc | — | err-diag-o9-test-doc |

---

### 🟪 **D. Dokumentacja z zapisem do `./target/doc/**/*`**

| Opis | Alias | Task |
|------|--------|-------|
| Pełna dokumentacja + otwarcie | — | doc-full |

---

### 🟫 **E. Wersjonowanie (v-\*)**

> | **Alias** | **Task** | **Purpose** | **Example result** |
> | --- | --- | --- | --- |
> | `v_tag` | `task.v-add-hashtag` | | |
> | `v_tag_pub` | `task.v--pub-crates` | | |
> | `v_tag_git` | `task.v--pub-github` | | |
> | `v_end` | `task.v-finish-dist` | Promote final **RC** to **stable release** | `v0.5.0-rc.7` → `v0.5.0` |
> | `v_new_fix` | `task.v-start-patch` | Bump **patch** and start **dev** prerelease | `v0.5.0` → `v0.5.1-dev.1` |
> | `v_new_ver` | `task.v-start-minor` | Bump **minor** and start **dev** prerelease | `v0.5.0` → `v0.6.0-dev.1` |
> | - | `task.v-start-major` | Bump **major** and start **dev** prerelease | `v0.5.0` → `v1.0.0-dev.1` |
> | `v_num` | `task.v-next--point` | Increment current prerelease counter  ( `dev.N` → `dev.N+1` or `snapshot.N` → `snapshot.N+1` or `alpha.N` → `alpha.N+1` or `beta.N` → `beta.N+1` or `rc.N` → r`c.N+1` ) | `v0.5.0-dev.1` →  `v0.5.0-dev.2` |
> | `v_typ` | `task.v-next--phase` | Advance lifecycle stage  (`dev` → `snapshot` → `alpha` → `beta` → `rc`) | `v0.5.0-dev.3` → `v0.5.0-snapshot.1` |

#### **Zamykanie cyklu**

| Opis | Alias | Task |
|------|--------|-------|
| Stabilna dystrybucja (odcina sufiksy) | v_end | v-finish-dist |

#### **Otwieranie nowego cyklu**

| Opis | Alias | Task |
|------|--------|-------|
| Patch → dev.1 | v_new_fix | v-start-patch |
| Minor → dev.1 | v_new_ver | v-start-minor |
| Major → dev.1 | — | v-start-major |

#### **Praca w cyklu**

| Opis | Alias | Task |
|------|--------|-------|
| Podbija punkt prerelease | v_num | v-next--point |
| Awans fazy prerelease | v_typ | v-next--phase |

#### **Tagowanie i publikacja**

| Opis | Alias | Task |
|------|--------|-------|
| Commit + tag lokalny | v_tag | v-add-hashtag |
| Publikacja crates.io | v_tag_pub | v--pub-crates |
| Push + tagi na GitHub | v_tag_git | v--pub-github |

---

### 🟫 **F. Pomoc**

| Opis | Alias | Task |
|------|--------|-------|
| Lista wszystkich komend | H | HELP |
| Lista posegregowana | h | help |

---

### 🟧 **G. Różne**

| Opis | Alias | Task |
|------|--------|-------|
| Kompilacja wasm32 | — | check-wasm32 |
| Kompilacja wasm64 | — | check-wasm64 |

### 🧠 **H. Mega-Combo (Kontekst dla AI)**

| Opis | Alias | Task |
|------|--------|-------|
| KOMPLETNY KONTEKST (Clean → Fix/Fmt → Diag → Snapshot) | ai | info |
| KOMPLETNY KONTEKST (Clean → Fix/Fmt → Diag → Snapshot) z zapisem do pliku `.\.prompt\info.log` | ai_out | info-tofile |

---
---
'@
    '''
]

[tasks.help-az]
description = "Wyświetla statyczną tabelę komend posortowaną alfabetycznie po oryginalnej komendzie (od strony silnika)"
category = "Pomoc"
command = "powershell"
args = [
    "-Command",
    '''
    $OutputEncoding = [System.Text.Encoding]::UTF8; [Console]::OutputEncoding = [System.Text.Encoding]::UTF8;
    Write-Host @'

## 📘 **Tabela posortowana alfabetycznie po komendzie wykonywanej**

### 🔤 **A. Komendy zaczynające się od `cargo …`**

| # | Oryginalna komenda | Task | Alias |
|---|--------------------|------|--------|
| 1 | cargo add-hashtag (wewn. git → ale główna operacja to cargo set-version) | v-add-hashtag | v_tag |
| 2 | cargo audit | fmt-c7-diag-audit | — |
| 3 | cargo build --release | err-diag-o5-release-build | — |
| 4 | cargo check | err-diag-o1-check | — |
| 5 | cargo check --examples | err-diag-o2-examples | — |
| 6 | cargo check --target wasm32 | check-wasm32 | — |
| 7 | cargo check --target wasm64 | check-wasm64 | — |
| 8 | cargo clippy | err-diag-o3-clippy-basic | — |
| 9 | cargo clippy --fix | fmt-c3-clippy | — |
| 10 | cargo clippy -D warnings | err-diag-o4-clippy-strict | — |
| 11 | cargo doc | err-diag-o6-doc-gen | — |
| 12 | cargo doc --open | doc-full | — |
| 13 | cargo fix | fmt-c2-cargo | — |
| 14 | cargo fmt --check | err-diag-o0-fmt | — |
| 15 | cargo +nightly fmt | fmt-c4-fmt-nightly-by-rustfmt-file-config | — |
| 16 | cargo package --list | fmt-c5-diag-package-list | — |
| 17 | cargo plot (includes) | snapshot-filetree-includes | a_f_i |
| 18 | cargo plot (excludes) | snapshot-filetree-excludes | a_f_e |
| 19 | cargo plot (source code) | snapshot-total-source-code | a_doc |
| 20 | cargo publish | v--pub-crates | v_tag_pub |
| 21 | cargo set-version (finish dist) | v-finish-dist | v_end |
| 22 | cargo set-version (start patch) | v-start-patch | v_new_fix |
| 23 | cargo set-version (start minor) | v-start-minor | v_new_ver |
| 24 | cargo set-version (start major) | v-start-major | — |
| 25 | cargo set-version --bump prerelease | v-next--point | v_num |
| 26 | cargo set-version (phase advance) | v-next--phase | v_typ |
| 27 | cargo test --no-run | err-diag-o7-test-compile | — |
| 28 | cargo test --verbose | err-diag-o8-test-run | — |
| 29 | cargo test --doc | err-diag-o9-test-doc | — |
| 30 | cargo verify-project | fmt-c6-diag-verify | — |

---

### 🔤 **B. Komendy zaczynające się od `git …`**

| # | Oryginalna komenda | Task | Alias |
|---|--------------------|------|--------|
| 31 | git add + commit (snapshot draft) | fmt-c0-pre-op-snapshot-restore-point-draft | b0 |
| 32 | git add + commit (snapshot final) | fmt-c0-pre-op-snapshot-restore-point | b |
| 33 | git add + commit + tag | v-add-hashtag | v_tag |
| 34 | git push origin main | v--pub-github | v_tag_git |
| 35 | git push origin main --tags | v--pub-github | v_tag_git |

---

### 🔤 **C. Komendy systemowe / PowerShell**

| # | Oryginalna komenda | Task | Alias |
|---|--------------------|------|--------|
| 36 | Remove-Item .prompt/.err | clear-contents-of-err-folder-under-prompt | e_clean / f_clean |
| 37 | New-Item .prompt/.err | ensure-prompt-and-err-folders-exist | — |
| 38 | Remove-Item .prompt/.src | clear-contents-of-src-folder-under-prompt | a_clean |
| 39 | New-Item .prompt/.src | ensure-prompt-and-src-folders-exist | — |
| 40 | Remove-Item .prompt/.helpers | clear-contents-of-helpers-folder-under-prompt | — |
| 41 | New-Item .prompt/.helpers | ensure-prompt-and-helpers-folders-exist | — |
| 42 | TrimEnd whitespace in *.rs | fmt-c1-fmt-whitespace | — |

---

### 🔤 **D. Komendy złożone (run_task)** (nie mają jednej komendy — to sekwencje)

| # | Oryginalna komenda | Task | Alias |
|---|--------------------|------|--------|
| 43 | sequence: clear src → snapshot-code | snapshot-fresh-diag-err | — |
| 44 | sequence: clear err → fmt-safe → diag-save | snapshot-fresh-diag | — |
| 45 | sequence: fmt snapshot → whitespace → fix → fmt → audit | snapshot-diag-fmt-safe | f |
| 46 | sequence: all err-diag + doc | snapshot-diag-err-save | e |
| 47 | sequence: includes + excludes + source | snapshot-code | a |
| 48 | sequence: clear err → clear src → fmt-safe → diag-save → snapshot-code | info | ai |
| 49 | sequence: clear err → clear src → fmt-safe → diag-save → snapshot-code; `.\.prompt\info.log`| info-tofile | ai_out |

---
---
'@
    '''
]

# ====================================================
# ✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️
# ✳️                                               ✳️
# ✳️                 RÓŻNE INNE                    ✳️ 
# ✳️                                               ✳️
# ✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️✳️
# ====================================================

[tasks.check-wasm32]
description = "Sprawdza, czy biblioteka skompiluje się pod WebAssembly (przeglądarki)"
command = "cargo"
args = ["check", "--target", "wasm32-unknown-unknown", "--lib"]
# UWAGA: Aby to zadziałało, musisz mieć zainstalowany target.
# Odpal raz w konsoli: rustup target add wasm32-unknown-unknown

[tasks.check-wasm64]
description = "Sprawdza, czy biblioteka skompiluje się pod WebAssembly (przeglądarki)"
command = "cargo"
args = ["check", "--target", "wasm64-unknown-unknown", "--lib"]
# UWAGA: Aby to zadziałało, musisz mieć zainstalowany target.
# Odpal raz w konsoli: rustup target add wasm64-unknown-unknown

# ====================================================
# 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
# 🟥                                               🟥
# 🟥                ALIAS - ALIASY                 🟥 
# 🟥                                               🟥
# 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
# ====================================================

[tasks.a]
alias = "snapshot-code"

[tasks.a_doc]
alias = "snapshot-total-source-code"

[tasks.a_f_i]
alias = "snapshot-filetree-includes"

[tasks.a_f_e]
alias = "snapshot-filetree-excludes"

[tasks.a_clean]
alias = "clear-contents-of-src-folder-under-prompt"

# ----------------------------------------------------------------------------------------------------------------------------------------------------

[tasks.e]
alias = "snapshot-diag-err-save"

[tasks.e_clean]
alias = "clear-contents-of-err-folder-under-prompt"

[tasks.f]
alias = "snapshot-diag-fmt-safe"

[tasks.f_clean]
alias = "clear-contents-of-err-folder-under-prompt"

# ----------------------------------------------------------------------------------------------------------------------------------------------------

[tasks.ai]
alias = "info"

[tasks.ai_out]
alias = "info-tofile"

# ----------------------------------------------------------------------------------------------------------------------------------------------------

[tasks.h]
alias = "help"

[tasks.H]
alias = "HELP"

# ----------------------------------------------------------------------------------------------------------------------------------------------------

[tasks.b0]
alias = "fmt-c0-pre-op-snapshot-restore-point-draft"

[tasks.b]
alias = "fmt-c0-pre-op-snapshot-restore-point"

# ----------------------------------------------------------------------------------------------------------------------------------------------------

# {G}/H
[tasks.v_tag]
alias = "v-add-hashtag"

# {E-F}/H
[tasks.v_num]
alias = "v-next--point"

# {E-F}/H
[tasks.v_typ]
alias = "v-next--phase"

# {B-D}/H
[tasks.v_new_fix]
alias = "v-start-patch"

# {B-D}/H
[tasks.v_new_ver]
alias = "v-start-minor"

# {A}/H
[tasks.v_end]
alias = "v-finish-dist"

# {H}/H
[tasks.v_tag_pub]
alias = "v--pub-crates"

# {H}/H
[tasks.v_tag_git]
alias = "v--pub-github"

# ----------------------------------------------------------------------------------------------------------------------------------------------------


```

### 010: `./README.md`

```markdown

```

### 011: `./ROADMAP.md`

```markdown
# 🗺️ ROADMAP (Plany Rozwoju)

Ten dokument określa strategiczne cele i planowane funkcjonalności dla biblioteki `cad-cs` na przyszłe wydania (v0.2.0 i wyżej).

---

## 1. Rozszerzenie Systemów Kątowych i Geodezyjnych

Obecnie biblioteka natywnie wspiera format DMS (Stopnie, Minuty, Sekundy) oraz Radiany. Planujemy rozbudowę o bardziej nowoczesne standardy zapisu.

* [ ] **Wsparcie dla formatu DDD (Decimal Degrees):**
  * **📚 [POL]:** Dodanie pełnej obsługi formatu stopni dziesiętnych (np. `50.2489°`). Jest to krytyczne dla natywnej współpracy z nowoczesnymi interfejsami API (np. Google Maps, GeoJSON).
  * **📚 [ENG]:** Add full support for Decimal Degrees format. Critical for native interoperability with modern web APIs (e.g., Google Maps, GeoJSON).
  * *Implementacja:* Wymaga dodania struktur DTO dla DDD, makra `ddd!` oraz funkcji przejścia pomiędzy jądrem `Cs` a nowym izolatem.

## 2. Zaawansowane Rzutowanie Przestrzenne (Polyhedron Projections)

Wychodzimy poza standardowe rzuty na płaszczyzny kartezjańskie (XY, XZ, YZ) oraz ECEF.

* [ ] **Rzutowanie Lat/Lon na Wielościany (Polyhedron):**
  * **📚 [POL]:** Implementacja algorytmów rzutowania współrzędnych sferycznych (Szerokość/Długość) na zdefiniowane, płaskie ściany wielościanów foremnych (np. Dwudziestościan/Icosahedron, Sześcian/Cube).
  * **📚 [ENG]:** Implementation of projection algorithms from spherical coordinates (Lat/Lon) onto defined, flat faces of regular polyhedrons.
  * *Cel:* Umożliwienie tworzenia map topologicznych (np. mapy Dymaxion Fullera) i rozwijanie sfery na płaskie siatki badawcze.

## 3. Topologia Sferyczna (Spherical Spatial Analysis)

Rozszerzenie obecnych, prostych analiz podziału przestrzeni (ćwiartki 2D, oktanty 3D) na zaawansowaną geometrię wielościenną.

* [ ] **Identyfikacja w Wielościanach Sferycznych (Spherical Polyhedrons):**
  * **📚 [POL]:** Zamiast ograniczania się do 8 oktanów, system będzie w stanie określić, do której "ściany" (obszaru) zdefiniowanego wielościanu sferycznego należy dany wektor 3D / punkt LatLon.
  * **📚 [ENG]:** Instead of limiting to 8 octants, the system will determine which "face" (region) of a defined spherical polyhedron a given 3D vector / LatLon point belongs to.
  * *Mechanizm:* Konstrukcja brył wpisanych w sferę bazową. Funkcja (np. `spherical_face()`) zwróci identyfikator regionu zdefiniowanego wielościanu (np. 1 z 20 trójkątów sferycznych dla icosahedronu), zastępując tradycyjne wywołanie `q()`.

```

### 012: `./TODO.md`

```markdown
# 📋 TODO: Projekt `cad-cs`

## 🚀 Plan na przyszłość

### Testy i Niezawodność

- [ ] **Testy jednostkowe (Unit Tests):** Aktualnie `cargo test` zgłasza brak testów (`running 0 tests`). Kluczowe będzie dopisanie modułu testowego dla głównych operacji matematycznych:
  - Konwersje układów współrzędnych (ECEF, DMS, sferyczne, biegunowe).
  - Weryfikacja działania `EPSILON_SPATIAL` oraz tolerancji numerycznej (`is_equal`).
  - Sprawdzenie operatorów na wektorach `Cs<N>`.
- [ ] **Testy dokumentacji (Doc Tests):** Dopisanie w dokumentacji (komentarze `///`) małych przykładów użycia każdej metody, co `cargo test` sam sprawdzi pod kątem poprawności.

### Dług technologiczny (Drobne poprawki)

- [*] **Zabezpieczenie tagu HTML w dokumentacji:** Składnia `Cs<N>` w pliku `src/libs/cs/model.rs` (linia 55) musi zostać ujęta w grawisy (`` `Cs<N>` ``), żeby `cargo doc` nie uznawał `<N>` za niezamknięty tag języka HTML.
- [ ] **Oczyszczenie importów:** Nieużywany import `AbstractHelperCs2` w `examples/basic_usage.rs` nie został naprawiony przez `cargo fix` i nadal wymaga ręcznego usunięcia.

### Rozwój Architektury

- [ ] **Eksploracja wasm64:** W miarę jak projekt zacznie operować na wielkich chmurach punktów (np. miliony wektorów 3D) rozważyć dodanie targetu `wasm64-unknown-unknown`, aby ominąć 4-gigabajtowy limit pamięci standardowego WebAssembly.

---

---

## Wdrożenie wzorca "Formatter Adapter Pattern"

**CEL:** Całkowita separacja warstwy prezentacji od logiki wyjścia (`stdout`).
Obecne rozwiązanie (`CsConsoleDebug`) jest wygodne, ale zbyt sztywno wiąże kod z makrem `println!`.

**KONCEPCJA:**
Zamiast metod `.print()`, stworzymy adaptery (lekkie struktury), które implementują trait `std::fmt::Display`. Dzięki temu punkt będzie można wypisać nie tylko na konsolę, ale też do logów, plików, czy przesłać jako tekst do UI.

**PRZEWIDYWANA ERGONOMIA:**

```rust
let pt = cs![1.0, 2.0, 3.0];
println!("Punkt kontrolny: {}", pt.display_as("P1", AngleFmt::Deg));
```

**ZALETY:**

1. **Wsparcie dla makr systemowych:** Pełna kompatybilność z `format!`, `write!`, `panic!`, `log!`.
2. **Leniwa ewaluacja (Lazy):** Formatowanie tekstu następuje dopiero w momencie rzeczywistego żądania zapisu, a nie w trakcie wywołania metody.
3. **Czystość kodu:** Całkowite usunięcie zależności od `std::io` z rdzenia matematycznego biblioteki.

**SZKIC IMPLEMENTACJI:**

```rust
struct CsFormatter<'a, const N: usize> {
    source: &'a Cs<N>,
    name: &'a str,
    fmt: AngleFmt
}

impl<'a, const N: usize> std::fmt::Display for CsFormatter<'a, N> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        // Tutaj przenosimy logikę z obecnych metod print, używając writeln!(f, ...)
        Ok(())
    }
}
```

---

---

## 🧩 Modularyzacja i Feature Flags (Planowana Optymalizacja)

**CEL:** Zapewnienie użytkownikom możliwości kompilacji tylko wybranych części biblioteki (np. samo `tolerance` bez ciężkiej trygonometrii).

### Konfiguracja `Cargo.toml`

Należy wdrożyć kaskadowy system zależności wewnętrznych:

```toml
[features]
default = ["cs"]

# Kotwice (Kaskada zależności):
cs        = ["angle", "cs_full"]
angle     = ["frac"]
frac      = ["tolerance"]
tolerance = []
cs_full   = [] # Prywatna kotwica dla pomocniczych modułów Cs
```

### Zmiany w strukturze `src/lib.rs` (lub `libs.rs`)

Wprowadzenie warunkowej kompilacji dla modułów pomocniczych:

```rust
// Przykład implementacji warunkowej w libs.rs
#[cfg(feature = "cs_full")]
pub(crate) mod cs_utils; // Dostępny tylko wewnątrz crate przy włączonym cs_full
```

**ZALETY:**

1. [cite_start]**Szybsza kompilacja:** Użytkownik potrzebujący tylko `is_zero()` nie kompiluje całej matematyki sferycznej[cite: 025].
2. [cite_start]**Mniejsze binarki:** Krytyczne przy projektach Embedded lub bardzo lekkich buildach WASM[cite: 006].
3. [cite_start]**Czystość dokumentacji:** Dzięki `all-features = true` w metadanych `docs.rs`, dokumentacja nadal będzie pokazywać pełne API[cite: 006].

---

---

## 🛠️ Poprawki i Refaktoryzacja

- [ ] **Stabilność DMS:** Rozważyć obsługę `-0` stopni w `Angle::from_dms` (obecna implementacja oparta na `i16` może gubić znak przy małych wartościach ujemnych).
- [ ] **Optymalizacja Trygonometrii:** W metodach konwersji (np. `to_ecef`) sprawdzić możliwość szerszego wykorzystania instrukcji `sin_cos()` dla redukcji kosztu obliczeniowego.
- [ ] **Implementacja Traitów:** Rozważyć implementację `std::ops::AddAssign` i `SubAssign` dla `Cs<N>` celem uniknięcia alokacji przy operacjach modyfikujących.

---

---

- [ ] **Macro compile_error:** Rozważyć użycie `compile_error!` w makrze `cs!` dla nieobsługiwanej liczby argumentów, aby dawać czytelniejsze komunikaty niż błąd dopasowania wzorca.
- [ ] **DerefMut:** Podjąć decyzję, czy dopuszczamy `impl DerefMut` dla `Cs<N>`. Obecnie struktura promuje niemutowalność, co jest bezpieczniejsze w obliczeniach wektorowych.

---

---

- [ ] **Shorthand API Consistency:** Rozważyć dodanie podobnych funkcji pomocniczych dla innych modułów (np. w `tolerance` dla szybkich porównań), jeśli ich częstotliwość użycia będzie wysoka.
- [ ] **Const context:** Sprawdzić, czy `from_deg` i `from_pi_frac` mogą stać się `const fn` (obecnie ograniczone przez wywołania `to_radians()`), co pozwoliłoby na używanie shorthandów w kontekstach statycznych.

---

---

- [ ] **Aproksymacja Symetryczna:** Przetestować zachowanie `as_frac` dla wartości ekstremalnie bliskich zeru, ale o różnym znaku, w celu uniknięcia anomalii w mianowniku.
- [ ] **Własny Typ Fraction:** Rozważyć wprowadzenie struktury `Fraction { num: f64, den: f64 }` zamiast krotki, aby umożliwić implementację traitu `Display`.

---

---

- [x] **Naprawa dokumentacji enum:** Naprawiono błąd `///` w `AngleFmt`.
- [ ] **Serde Support:** Rozważyć dodanie opcjonalnej zależności `serde` pod flagą feature, aby umożliwić automatyczną serializację struktur DTO do JSON/TOML.
- [ ] **Validation Logic:** Dodać metody walidujące zakresy dla DTO (np. czy `sn_lat_d` nie przekracza 90) przed konwersją do `Cs<N>`.

---

---

- [ ] **Symmetry Check:** Zweryfikować spójność kierunków kątów `f_z_x` oraz `f_z_y` względem reguły prawej dłoni w układach cylindrycznych osi Y i X.
- [ ] **Unified DTO Trait:** Rozważyć wprowadzenie traitu `Cylindrical` wspierającego różne osie obrotu (X, Y, Z) dla ujednolicenia interfejsu konwersji.
- [ ] **DMS Nz90Ex0 Altitude:** Podjąć decyzję o włączeniu pola `alt` (wysokość) do struktury `CoordsDmsNz90Ex0` w celu pełnej zgodności z ECEF.

---

---

- [ ] **AbstractSignStrExt - Obsługa -0.0:** Sprawdzić, czy dla `f64` należy uwzględniać "ujemne zero" w metodach `sign_*`. Obecna implementacja `self >= 0.0` traktuje `-0.0` jako dodatnie (N/E).
- [ ] **Lokalizacja:** Rozważyć, czy nazewnictwo kierunków (N/S/E/W) powinno być konfigurowalne (np. polskie P/P/W/Z) poprzez opcjonalny parametr lub feature flag.

---

---

- [ ] **Feature Gating:** Rozdzielić moduły `core::d2` i `core::d3` za pomocą atrybutów `#[cfg(feature = "dim2")]` / `#[cfg(feature = "dim3")]`.
- [ ] **TryFrom for DTO:** Rozważyć implementację `TryFrom<Cs<N>>` dla struktur DTO, co umożliwiłoby bezpieczny powrót z jądra obliczeniowego do modeli nazwanych z walidacją zakresów.
- [ ] **Cylindrical Rotation Check:** Wykonać testy jednostkowe sprawdzające, czy kierunki obrotu w `new_from_rfx` i `new_from_rfy` są zgodne z intuicją CAD (prawoskrętność).

---

---

- [ ] **Unit Tests - Vector Ops:** Implementacja testów dla `dot`, `cross` (2D/3D) oraz `angle_between` z wykorzystaniem wartości referencyjnych.
- [ ] **SIMD Optimization:** Rozważyć użycie atrybutów `#[repr(simd)]` (wymaga nightly) dla `Cs<2>` i `Cs<3>` w celu przyspieszenia operacji masowych na chmurach punktów.
- [ ] **ECEF Accuracy:** Przetestować `to_dms_sn_we_from_xyz` pod kątem błędów zaokrągleń przy biegunach (osobliwość asin).
- [ ] **Assignment Operators:** Zaimplementować traity `AddAssign`, `SubAssign`, `MulAssign` oraz `DivAssign` dla `Cs<N>`, aby umożliwić modyfikację wektorów w miejscu (in-place).
- [ ] **Angle Between - Edge Cases:** Przetestować stabilność `angle_between` dla wektorów o skrajnie różnych rzędach wielkości.
- [ ] **ECEF Reference Ellipsoids:** Rozważyć dodanie predefiniowanych stałych dla elipsoid (np. WGS84, GRS80) jako parametrów wejściowych dla konwersji ECEF.
- [ ] **Angle Normalization:** Sprawdzić, czy metody azymutalne powinny automatycznie normalizować wynik do zakresu [0, 2π).
- [ ] **to_rf Consistency:** Zweryfikować, czy konwersja `to_rf_from_xy` nie powinna zwracać dedykowanej struktury DTO zamiast surowego `Cs<2>`, aby uniknąć pomyłek R/Phi z X/Y.
- [ ] **Coordinate Precision:** Zweryfikować błędy zaokrągleń przy konwersji `to_ecef` dla punktów znajdujących się w skrajnie dużej odległości od środka układu.
- [ ] **Angle Ambiguity:** Dodać testy sprawdzające stabilność kątów kompasowych (`arctan_x_y` etc.) na granicach przedziałów.
- [ ] **DMS Validation:** Dodać walidację wejściowych parametrów DMS (sekundy < 60, minuty < 60) przed konwersją do radianów.

---

---

- [ ] **ANSI Color Support:** Rozważyć użycie kodów kolorów ANSI zamiast (lub obok) emoji, aby poprawić czytelność w terminalach nieobsługujących pełnego zestawu Unicode.
- [ ] **Custom Formatter:** Wprowadzić strukturę `CsFormatter`, która pozwoli na globalne ustawienie precyzji wyświetlanych liczb (obecnie używane jest domyślne `{:?}`).
- [ ] **Log Integration:** Przygotować implementację traitu `Display` lub integrację z makrem `log::debug!`, aby uniknąć bezpośredniego używania `println!` wewnątrz biblioteki.

---

---

- [ ] **Eksport DTO z modelem Wildcard:** Przeanalizować, czy użycie `pub use model::*;` nie spowoduje zanieczyszczenia przestrzeni nazw (Namespace Pollution) w miarę dodawania nowych układów DTO. Rozważyć wprowadzenie modułu `prelude`.

---

---

- [ ] **Linter & Docs Atrybuty:** Rozważyć dodanie na górze pliku `libs.rs` (lub `lib.rs`) rygorystycznych atrybutów, np. `#![warn(missing_docs)]` oraz `#![deny(clippy::unwrap_used)]`, aby wymusić rygor dokumentacyjny i bezpieczeństwo (brak panik) w całym drzewie projektu.
- [ ] **no_std Support:** Przeanalizować możliwość dodania atrybutu `#![no_std]` (wymagałoby użycia biblioteki `libm` dla funkcji trygonometrycznych na rzecz wbudowanego `std`), co otworzyłoby bibliotekę na systemy Embedded i lekkie środowiska WASM.

---

---

- [ ] **Globalne Lintery:** Dodać na początku `src/lib.rs` dyrektywy `#![warn(missing_docs)]` oraz `#![deny(clippy::unwrap_used)]` w celu zablokowania możliwości wdrożenia nieudokumentowanego lub panikującego kodu.
- [ ] **Feature Flags w Crate Root:** Jeśli wprowadzimy system `features` (np. dla wyłączania modułu 3D), `src/lib.rs` będzie miejscem do warunkowego eksportowania (np. `#[cfg(feature = "full")] pub mod libs;`).

---

---

- [ ] **Fasada w przykładach:** Zaktualizować importy w `basic_usage.rs`, aby używały skróconych ścieżek z fasady `cs.rs` (np. `use cad_cs::CoordsPolar;` zamiast pełnej ścieżki do `model`), w celu testowania publicznego API tak, jak widzi to użytkownik zewnętrzny.
- [ ] **Rozszerzenie Examples:** Dodać osobny plik `examples/advanced_geodesy.rs` skupiający się wyłącznie na konwersjach ECEF i operacjach krzyżowych, odciążając tym samym `basic_usage.rs`.

---

---

```

### 013: `./examples/basic_usage.rs`

```rust
// 📃 ./examples/basic_usage.rs

use cad_cs::libs::cs::abstracts::{
	//AbstractHelperCs2, // Jeśli używasz .print()
	AbstractHelperCs3, // Jeśli używasz .print()
	AbstractMathCs2,
	AbstractMathCs3,
};
use cad_cs::{
	cs,
	dms,
	libs::{
		angle::AngleFmt,
		cs::{
			Cs2,
			Cs3,
			model::{CoordsPolar, CoordsSpherical},
		},
	},
};

fn main() {
	// 📚 [POL]: Inicjalizacja demonstracji API biblioteki cad-cs.
	// 📚 [ENG]: Initialization of the cad-cs library API demonstration.
	println!("🚀 cad-cs API demonstration\n");

	// =================================================================
	// 1. MACRO INITIALIZATION (cs!)
	// =================================================================

	let pt_2d = cs![3.0, 4.0];
	let pt_3d = cs![3.0, 4.0, 12.0];

	println!("🔷 2D Cartesian: {:?}", pt_2d);
	println!("🔶 3D Cartesian: {:?}", pt_3d);

	// 📚 [POL]: Bezpośrednie wywołania metod algebraicznych jądra.
	// 📚 [ENG]: Direct calls to the kernel's algebraic methods.
	println!("📏 rxy (2D radius): {}", pt_2d.rxy());
	println!("📏 rxyz (3D full radius): {}", pt_3d.rxyz());
	println!("📐 arctan_y_x (2D azimuth): {:.4} rad", pt_2d.arctan_y_x());

	println!("\n----------------------------------------------------\n");

	// =================================================================
	// 2. DOMAIN TRANSFER OBJECTS (DTO) CONVERSIONS
	// =================================================================

	// 📚 [POL]: Konwersja układu biegunowego (R, Φ) na kartezjański wektor Cs2.
	// 📚 [ENG]: Conversion of polar system (R, Φ) to Cartesian Cs2 vector.
	let punkt_z_biegunowego: Cs2 = CoordsPolar {
		r_d2: 10.0,
		f_y_x: std::f64::consts::PI / 2.0, // 90° (Y-axis)
	}
	.into();

	println!("🟪 Cs2 from polar (R=10, Φ=90°): {:?}", punkt_z_biegunowego);

	// 📚 [POL]: Konwersja układu sferycznego (R, Φ, Θ) na kartezjański wektor Cs3.
	// 📚 [ENG]: Conversion of spherical system (R, Φ, Θ) to Cartesian Cs3 vector.
	let punkt_ze_sferycznego: Cs3 = CoordsSpherical {
		r_d3: 20.0,
		f_y_x: 0.0,                        // X-axis azimuth
		t_z_r: std::f64::consts::PI / 4.0, // 45° inclination from Z-axis
	}
	.into();

	println!("🟫 Cs3 from spherical (R=20, Φ=0°, Θ=45°): {:?}", punkt_ze_sferycznego);

	println!("\n----------------------------------------------------\n");

	// =================================================================
	// 3. GEODETIC CONVERSIONS (DMS / ECEF)
	// =================================================================

	// 📚 [POL]: Wektor 2D zawierający szerokość i długość geograficzną wygenerowaną makrem dms!.
	// 📚 [ENG]: 2D vector containing latitude and longitude generated by the dms! macro.
	let stawowa2 = cs![dms!(50, 14, 56.3), dms!(19, 8, 2.3)];

	// 📚 [POL]: Średni promień Ziemi w metrach (model sferyczny).
	// 📚 [ENG]: Mean Earth radius in meters (spherical model).
	let r_ziemi = 6_371_000.0;

	// 📚 [POL]: Transformacja współrzędnych sferycznych do przestrzeni kartezjańskiej ECEF.
	// 📚 [ENG]: Transformation of spherical coordinates to Cartesian ECEF space.
	let stawowa_xyz = stawowa2.to_ecef_from_rad_sn_we(r_ziemi);

	println!("🌐 Radian input (Lat, Lon): {:?}", stawowa2);

	// 📚 [POL]: Wywołanie warstwy diagnostycznej (helper).
	// 📚 [ENG]: Invocation of the diagnostic layer (helper).
	stawowa_xyz.print("stawowa_xyz", AngleFmt::Deg);
	stawowa_xyz.print_dms_sn_we("stawowa_xyz_dms");

	println!("📍 Location relative to Earth's core (meters):");
	println!("   X: {:.2} m", stawowa_xyz[0]);
	println!("   Y: {:.2} m", stawowa_xyz[1]);
	println!("   Z: {:.2} m", stawowa_xyz[2]);
	println!("📏 Distance from core (validation): {:.2} m", stawowa_xyz.rxyz());

	// 📚 [POL]: Operacja odwrotna (Dekompresja) ECEF -> DMS.
	// 📚 [ENG]: Inverse operation (Decompression) ECEF -> DMS.
	let z_powrotem_na_powierzchnie = stawowa_xyz.to_dms_sn_we_from_xyz();
	println!("🔄 Back to DMS: {:?}", z_powrotem_na_powierzchnie);
}

```

### 014: `./examples/playground.rs`

```rust
// 📃 ./examples/playground.rs

// ===================================================================================
// IMPORTY BIBLIOTEKI CAD-CS (Aktywne i zakomentowane do testów)
// ===================================================================================

// Makra fundamentalne
use cad_cs::cs;
// use cad_cs::{dms, dms_angle, frac, frac_pi};

// Główne typy jądra i traity
// use cad_cs::{Cs, Cs2, Cs3, Dim};

// Typy modeli i układów współrzędnych (DTO)
// use cad_cs::{CoordsXy, CoordsPolar};
// use cad_cs::{CoordsCylindricalZ, CoordsCylindricalY, CoordsCylindricalX};
// use cad_cs::{CoordsXyz, CoordsSpherical, CoordsSphericalEcefSnWeDms};

// Typy pomocnicze z modułu kątów
use cad_cs::libs::angle::AngleFmt;
// use cad_cs::libs::angle::{Angle, AngleExt, deg, rad, pi_frac};

// Typy z modułu ułamków
// use cad_cs::libs::frac::{as_frac, as_frac_pi};

// Trait rozszerzający znaki
// use cad_cs::AbstractSignStrExt;
use cad_cs::libs::cs::abstracts::{
	// AbstractMathCs2,        // Dla metod typu .q() czy .rxy()
	// AbstractMathCs3,
	AbstractHelperCs2,
	AbstractHelperCs3,
	AbstractProjectionsCs2,
	AbstractProjectionsCs3,
};

fn main() {
	// 📚 [POL]: Testy wyczerpujące wektorów 2D w poszczególnych ćwiartkach kartezjańskich.
	// 📚 [ENG]: Exhaustive testing of 2D vectors in individual Cartesian quadrants.
	let d2_pt1 = cs![4.327, 7.194];
	let d2_pt2 = cs![4.327, -7.194];
	let d2_pt3 = cs![-4.327, -7.194];
	let d2_pt4 = cs![-4.327, 7.194];

	// 📚 [POL]: Rzutowanie wektorów 2D na poszczególne płaszczyzny 3D.
	// 📚 [ENG]: Projecting 2D vectors onto individual 3D planes.
	let xy_pt1 = cs![4.327, 7.194].new_as_xy();
	let xy_pt2 = cs![4.327, -7.194].new_as_xy();
	let xy_pt3 = cs![-4.327, -7.194].new_as_xy();
	let xy_pt4 = cs![-4.327, 7.194].new_as_xy();

	let xz_pt1 = cs![4.327, 7.194].new_as_xz();
	let xz_pt2 = cs![4.327, -7.194].new_as_xz();
	let xz_pt3 = cs![-4.327, -7.194].new_as_xz();
	let xz_pt4 = cs![-4.327, 7.194].new_as_xz();

	let yz_pt1 = cs![4.327, 7.194].new_as_yz();
	let yz_pt2 = cs![4.327, -7.194].new_as_yz();
	let yz_pt3 = cs![-4.327, -7.194].new_as_yz();
	let yz_pt4 = cs![-4.327, 7.194].new_as_yz();

	// 📚 [POL]: Testy wyczerpujące wektorów 3D we wszystkich 8 oktantach.
	// 📚 [ENG]: Exhaustive testing of 3D vectors in all 8 octants.
	let xyz_pt1 = cs![16.321, 3.438, 8.213];
	let xyz_pt2 = cs![16.321, 3.438, -8.213];
	let xyz_pt3 = cs![16.321, -3.438, 8.213];
	let xyz_pt4 = cs![-16.321, 3.438, 8.213];
	let xyz_pt5 = cs![16.321, -3.438, -8.213];
	let xyz_pt6 = cs![-16.321, -3.438, 8.213];
	let xyz_pt7 = cs![-16.321, 3.438, -8.213];
	let xyz_pt8 = cs![-16.321, -3.438, -8.213];

	// ===================================================================================
	// KREACJA Z UKŁADÓW ALTERNATYWNYCH (SHORTHAND)
	// ===================================================================================

	// 📚 [POL]: System biegunowy (R=15.0, Φ=90°) -> Kartezjański Cs2.
	// 📚 [ENG]: Polar system (R=15.0, Φ=90°) -> Cartesian Cs2.
	let bieg_pt1 = cs![15.0, 0.5 * std::f64::consts::PI].new_as_xy_from_rf();

	// 📚 [POL]: System sferyczny (R=14.0, Φ=45°, Θ=225°) -> Kartezjański Cs3.
	// 📚 [ENG]: Spherical system (R=14.0, Φ=45°, Θ=225°) -> Cartesian Cs3.
	let sfer_pt1 =
		cs![14.0, 0.25 * std::f64::consts::PI, 1.25 * std::f64::consts::PI].new_as_xyz_from_rft();

	// 📚 [POL]: System cylindryczny względem osi X (X=12.0) -> Kartezjański Cs3.
	// 📚 [ENG]: Cylindrical system relative to X-axis (X=12.0) -> Cartesian Cs3.
	let x_cy_pt1 = cs![13.0, 0.5 * std::f64::consts::PI].new_as_xyz_from_rf_with_x(12.0);

	// 📚 [POL]: System cylindryczny względem osi Y (Y=11.0) -> Kartezjański Cs3.
	// 📚 [ENG]: Cylindrical system relative to Y-axis (Y=11.0) -> Cartesian Cs3.
	let y_cy_pt1 = cs![12.0, 0.2 * std::f64::consts::PI].new_as_xyz_from_rf_with_y(11.0);

	// 📚 [POL]: System cylindryczny względem osi Z (Z=14.0) -> Kartezjański Cs3.
	// 📚 [ENG]: Cylindrical system relative to Z-axis (Z=14.0) -> Cartesian Cs3.
	let z_cy_pt1 = cs![16.0, 0.6 * std::f64::consts::PI].new_as_xyz_from_rf_with_z(14.0);

	// ===================================================================================
	// WIZUALIZACJA I RAPORTOWANIE
	// ===================================================================================

	d2_pt1.print("d2_pt1", AngleFmt::Deg);
	d2_pt2.print("d2_pt2", AngleFmt::Deg);
	d2_pt3.print("d2_pt3", AngleFmt::Deg);
	d2_pt4.print("d2_pt4", AngleFmt::Deg);

	xy_pt1.print("xy_pt1", AngleFmt::Deg);
	xy_pt2.print("xy_pt2", AngleFmt::Deg);
	xy_pt3.print("xy_pt3", AngleFmt::Deg);
	xy_pt4.print("xy_pt4", AngleFmt::Deg);

	xz_pt1.print("xz_pt1", AngleFmt::Deg);
	xz_pt2.print("xz_pt2", AngleFmt::Deg);
	xz_pt3.print("xz_pt3", AngleFmt::Deg);
	xz_pt4.print("xz_pt4", AngleFmt::Deg);

	yz_pt1.print("yz_pt1", AngleFmt::Deg);
	yz_pt2.print("yz_pt2", AngleFmt::Deg);
	yz_pt3.print("yz_pt3", AngleFmt::Deg);
	yz_pt4.print("yz_pt4", AngleFmt::Deg);

	xyz_pt1.print("xyz_pt1", AngleFmt::Deg);
	xyz_pt2.print("xyz_pt2", AngleFmt::Deg);
	xyz_pt3.print("xyz_pt3", AngleFmt::Deg);
	xyz_pt4.print("xyz_pt4", AngleFmt::Deg);
	xyz_pt5.print("xyz_pt5", AngleFmt::Deg);
	xyz_pt6.print("xyz_pt6", AngleFmt::Deg);
	xyz_pt7.print("xyz_pt7", AngleFmt::Deg);
	xyz_pt8.print("xyz_pt8", AngleFmt::Deg);

	bieg_pt1.print("bieg_pt1", AngleFmt::Deg);
	sfer_pt1.print("sfer_pt1", AngleFmt::Deg);
	x_cy_pt1.print("x_cy_pt1", AngleFmt::Deg);
	y_cy_pt1.print("y_cy_pt1", AngleFmt::Deg);
	z_cy_pt1.print("z_cy_pt1", AngleFmt::Deg);
}

```

### 015: `./src/lib.rs`

```rust
// 📃 ./src/lib.rs

// 📚 【 POL】: Główny punkt wejścia biblioteki przestrzennej i geodezyjnej `cad-cs`.
// 📚 【 ENG】: Main entry point for the spatial and geodetic library `cad-cs`.

/// 📚 【 POL】: Główny moduł agregujący całą logikę biblioteki (matematykę, geodezję, narzędzia).
/// 📚 【 ENG】: Main module aggregating all library logic (mathematics, geodesy, tools).
pub mod libs;

```

### 016: `./src/libs.rs`

```rust
// 📃 ./src/libs.rs

/// 📚 【 POL】: Izolator systemu kątowego. Bezpieczne zarządzanie radianami, stopniami i formatem DMS.
/// 📚 【 ENG】: Angular system insulator. Safe management of radians, degrees, and DMS format.
pub mod angle;

/// 📚 【 POL】: Jądro geometryczne. Wektory, układy współrzędnych i transformacje w przestrzeni 2D/3D.
/// 📚 【 ENG】: Geometric kernel. Vectors, coordinate systems, and transformations in 2D/3D space.
pub mod cs;

/// 📚 【 POL】: Silnik aproksymacji wymiernej. Ułamki łańcuchowe i reprezentacja wielokrotności liczby PI.
/// 📚 【 ENG】: Rational approximation engine. Continued fractions and PI multiples representation.
pub mod frac;

/// 📚 【 POL】: Fundament stabilności numerycznej. Globalne progi tolerancji dla operacji zmiennoprzecinkowych.
/// 📚 【 ENG】: Numerical stability foundation. Global tolerance thresholds for floating-point operations.
pub mod tolerance;

/// 📚 【 POL】: Stałe fizyczne i matematyczne używane w całej bibliotece.
/// 📚 【 ENG】: Physical and mathematical constants used throughout the library.
pub mod consts;

```

### 017: `./src/libs/angle.rs`

```rust
// 📃 ./src/libs/angle.rs

pub mod abstracts;
pub mod math;
pub mod model;

// Udostępniamy użytkownikowi modele i kontrakty od razu
pub use abstracts::*;
pub use math::{deg, pi_frac, rad};
pub use model::*;

```

### 018: `./src/libs/angle/abstracts.rs`

```rust
// 📃 src/libs/angle/abstracts.rs
use super::model::Angle;

pub trait AbstractAngle {
	fn from_rad(r: f64) -> Self;
	fn from_deg(d: f64) -> Self;
	fn from_pi_frac(fraction: f64) -> Self;
	fn from_dms(d: i16, m: u8, s: f32) -> Self;
	fn to_dms(self) -> (i16, u8, f32);
	fn rad(self) -> f64;
	fn deg(self) -> f64;
	fn pi_frac(self) -> (f64, f64);
	fn print_rad(self) -> String;
	fn print_deg(self) -> String;
	fn print_pi_frac(self) -> String;
}

/// 📚 【 POL】: Trait rozszerzający dla f64, umożliwiający bezpośrednią konwersję na typ Angle.
/// 📚 【 ENG】: Extension trait for f64, allowing direct conversion to Angle type.
pub trait AngleExt {
	fn deg(self) -> Angle;
	fn rad(self) -> Angle;
	fn pi_frac(self) -> Angle;
}

```

### 019: `./src/libs/angle/math.rs`

```rust
// 📃 src/libs/angle/math.rs

use std::f64::consts;

use super::{
	abstracts::{AbstractAngle, AngleExt},
	model::{Angle, AngleFmt},
};
use crate::libs::frac;

impl AbstractAngle for Angle {
	/// 📚 【 POL】: Tworzy instancję Angle bezpośrednio z wartości w radianach (Konstruktor bazowy).
	/// 📚 【 ENG】: Creates an Angle instance directly from a value in radians (Base constructor).
	#[inline]
	fn from_rad(r: f64) -> Self { Self(r) }

	/// 📚 【 POL】: Tworzy instancję Angle z wartości w stopniach, dokonując konwersji na radiany.
	/// 📚 【 ENG】: Creates an Angle instance from a value in degrees, converting it to radians.
	#[inline]
	fn from_deg(d: f64) -> Self { Self(d.to_radians()) }

	/// 📚 【 POL】: Tworzy instancję Angle jako wielokrotność liczby PI.
	/// 📚 【 ENG】: Creates an Angle instance as a multiple of PI.
	#[inline]
	fn from_pi_frac(fraction: f64) -> Self { Self(fraction * consts::PI) }

	/// 📚 【 POL】: Dekoduje format DMS (Stopnie, Minuty, Sekundy) do reprezentacji radianowej.
	/// 📚 【 ENG】: Decodes DMS (Degrees, Minutes, Seconds) format to radian representation.
	///
	/// ⚠️ 【 POL】: Wykorzystanie i16 dla stopni uniemożliwia reprezentację "-0°" w formacie DMS.
	/// ⚠️ 【 ENG】: Using i16 for degrees prevents representation of "-0°" in DMS format.
	fn from_dms(d: i16, m: u8, s: f32) -> Self {
		// Uwaga: prosty 'sign' z d < 0 nie obsłuży "-0 stopni".
		// W GIS często używa się f64 z signum() dla stopnia, ale trzymając się i16:
		let sign = if d < 0 { -1.0_f64 } else { 1.0_f64 };
		let ddd = (d as f64) + sign * ((m as f64) / 60.0) + sign * ((s as f64) / 3600.0);
		Self::from_deg(ddd)
	}

	/// 📚 【 POL】: Dekomponuje kąt z radianów do formatu DMS (Stopnie, Minuty, Sekundy).
	/// 📚 【 ENG】: Decomposes angle from radians to DMS (Degrees, Minutes, Seconds) format.
	fn to_dms(self) -> (i16, u8, f32) {
		let ddd = self.deg();
		let sign = ddd.signum();
		let abs_ddd = ddd.abs();

		let d = (abs_ddd.floor() * sign) as i16;
		let m_float = (abs_ddd - abs_ddd.floor()) * 60.0;
		let m = m_float.floor() as u8;
		let s = ((m_float - m_float.floor()) * 60.0) as f32;

		(d, m, s)
	}

	/// 📚 【 POL】: Zwraca wartość kąta w radianach (f64). Operacja bezkosztowa.
	/// 📚 【 ENG】: Returns angle value in radians (f64). Zero-cost operation.
	#[inline]
	fn rad(self) -> f64 { self.0 }

	/// 📚 【 POL】: Zwraca wartość kąta w stopniach (f64).
	/// 📚 【 ENG】: Returns angle value in degrees (f64).
	#[inline]
	fn deg(self) -> f64 { self.0.to_degrees() }

	/// 📚 【 POL】: Zwraca kąt jako ułamek liczby PI w postaci (licznik, mianownik).
	/// 📚 【 ENG】: Returns angle as a fraction of PI in (numerator, denominator) form.
	#[inline]
	fn pi_frac(self) -> (f64, f64) { frac::as_frac_pi(self.0) }

	/// 📚 【 POL】: Formatuje kąt jako ciąg znaków w radianach. Alokuje String.
	/// 📚 【 ENG】: Formats angle as a string in radians. Allocates String.
	fn print_rad(self) -> String { format!("{:.4} rad", self.rad()) }

	/// 📚 【 POL】: Formatuje kąt jako ciąg znaków w stopniach. Alokuje String.
	/// 📚 【 ENG】: Formats angle as a string in degrees. Allocates String.
	fn print_deg(self) -> String { format!("{:.2}°", self.deg()) }

	/// 📚 【 POL】: Formatuje kąt jako ułamek liczby PI. Alokuje String.
	/// 📚 【 ENG】: Formats angle as a fraction of PI. Allocates String.
	fn print_pi_frac(self) -> String {
		let (num, den) = self.pi_frac();
		if num == 0.0 {
			return "0".to_string();
		}
		if den == 1.0 {
			return format!("{} π", num);
		}
		format!("{} / {} π", num, den)
	}
}

impl AngleExt for f64 {
	#[rustfmt::skip] #[inline]	fn deg(self) -> Angle { Angle::from_deg(self) }
	#[rustfmt::skip] #[inline]	fn rad(self) -> Angle { Angle::from_rad(self) }
	#[rustfmt::skip] #[inline]	fn pi_frac(self) -> Angle { Angle::from_pi_frac(self) }
}

impl AngleFmt {
	/// 📚 【 POL】: Formatuje wartość f64 (interpretowaną jako radiany) zgodnie z wybranym formatem.
	/// 📚 【 ENG】: Formats a f64 value (interpreted as radians) according to the selected format.
    #[rustfmt::skip] #[inline]
	pub fn format(&self, val: f64) -> String {
        match self {
            Self::Rad    => Angle::from_rad(val).print_rad(),
			Self::Deg    => Angle::from_rad(val).print_deg(),
			Self::PiFrac => Angle::from_rad(val).print_pi_frac(),
        }
    }
}

/// 📚 【 POL】: Funkcja pomocnicza (Top-level API) tworząca instancję Angle z wartości w radianach.
/// 📚 【 ENG】: Helper function (Top-level API) creating an Angle instance from a value in radians.
#[rustfmt::skip] #[inline] pub const fn rad(r: f64) -> Angle { Angle(r) }

/// 📚 【 POL】: Funkcja pomocnicza (Top-level API) tworząca instancję Angle z wartości w stopniach.
/// 📚 【 ENG】: Helper function (Top-level API) creating an Angle instance from a value in degrees.
#[rustfmt::skip] #[inline] pub fn deg(d: f64) -> Angle { Angle::from_deg(d) }

/// 📚 【 POL】: Funkcja pomocnicza (Top-level API) tworząca instancję Angle jako wielokrotność liczby PI.
/// 📚 【 ENG】: Helper function (Top-level API) creating an Angle instance as a multiple of PI.
#[rustfmt::skip] #[inline] pub fn pi_frac(fraction: f64) -> Angle { Angle::from_pi_frac(fraction) }

```

### 020: `./src/libs/angle/model.rs`

```rust
// 📃 src/libs/angle/model.rs

/// 📚 【 POL】: Izolator systemu typów przechowujący wartości kątowe w radianach. Zapobiega błędom jednostkowym.
/// 📚 【 ENG】: Type system insulator storing angular values in radians. Prevents unit mismatch errors.
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Angle(pub f64);

/// 📚 【 POL】: Definicja dostępnych formatów prezentacji kąta.
/// 📚 【 ENG】: Definition of available angle presentation formats.
#[derive(Debug, Clone, Copy, Default)]
pub enum AngleFmt {
	#[default]
	/// 📚 【 POL】: Stopnie (np. 90.00°)
	/// 📚 【 ENG】: Degrees (e.g., 90.00°)
	Deg,
	/// 📚 【 POL】: Radiany (np. 1.5708 rad)
	/// 📚 【 ENG】: Radians (e.g., 1.5708 rad)
	Rad,
	/// 📚 【 POL】: Ułamki liczby PI (np. 1/2 π)
	/// 📚 【 ENG】: PI Fractions (e.g., 1/2 π)
	PiFrac,
}

```

### 021: `./src/libs/consts.rs`

```rust
// 📃 ./src/libs/consts.rs

/// 📚 【 POL】: Średni promień Ziemi w metrach (model sferyczny R1).
/// 📚 【 ENG】: Mean Earth radius in meters (spherical model R1).
pub const EARTH_MEAN_RADIUS_METERS: f64 = 6_371_000.0;

/// 📚 【 POL】: Przyśpieszenie ziemskie (standardowe) w m/s².
/// 📚 【 ENG】: Standard Earth gravity in m/s².
pub const G_ACCELERATION: f64 = 9.80665;

/// 📚 【 POL】: Tryb promienia używany w obliczeniach łukowych i konwersjach DMS.
/// 📚 【 ENG】: Radius mode used in arc calculations and DMS conversions.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum RadiusMode {
	/// 📚 【 POL】: Średni promień Ziemi (6,371,000 m).
	/// 📚 【 ENG】: Mean Earth radius (6,371,000 m).
	Mean,
	/// 📚 【 POL】: Jedność (1.0) - przydatne do obliczeń znormalizowanych.
	/// 📚 【 ENG】: Unity (1.0) - useful for normalized calculations.
	Unity,
	/// 📚 【 POL】: Własny promień podany w metrach.
	/// 📚 【 ENG】: Custom radius provided in meters.
	Custom(f64),
}

impl RadiusMode {
	/// 📚 【 POL】: Zwraca liczbową wartość promienia dla wybranego trybu.
	/// 📚 【 ENG】: Returns the numerical radius value for the selected mode.
	#[inline]
	pub fn val(&self) -> f64 {
		match self {
			Self::Mean => EARTH_MEAN_RADIUS_METERS,
			Self::Unity => 1.0,
			Self::Custom(r) => *r,
		}
	}
}

```

### 022: `./src/libs/cs.rs`

```rust
// 📃 ./src/libs/cs.rs

// --- REJESTRACJA PODMODUŁÓW ---

/// 📚 【 POL】: Rdzeń konwersji pomiędzy strukturami DTO a jądrem wektorowym.
/// 📚 【 ENG】: Conversion core between DTO structures and the vector kernel.
pub mod core;

/// 📚 【 POL】: Warstwa prezentacji i diagnostyki konsolowej (odseparowana od matematyki).
/// 📚 【 ENG】: Presentation and console diagnostics layer (separated from mathematics).
pub mod helper;

/// 📚 【 POL】: Implementacje operacji wektorowych, rzutów i transformacji geodezyjnych.
/// 📚 【 ENG】: Implementations of vector operations, projections, and geodetic transformations.
pub mod math;

/// 📚 【 POL】: Definicja struktury bazowej `Cs<N>` oraz ograniczeń wymiarowych (trait Dim).
/// 📚 【 ENG】: Definition of the base `Cs<N>` structure and dimensional constraints (Dim trait).
/// 📚 【 POL】: Modele danych (DTO) reprezentujące punkty w różnych układach współrzędnych.
/// 📚 【 ENG】: Data models (DTO) representing points in various coordinate systems.
pub mod model;

/// 📚 【 POL】: Narzędzia pomocnicze, w tym rozszerzenia typów do formatowania znaków.
/// 📚 【 ENG】: Utility tools, including type extensions for sign formatting.
pub mod utils;

// --- FASADA API (RE-EKSPORTY) ---

/// 📚 【 POL】: Bezpośredni dostęp do jądra obliczeniowego i aliasów typów.
/// 📚 【 ENG】: Direct access to the computational kernel and type aliases.
pub use model::Cs;
/// 📚 【 POL】: Globalny eksport wszystkich struktur DTO dla wygody inicjalizacji.
/// 📚 【 ENG】: Global export of all DTO structures for initialization convenience.
pub use model::*;
pub use types::{Cs2, Cs3, Dim};

// --- ABSTRAKCJA ---

pub mod abstracts;
/// 📚 【 POL】: Eksport traitu formatowania, wymaganego dla metod takich jak `sign_sn()`.
/// 📚 【 ENG】: Export of the formatting trait, required for methods like `sign_sn()`.
pub use abstracts::AbstractSignStrExt;

// --- MAKRA ---

pub mod macros;

// --- TYPY / ALIASY ---

pub mod types;

```

### 023: `./src/libs/cs/abstracts.rs`

```rust
// 📃 ./src/libs/cs/abstracts.rs

use std::ops::{Add, Div, Mul, Neg, Sub};

use crate::libs::{angle::AngleFmt, cs::model::Cs};

/// 📚 【 POL】: Kontrakt gwarantujący implementację podstawowych rzutowań 2D.
/// 📚 【 ENG】: Contract guaranteeing the implementation of basic 2D projections.
pub trait AbstractProjectionsCs2 {
	fn new_from_rf(r: f64, phi_rad: f64) -> Self;
	fn new_as_xy(&self) -> Cs<3>;
	fn new_as_xz(&self) -> Cs<3>;
	fn new_as_yz(&self) -> Cs<3>;
	fn new_as_xy_from_rf(&self) -> Self;
	fn new_as_xyz_from_rf_with_z(&self, z: f64) -> Cs<3>;
	fn new_as_xyz_from_rf_with_y(&self, y: f64) -> Cs<3>;
	fn new_as_xyz_from_rf_with_x(&self, x: f64) -> Cs<3>;
}

/// 📚 【 POL】: Kontrakt gwarantujący implementację podstawowych rzutowań 3D.
/// 📚 【 ENG】: Contract guaranteeing the implementation of basic 3D projections.
pub trait AbstractProjectionsCs3 {
	fn new_from_rft(r: f64, phi_rad: f64, theta_rad: f64) -> Self;
	fn new_from_rfz(r_d2: f64, phi_rad: f64, z: f64) -> Self;
	fn new_from_rfx(r_d2: f64, phi_rad: f64, x: f64) -> Self;
	fn new_from_rfy(r_d2: f64, phi_rad: f64, y: f64) -> Self;
	fn new_as_xyz_from_rft(&self) -> Cs<3>;
}

/// 📚 【 POL】: Kontrakt generyczny dla uniwersalnej matematyki wektorowej (np. dodawanie).
/// 📚 【 ENG】: Generic contract for universal vector mathematics.
pub trait AbstractMathCsGeneric {
	fn sub(&self, other: &Self) -> Self;
	fn add(&self, other: &Self) -> Self;
	fn dot(&self, other: &Self) -> f64;
	fn r_sq(&self) -> f64;
	fn r(&self) -> f64;
	fn normalize_r_projection(&self) -> Self;
	fn angle_between(&self, other: &Self) -> f64;
}

/// 📚 【 POL】: Kontrakt dla operacji matematycznych specyficznych dla 2D.
/// 📚 【 ENG】: Contract for 2D-specific mathematical operations.
pub trait AbstractMathCs2 {
	fn rxy(&self) -> f64;
	fn arctan_y_x(&self) -> f64;
	fn arctan_x_y(&self) -> f64;
	fn to_rf_from_xy(&self) -> Cs<2>;
	fn to_ecef_from_rad_sn_we(&self, r: f64) -> Cs<3>;
	fn q(&self) -> u8;
	fn q_sign(&self) -> [&'static str; 2];
	fn rxy_sq(&self) -> f64;
	fn cross(&self, other: &Cs<2>) -> f64;
	fn perp(&self) -> Cs<2>;
}

/// 📚 【 POL】: Kontrakt dla operacji matematycznych specyficznych dla 3D.
/// 📚 【 ENG】: Contract for 3D-specific mathematical operations.
pub trait AbstractMathCs3 {
	fn rxy(&self) -> f64;
	fn rxz(&self) -> f64;
	fn ryz(&self) -> f64;
	fn rxyz(&self) -> f64;
	fn arctan_y_x(&self) -> f64;
	fn arctan_z_x(&self) -> f64;
	fn arctan_z_y(&self) -> f64;
	fn arctan_x_y(&self) -> f64;
	fn arctan_x_z(&self) -> f64;
	fn arctan_y_z(&self) -> f64;
	fn arccos_x_rxyz(&self) -> f64;
	fn arccos_y_rxyz(&self) -> f64;
	fn arccos_z_rxyz(&self) -> f64;
	fn to_rf_from_xy(&self) -> Cs<2>;
	fn to_rf_from_xz(&self) -> Cs<2>;
	fn to_rf_from_yz(&self) -> Cs<2>;
	fn to_rfx_from_xyz(&self) -> Cs<3>;
	fn to_rfy_from_xyz(&self) -> Cs<3>;
	fn to_rfz_from_xyz(&self) -> Cs<3>;
	fn to_rft_from_xyz(&self) -> Cs<3>;
	fn to_ecef_from_dms_sn_we(
		sn_d: i16,
		sn_m: u8,
		sn_s: f32,
		we_d: i16,
		we_m: u8,
		we_s: f32,
		r: f64,
	) -> Self;
	fn to_dms_sn_we_from_xyz(&self) -> crate::libs::cs::model::CoordsSphericalEcefSnWeDms;
	fn q(&self) -> u8;
	fn q_sign(&self) -> [&'static str; 3];
	fn rxyz_sq(&self) -> f64;
	fn rxy_sq(&self) -> f64;
	fn rxz_sq(&self) -> f64;
	fn ryz_sq(&self) -> f64;
	fn normalize_rxy_projection(&self) -> Cs<3>;
	fn normalize_rxz_projection(&self) -> Cs<3>;
	fn normalize_ryz_projection(&self) -> Cs<3>;
	fn cross(&self, other: &Cs<3>) -> Cs<3>;
}

/// 📚 【 POL】: Kontrakt generyczny dla fundamentalnych operacji modelu` Cs<N>`.
/// 📚 【 ENG】: Generic contract for fundamental `Cs<N>` model operations.
pub trait AbstractModelCsGeneric<const N: usize> {
	fn new(data: [f64; N]) -> Self;
	fn origin() -> Self;
	fn as_slice(&self) -> &[f64];
}

/// 📚 【 POL】: Kontrakt dla pomocniczych funkcji diagnostycznych 2D.
/// 📚 【 ENG】: Contract for 2D diagnostic helper functions.
/// 📚 【 POL】: Trait rozszerzający dla `Cs<2>`, umożliwiający formatowanie danych wyjściowych do konsoli.
/// 📚 【 ENG】: Extension trait for `Cs<2>`, enabling output formatting to the console.
pub trait AbstractHelperCs2 {
	/// 📚 【 POL】: Wyświetla informację o ćwiartce i znakach składowych.
	/// 📚 【 ENG】: Displays quadrant information and component signs.
	fn print_q(&self, name: &str);

	/// 📚 【 POL】: Wyświetla współrzędne kartezjańskie (X, Y).
	/// 📚 【 ENG】: Displays Cartesian coordinates (X, Y).
	fn print_xy(&self, name: &str);

	/// 📚 【 POL】: Wyświetla współrzędne biegunowe (R, Φ).
	/// 📚 【 ENG】: Displays polar coordinates (R, Φ).
	fn print_rf(&self, name: &str, fmt: AngleFmt);

	/// 📚 【 POL】: Wyświetla zbiorczy raport debugowania dla wektora 2D.
	/// 📚 【 ENG】: Displays a summary debug report for the 2D vector.
	fn print(&self, name: &str, fmt: AngleFmt);
}

/// 📚 【 POL】: Kontrakt dla pomocniczych funkcji diagnostycznych 3D.
/// 📚 【 ENG】: Contract for 3D diagnostic helper functions.
/// 📚 【 POL】: Trait rozszerzający dla `Cs<3>`, umożliwiający zaawansowane formatowanie rzutów i geodezji.
/// 📚 【 ENG】: Extension trait for `Cs<3>`, enabling advanced formatting for projections and geodesy.
pub trait AbstractHelperCs3 {
	fn print_q(&self, name: &str);
	fn print_xyz(&self, name: &str);
	fn print_rft(&self, name: &str, fmt: AngleFmt);
	fn print_rfx(&self, name: &str, fmt: AngleFmt);
	fn print_rfy(&self, name: &str, fmt: AngleFmt);
	fn print_rfz(&self, name: &str, fmt: AngleFmt);
	fn print_dms_sn_we(&self, name: &str);
	fn print(&self, name: &str, fmt: AngleFmt);
}

pub trait AbstractArithmeticCsGeneric:
	Add<Output = Self>
	+ Sub<Output = Self>
	+ Neg<Output = Self>
	+ Mul<f64, Output = Self>
	+ Div<f64, Output = Self>
	+ Sized // Zapewnia, że rozmiar jest znany w czasie kompilacji
{
	// Deklarujemy metody, które potem implementujesz w math.rs
	fn add_cs(&self, rhs: &Self) -> Self;
	fn sub_cs(&self, rhs: &Self) -> Self;
	fn neg_cs(&self) -> Self;
	fn mul_scalar(&self, rhs: f64) -> Self;
	fn div_scalar(&self, rhs: f64) -> Self;
}

/// 📚 【 POL】: Trait rozszerzający dla typów liczbowych, ułatwiający prezentację znaków kierunkowych.
/// 📚 【 ENG】: Extension trait for numerical types, facilitating the presentation of directional signs.
pub trait AbstractSignStrExt {
	/// 📚 【 POL】: Zwraca "+" dla wartości nieujemnych oraz "-" dla ujemnych.
	/// 📚 【 ENG】: Returns "+" for non-negative values and "-" for negative ones.
	fn sign_str(self) -> &'static str;

	/// 📚 【 POL】: Zwraca "N" (Północ) dla wartości nieujemnych oraz "S" (Południe) dla ujemnych.
	/// 📚 【 ENG】: Returns "N" (North) for non-negative values and "S" (South) for negative ones.
	fn sign_sn(self) -> &'static str;

	/// 📚 【 POL】: Zwraca "E" (Wschód) dla wartości nieujemnych oraz "W" (Zachód) dla ujemnych.
	/// 📚 【 ENG】: Returns "E" (East) for non-negative values and "W" (West) for negative ones.
	fn sign_we(self) -> &'static str;
}

```

### 024: `./src/libs/cs/core.rs`

```rust
// 📃 ./src/libs/cs/core.rs

/// 📚 【 POL】: Implementacje konwersji 2D. 📚 【 ENG】: 2D conversion impls.
pub mod d2;
/// 📚 【 POL】: Implementacje konwersji 3D. 📚 【 ENG】: 3D conversion impls.
pub mod d3;

use std::ops::Deref;

use super::{abstracts::AbstractModelCsGeneric, model::Cs, types::Dim};

/// 📚 【 POL】: Implementacja Deref zapewniająca bezpośredni dostęp do wewnętrznej tablicy danych.
/// 📚 【 ENG】: Deref implementation providing direct access to the internal data array.
impl<const N: usize> Deref for Cs<N>
where Cs<N>: Dim
{
	type Target = [f64; N];
	#[inline]
	fn deref(&self) -> &Self::Target { &self.0 }
}

/// 📚 【 POL】: Implementacja kontraktu bazowego (przeniesiona z model.rs).
impl<const N: usize> AbstractModelCsGeneric<N> for Cs<N>
where Cs<N>: Dim
{
	#[inline]
	fn new(data: [f64; N]) -> Self { Cs(data) }
	#[inline]
	fn origin() -> Self { Cs([0.0; N]) }
	#[inline]
	fn as_slice(&self) -> &[f64] { &self.0 }
}

```

### 025: `./src/libs/cs/core/d2.rs`

```rust
// 📃 ./src/libs/cs/core/d2.rs

use crate::libs::cs::{
	abstracts::AbstractProjectionsCs2,
	model::{Cs, *},
	types::Cs2,
};

// --- IMPLEMENTACJE FROM (DTO -> Cs2) ---

impl From<CoordsXy> for Cs2 {
	/// 📚 【 POL】: Konwertuje kartezjańskie DTO XY na wektor Cs2.
	/// 📚 【 ENG】: Converts Cartesian XY DTO to a Cs2 vector.
	#[inline]
	fn from(c: CoordsXy) -> Self { Cs([c.x, c.y]) }
}

impl From<CoordsPolar> for Cs2 {
	/// 📚 【 POL】: Konwertuje współrzędne biegunowe XY na wektor kartezjański Cs2.
	/// 📚 【 ENG】: Converts XY polar coordinates to a Cs2 Cartesian vector.
	#[inline]
	fn from(c: CoordsPolar) -> Self {
		let (sin_f, cos_f) = c.f_y_x.sin_cos();
		Cs([c.r_d2 * cos_f, c.r_d2 * sin_f])
	}
}

impl AbstractProjectionsCs2 for Cs<2> {
	/// 📚 【 POL】: Tworzy nowy wektor Cs2 z układu biegunowego (R, Φ) na płaszczyźnie XY.
	/// 📚 【 ENG】: Creates a new Cs2 vector from a polar system (R, Φ) on the XY plane.
	#[rustfmt::skip] #[inline]
	fn new_from_rf(r: f64, phi_rad: f64) -> Self {
		let (sin_phi, cos_phi) = phi_rad.sin_cos();
		Cs([r * cos_phi, r * sin_phi])
	}

	// Projeksje 2D -> 3D
	#[rustfmt::skip] #[inline]	fn new_as_xy(&self) -> Cs<3> { Cs([self.0[0], self.0[1], 0.0]) }
	#[rustfmt::skip] #[inline]	fn new_as_xz(&self) -> Cs<3> { Cs([self.0[0], 0.0, self.0[1]]) }
	#[rustfmt::skip] #[inline]	fn new_as_yz(&self) -> Cs<3> { Cs([0.0, self.0[0], self.0[1]]) }

	// ===================================================================================
	// KREACJA Z UKŁADÓW BIEGUNOWYCH I CYLINDRYCZNYCH (Źródło: R, Phi)
	// ===================================================================================
	// ⚠️ UWAGA DOTYCZĄCA ZAKRESU PONIŻSZYCH METOD:
	// Poniższe metody asymilują ("as"), że wywołujący obiekt `self` NIE JEST
	// wektorem kartezjańskim [X, Y], lecz kontenerem na dane układu biegunowego:
	// self.0[0] = R (Promień)
	// self.0[1] = Φ (Kąt Azymutu w radianach)
	// Przykładowe wywołanie: let punkt = cs![promien, azymut_rad].new_as_xy_from_rf();

	/// 📚 【 POL】: Interpretuje Cs2 jako kontener [R, Φ] i zwraca kartezjański wektor 2D [X, Y].
	/// 📚 【 ENG】: Interprets Cs2 as a [R, Φ] container and returns a 2D Cartesian vector [X, Y].
	#[rustfmt::skip] #[inline]
	fn new_as_xy_from_rf(&self) -> Cs<2> {
		let (sin_phi, cos_phi) = self.0[1].sin_cos();
		Cs([self.0[0] * cos_phi, self.0[0] * sin_phi])
	}

	/// 📚 【 POL】: Interpretuje Cs2 jako [R_xy, Φ] i zwraca kartezjański Cs3 z zadaną wysokością Z.
	/// 📚 【 ENG】: Interprets Cs2 as [R_xy, Φ] and returns a Cartesian Cs3 with a given Z height.
	#[rustfmt::skip] #[inline]
	fn new_as_xyz_from_rf_with_z(&self, z: f64) -> Cs<3> {
		let (sin_phi, cos_phi) = self.0[1].sin_cos();
		Cs([self.0[0] * cos_phi, self.0[0] * sin_phi, z])
	}

	/// 📚 【 POL】: Interpretuje Cs2 jako [R_xz, Φ] i zwraca kartezjański Cs3 z zadaną szerokością Y.
	/// 📚 【 ENG】: Interprets Cs2 as [R_xz, Φ] and returns a Cartesian Cs3 with a given Y width.
	#[rustfmt::skip] #[inline]
	fn new_as_xyz_from_rf_with_y(&self, y: f64) -> Cs<3> {
		let (sin_phi, cos_phi) = self.0[1].sin_cos();
		Cs([self.0[0] * cos_phi, y, self.0[0] * sin_phi])
	}

	/// 📚 【 POL】: Interpretuje Cs2 jako [R_yz, Φ] i zwraca kartezjański Cs3 z zadaną współrzędną X.
	/// 📚 【 ENG】: Interprets Cs2 as [R_yz, Φ] and returns a Cartesian Cs3 with a given X coordinate.
	#[rustfmt::skip] #[inline]
	fn new_as_xyz_from_rf_with_x(&self, x: f64) -> Cs<3> {
		let (sin_phi, cos_phi) = self.0[1].sin_cos();
		Cs([x, self.0[0] * cos_phi, self.0[0] * sin_phi])
	}
}

```

### 026: `./src/libs/cs/core/d3.rs`

```rust
// 📃 ./src/libs/cs/core/d3.rs

use crate::libs::cs::{
	abstracts::AbstractProjectionsCs3,
	model::{Cs, *},
	types::Cs3,
};

// --- IMPLEMENTACJE FROM (DTO -> Cs3) ---

impl From<CoordsXyz> for Cs3 {
	/// 📚 【 POL】: Konwertuje kartezjańskie DTO XYZ na wektor Cs3.
	/// 📚 【 ENG】: Converts Cartesian XYZ DTO to a Cs3 vector.
	#[inline]
	fn from(c: CoordsXyz) -> Self { Cs([c.x, c.y, c.z]) }
}

impl From<CoordsCylindricalZ> for Cs3 {
	/// 📚 【 POL】: Konwertuje współrzędne cylindryczne względem osi Z na wektor kartezjański Cs3.
	/// 📚 【 ENG】: Converts cylindrical coordinates relative to the Z-axis to a Cs3 Cartesian vector.
	#[inline]
	fn from(c: CoordsCylindricalZ) -> Self {
		let (sin_f, cos_f) = c.f_y_x.sin_cos();
		Cs([c.r_d2 * cos_f, c.r_d2 * sin_f, c.z])
	}
}

impl From<CoordsCylindricalY> for Cs3 {
	/// 📚 【 POL】: Konwertuje współrzędne cylindryczne względem osi Y na wektor kartezjański Cs3.
	/// 📚 【 ENG】: Converts cylindrical coordinates relative to the Y-axis to a Cs3 Cartesian vector.
	#[inline]
	fn from(c: CoordsCylindricalY) -> Self {
		let (sin_f, cos_f) = c.f_z_x.sin_cos();
		Cs([c.r_d2 * cos_f, c.y, c.r_d2 * sin_f])
	}
}

impl From<CoordsCylindricalX> for Cs3 {
	/// 📚 【 POL】: Konwertuje współrzędne cylindryczne względem osi X na wektor kartezjański Cs3.
	/// 📚 【 ENG】: Converts cylindrical coordinates relative to the X-axis to a Cs3 Cartesian vector.
	#[inline]
	fn from(c: CoordsCylindricalX) -> Self {
		let (sin_f, cos_f) = c.f_z_y.sin_cos();
		Cs([c.x, c.r_d2 * cos_f, c.r_d2 * sin_f])
	}
}

impl From<CoordsSpherical> for Cs3 {
	/// 📚 【 POL】: Konwertuje współrzędne sferyczne na wektor kartezjański Cs3.
	/// 📚 【 ENG】: Converts spherical coordinates to a Cs3 Cartesian vector.
	#[inline]
	fn from(c: CoordsSpherical) -> Self {
		let (sin_f, cos_f) = c.f_y_x.sin_cos(); // Azymut XY
		let (sin_t, cos_t) = c.t_z_r.sin_cos(); // Inklinacja Z do R
		Cs([c.r_d3 * sin_t * cos_f, c.r_d3 * sin_t * sin_f, c.r_d3 * cos_t])
	}
}

impl AbstractProjectionsCs3 for Cs<3> {
	/// 📚 【 POL】: Tworzy nowy wektor Cs3 z układu sferycznego (R, Φ, Θ).
	/// 📚 【 ENG】: Creates a new Cs3 vector from a spherical system (R, Φ, Θ).
	#[rustfmt::skip] #[inline]
	fn new_from_rft(r: f64, phi_rad: f64, theta_rad: f64) -> Self {
		let (sin_phi, cos_phi) = phi_rad.sin_cos();
		let (sin_theta, cos_theta) = theta_rad.sin_cos();
		Cs([r * sin_theta * cos_phi, r * sin_theta * sin_phi, r * cos_theta])
	}

	/// 📚 【 POL】: Interpretuje Cs3 jako kontener sferyczny [R, Φ, Θ] i zwraca wektor kartezjański [X, Y, Z].
	/// 📚 【 ENG】: Interprets Cs3 as a spherical container [R, Φ, Θ] and returns a Cartesian vector [X, Y, Z].
	#[rustfmt::skip] #[inline]
	fn new_as_xyz_from_rft(&self) -> Cs<3> {
		let (sin_phi, cos_phi) = self.0[1].sin_cos();
		let (sin_theta, cos_theta) = self.0[2].sin_cos();
		Cs([
			self.0[0] * sin_theta * cos_phi,
			self.0[0] * sin_theta * sin_phi,
			self.0[0] * cos_theta
		])
	}

	/// 📚 【 POL】: Tworzy nowy wektor 3D z układu cylindrycznego względem osi Z: (R_xy, Φ, Z).
	/// 📚 【 ENG】: Creates a new 3D vector from a cylindrical system relative to the Z-axis: (R_xy, Φ, Z).
	#[rustfmt::skip] #[inline]
	fn new_from_rfz(r_d2: f64, phi_rad: f64, z: f64) -> Self {
		let (sin_phi, cos_phi) = phi_rad.sin_cos();
		Cs([r_d2 * cos_phi, r_d2 * sin_phi, z])
	}

	/// 📚 【 POL】: Tworzy nowy wektor 3D z układu cylindrycznego względem osi X: (R_yz, Φ, X).
	/// 📚 【 ENG】: Creates a new 3D vector from a cylindrical system relative to the X-axis: (R_yz, Φ, X).
	/// ⚙️ 【 POL】: Kąt Φ mierzony jest od osi Y do Z na płaszczyźnie YZ.
	/// ⚙️ 【 ENG】: Angle Φ is measured from the Y-axis to the Z-axis on the YZ plane.
	#[rustfmt::skip] #[inline]
	fn new_from_rfx(r_d2: f64, phi_rad: f64, x: f64) -> Self {
		let (sin_phi, cos_phi) = phi_rad.sin_cos();
		Cs([x, r_d2 * cos_phi, r_d2 * sin_phi])
	}

	/// 📚 【 POL】: Tworzy nowy wektor 3D z układu cylindrycznego względem osi Y: (R_xz, Φ, Y).
	/// 📚 【 ENG】: Creates a new 3D vector from a cylindrical system relative to the Y-axis: (R_xz, Φ, Y).
	/// ⚙️ 【 POL】: Kąt Φ mierzony jest od osi X do Z na płaszczyźnie XZ.
	/// ⚙️ 【 ENG】: Angle Φ is measured from the X-axis to the Z-axis on the XZ plane.
	#[rustfmt::skip] #[inline]
	fn new_from_rfy(r_d2: f64, phi_rad: f64, y: f64) -> Self {
		let (sin_phi, cos_phi) = phi_rad.sin_cos();
		Cs([r_d2 * cos_phi, y, r_d2 * sin_phi])
	}
}

```

### 027: `./src/libs/cs/helper.rs`

```rust
// 📃 ./src/libs/cs/helper.rs

// use crate::libs::angle::{AngleExt, AngleFmt};

pub mod d2;
pub mod d3;

/*
 * /// 📚 【 POL】: Wewnętrzny helper do formatowania wartości kątowych zgodnie z zadanym enum AngleFmt.
 * /// 📚 【 ENG】: Internal helper for formatting angular values according to the specified AngleFmt enum.
 * #[rustfmt::skip] #[inline]
 * pub(crate) fn print_fmt_ang(val: f64, fmt: AngleFmt) -> String {
 * 	match fmt {
 * 		AngleFmt::Rad => val.rad().print_rad(),
 * 		AngleFmt::Deg => val.rad().print_deg(),
 * 		AngleFmt::PiFrac => val.rad().print_pi_frac(),
 * 	}
 * }
 */

```

### 028: `./src/libs/cs/helper/d2.rs`

```rust
// 📃 ./src/libs/cs/helper/d2.rs

use crate::libs::{
	angle::AngleFmt,
	cs::{
		abstracts::{AbstractHelperCs2, AbstractMathCs2},
		model::Cs,
	},
};
// ===================================================================================
// TRAIT DLA 2D
// ===================================================================================

impl AbstractHelperCs2 for Cs<2> {
	#[rustfmt::skip] #[inline]
	fn print_q(&self, name: &str) {
	let s = self.q_sign();
	println!(" {}    (Ćwiartka: {} [{}, {}])", name, self.q(), s[0], s[1]);
	}

	#[rustfmt::skip] #[inline]
	fn print_xy(&self, name: &str) {
		println!(" {} 🔷 (x: {:?}, y: {:?})", name, self.0[0], self.0[1]);
	}

	#[rustfmt::skip] #[inline]
	fn print_rf(&self, name: &str, fmt: AngleFmt) {
		let rf = self.to_rf_from_xy();
		println!(" {} 🟪 (R: {:?}, Φ: {})", name, rf[0], fmt.format(rf[1]));
	}

	#[rustfmt::skip] #[inline]
	fn print(&self, name: &str, fmt: AngleFmt) {
		let spacer = " ".repeat(name.chars().count());
		self.print_xy(name);
		self.print_q(&spacer);
		self.print_rf(&spacer, fmt);
		println!(" ");
	}
}

```

### 029: `./src/libs/cs/helper/d3.rs`

```rust
// 📃 ./src/libs/cs/helper/d3.rs

use crate::libs::{
	angle::AngleFmt,
	cs::{
		abstracts::{AbstractHelperCs3, AbstractMathCs3},
		model::Cs,
	},
};

// ===================================================================================
// TRAIT DLA 3D
// ===================================================================================

impl AbstractHelperCs3 for Cs<3> {
	#[rustfmt::skip] #[inline]
	fn print_q(&self, name: &str) {
		let s = self.q_sign();
		println!(" {}    (Oktant: {} [{}, {}, {}])", name, self.q(), s[0], s[1], s[2]);
	}

	#[rustfmt::skip] #[inline]
	fn print_xyz(&self, name: &str) {
		println!(" {} 🔶 (x: {:?}, y: {:?}, z: {:?})", name, self.0[0], self.0[1], self.0[2]);
	}

	#[rustfmt::skip] #[inline]
	fn print_rft(&self, name: &str, fmt: AngleFmt) {
		let rft = self.to_rft_from_xyz();
		println!(" {} 🟫 (R: {:?}, Φ: {}, Θ: {})", name, rft[0], fmt.format(rft[1]), fmt.format(rft[2]));
	}

	#[rustfmt::skip] #[inline]
	fn print_rfx(&self, name: &str, fmt: AngleFmt) {
		let rfx = self.to_rfx_from_xyz();
		println!(" {} 🟧 (R: {:?}, Φ: {}, x: {:?})", name, rfx[0], fmt.format(rfx[1]), rfx[2]);
	}

	#[rustfmt::skip] #[inline]
	fn print_rfy(&self, name: &str, fmt: AngleFmt) {
		let rfy = self.to_rfy_from_xyz();
		println!(" {} 🟨 (R: {:?}, Φ: {}, y: {:?})", name, rfy[0], fmt.format(rfy[1]), rfy[2]);
	}

	#[rustfmt::skip] #[inline]
	fn print_rfz(&self, name: &str, fmt: AngleFmt) {
		let rfz = self.to_rfz_from_xyz();
		println!(" {} 🟥 (R: {:?}, Φ: {}, z: {:?})", name, rfz[0], fmt.format(rfz[1]), rfz[2]);
	}

	/// 📚 【 POL】: Wyświetla współrzędne w formacie geodezyjnym DMS (Stopnie, Minuty, Sekundy) z oznaczeniami N/S i E/W.
	/// 📚 【 ENG】: Displays coordinates in geodetic DMS (Degrees, Minutes, Seconds) format with N/S and E/W indicators.
	#[rustfmt::skip] #[inline]
	fn print_dms_sn_we(&self, name: &str) {
		// Pobieramy nasz rozszerzony trait dla formatowania znaków
		use crate::libs::cs::abstracts::AbstractSignStrExt;

		// Dekompresujemy ECEF (XYZ) do DTO z DMS
		let dms = self.to_dms_sn_we_from_xyz();

		// Wyciągamy litery kierunków na podstawie znaków (N/S i E/W)
		let lat_dir = dms.sn_lat_d.sign_sn();
		let lon_dir = dms.we_lon_d.sign_we();

		// Wyświetlamy dokładnie jak na zrzucie ekranu z Google Maps!
		// {:02} dodaje zera wiodące do minut (np. 8 -> 08)
		// {:04.1} dodaje zera i ustala 1 miejsce po przecinku dla sekund (np. 2.3 -> 02.3)
		println!(" {} 🌍 {}°{:02}'{:04.1}\"{} {}°{:02}'{:04.1}\"{}",
			name,
			dms.sn_lat_d.abs(), dms.sn_lat_m, dms.sn_lat_s, lat_dir,
			dms.we_lon_d.abs(), dms.we_lon_m, dms.we_lon_s, lon_dir
		);
	}

	#[rustfmt::skip] #[inline]
	fn print(&self, name: &str, fmt: AngleFmt) {
		let spacer = " ".repeat(name.chars().count());
		self.print_xyz(name);
		self.print_q(&spacer);
		self.print_rft(&spacer, fmt);
		self.print_rfz(&spacer, fmt);
		self.print_rfy(&spacer, fmt);
		self.print_rfx(&spacer, fmt);
		self.print_dms_sn_we(&spacer);
		println!(" ");
	}
}

```

### 030: `./src/libs/cs/macros.rs`

```rust
// 📃 ./src/libs/cs/macros.rs

/*/
 * // Makro generujące Cs<N>
 * #[macro_export]
 * macro_rules! cs {
 *     ($($x:expr),* $(,)?) => {
 *         $crate::libs::cs::Cs([$($x as f64),*])
 *     };
 * }
 */

/// 📚 【 POL 】: Konstruktor makrowy dla `Cs<N>`. Obsługuje rzutowanie typów numerycznych na f64.
/// 📚 【 ENG 】: Macro constructor for `Cs<N>`. Handles casting of numerical types to f64.
///
/// # Examples: `cs![1, 2]` (Cs2), `cs![1, 2, 3]` (Cs3)
#[macro_export]
macro_rules! cs {
	// Dopasowanie dokładnie dla 2 elementów
	($x:expr, $y:expr $(,)?) => {
		$crate::libs::cs::model::Cs([$x as f64, $y as f64])
	};
	// Dopasowanie dokładnie dla 3 elementów
	($x:expr, $y:expr, $z:expr $(,)?) => {
		$crate::libs::cs::model::Cs([$x as f64, $y as f64, $z as f64])
	};
}

/// 📚 【 POL 】: Konstruktor makrowy tworzący instancję Angle z formatu DMS.
/// 📚 【 ENG 】: Macro constructor creating an Angle instance from DMS format.
#[macro_export]
macro_rules! dms_angle {
    ($d:expr, $m:expr, $s:expr) => {
        // W pełni kwalifikowana ścieżka uwalnia użytkownika z konieczności importowania AbstractAngle!
        <$crate::libs::angle::Angle as $crate::libs::angle::AbstractAngle>::from_dms($d as i16, $m as u8, $s as f32)
    };
}

/// 📚 【 POL 】: Konwertuje format DMS bezpośrednio do wartości f64 w radianach.
/// 📚 【 ENG 】: Converts DMS format directly to a f64 value in radians.
#[macro_export]
macro_rules! dms {
    ($d:expr, $m:expr, $s:expr) => {
        // Tutaj tak samo - wywołujemy .rad() bezpośrednio z traita, aby uniknąć błędów zakresu (scope).
        <$crate::libs::angle::Angle as $crate::libs::angle::AbstractAngle>::rad(
            <$crate::libs::angle::Angle as $crate::libs::angle::AbstractAngle>::from_dms($d as i16, $m as u8, $s as f32)
        )
    };
}

/// 📚 【 POL】: Makro implementujące trait AbstractSignStrExt dla wskazanych typów liczbowych i zdefiniowanego punktu zera.
/// 📚 【 ENG】: Macro implementing the AbstractSignStrExt trait for specified numerical types and a defined zero point.
#[macro_export]
macro_rules! impl_sign_str {
	($t:ty, $zero:expr) => {
		impl $crate::libs::cs::abstracts::AbstractSignStrExt for $t {
			#[inline]
			fn sign_str(self) -> &'static str { if self >= $zero { "+" } else { "-" } }
			#[inline]
			fn sign_sn(self) -> &'static str { if self >= $zero { "N" } else { "S" } }
			#[inline]
			fn sign_we(self) -> &'static str { if self >= $zero { "E" } else { "W" } }
		}
	};
}

```

### 031: `./src/libs/cs/math.rs`

```rust
// 📃 ./src/libs/cs/math.rs

use std::{
	array,
	ops::{Add, Div, Mul, Neg, Sub},
};

use crate::libs::{
	cs::{
		abstracts::{AbstractArithmeticCsGeneric, AbstractMathCsGeneric},
		model::Cs,
		types::Dim,
	},
	tolerance,
};

/// 📚 【 POL】: Specjalizacja 2D. 📚 【 ENG】: 2D Specialization.
pub mod d2;
/// 📚 【 POL】: Specjalizacja 3D. 📚 【 ENG】: 3D Specialization.
pub mod d3;

impl<const N: usize> AbstractMathCsGeneric for Cs<N>
where Cs<N>: Dim
{
	/// 📚 【 POL】: Operacja odejmowania wektorów. Zwraca wektor różnicy (B - A).
	/// 📚 【 ENG】: Vector subtraction. Returns the difference vector (B - A).
    #[rustfmt::skip] #[inline]
	fn sub(&self, other: &Self) -> Self {
		Cs(array::from_fn(|i| self.0[i] - other.0[i]))
	}

	/// 📚 【 POL】: Operacja dodawania wektorów. Zwraca wektor sumy (A + B).
	/// 📚 【 ENG】: Vector addition. Returns the sum vector (A + B).
    #[rustfmt::skip] #[inline]
	fn add(&self, other: &Self) -> Self {
		Cs(array::from_fn(|i| self.0[i] + other.0[i]))
	}

	/// 📚 【 POL】: Iloczyn skalarny (Dot product) dla dowolnego wymiaru N.
	/// 📚 【 ENG】: Dot product for any dimension N.
    #[rustfmt::skip] #[inline]
	fn dot(&self, other: &Self) -> f64 {
		let mut sum = 0.0;
		for i in 0..N { sum += self.0[i] * other.0[i]; }
		sum
	}

	/// 📚 【 POL】: Kwadrat pełnej długości wektora (R²). Eliminuje kosztowne pierwiastkowanie.
	/// 📚 【 ENG】: Squared full length of the vector (R²). Eliminates costly square root.
    #[rustfmt::skip] #[inline]
	fn r_sq(&self) -> f64 { self.dot(self) }

	/// 📚 【 POL】: Pełna długość wektora w przestrzeni (Norma Euklidesowa R).
	/// 📚 【 ENG】: Full length of the vector in space (Euclidean Norm R).
    #[rustfmt::skip] #[inline]
	fn r(&self) -> f64 { self.r_sq().sqrt() }

	/// 📚 【 POL】: Normalizuje wektor do długości jednostkowej (1.0). Zwraca wektor zerowy przy zerowej długości.
	/// 📚 【 ENG】: Normalizes the vector to unit length (1.0). Returns a zero vector for zero length.
    #[rustfmt::skip] #[inline]
	fn normalize_r_projection(&self) -> Self {
		let radius = self.r();
		if tolerance::is_zero(radius) {
			Cs([0.0; N])
		} else {
			Cs(array::from_fn(|i| self.0[i] / radius))
		}
	}

	/// 📚 【 POL】: Oblicza kąt między dwoma wektorami w radianach.
	/// 📚 【 ENG】: Calculates the angle between two vectors in radians.
    #[rustfmt::skip] #[inline]
	fn angle_between(&self, other: &Self) -> f64 {
		let r1 = self.r();
		let r2 = other.r();
		if tolerance::is_zero(r1) || tolerance::is_zero(r2) {
			0.0
		} else {
			(self.dot(other) / (r1 * r2)).clamp(-1.0, 1.0).acos()
		}
	}
}

// =============================================================================
// IMPLEMENTACJA OPERATORÓW
// =============================================================================

/// 📚 【 POL】: Implementacja operatora dodawania (Cs + Cs).
/// 📚 【 ENG】: Implementation of the addition operator (Cs + Cs).
impl<const N: usize> Add for Cs<N>
where Cs<N>: Dim
{
	type Output = Cs<N>;
	#[inline]
	fn add(self, rhs: Self) -> Self::Output {
		// 📌 Cs(array::from_fn(|i| self.0[i] + rhs.0[i]))
		AbstractMathCsGeneric::add(&self, &rhs)
	}
}

/// 📚 【 POL】: Implementacja operatora odejmowania (Cs - Cs).
/// 📚 【 ENG】: Implementation of the subtraction operator (Cs - Cs).
impl<const N: usize> Sub for Cs<N>
where Cs<N>: Dim
{
	type Output = Cs<N>;
	#[inline]
	fn sub(self, rhs: Self) -> Self::Output {
		// 📌 Cs(array::from_fn(|i| self.0[i] - rhs.0[i]))
		AbstractMathCsGeneric::sub(&self, &rhs)
	}
}

/// 📚 【 POL】: Implementacja operatora negacji (-Cs).
/// 📚 【 ENG】: Implementation of the negation operator (-Cs).
impl<const N: usize> Neg for Cs<N>
where Cs<N>: Dim
{
	type Output = Cs<N>;
	#[inline]
	fn neg(self) -> Self::Output {
		Cs(array::from_fn(|i| -self.0[i]))
		// ⁉️ AbstractMathCsGeneric::
	}
}

/// 📚 【 POL】: Implementacja mnożenia wektora przez skalar (Cs * f64).
/// 📚 【 ENG】: Implementation of vector multiplication by a scalar (Cs * f64).
impl<const N: usize> Mul<f64> for Cs<N>
where Cs<N>: Dim
{
	type Output = Cs<N>;
	#[inline]
	fn mul(self, rhs: f64) -> Self::Output {
		Cs(array::from_fn(|i| self.0[i] * rhs))
		// ⁉️ AbstractMathCsGeneric::
	}
}

/// 📚 【 POL】: Implementacja mnożenia skalara przez wektor (f64 * Cs).
/// 📚 【 ENG】: Implementation of scalar multiplication by a vector (f64 * Cs).
impl<const N: usize> Mul<Cs<N>> for f64
where Cs<N>: Dim
{
	type Output = Cs<N>;
	#[inline]
	fn mul(self, rhs: Cs<N>) -> Self::Output { rhs * self }
}

/// 📚 【 POL】: Implementacja dzielenia wektora przez skalar (Cs / f64).
/// 📚 【 ENG】: Implementation of vector division by a scalar (Cs / f64).
impl<const N: usize> Div<f64> for Cs<N>
where Cs<N>: Dim
{
	type Output = Cs<N>;
	#[inline]
	fn div(self, rhs: f64) -> Self::Output {
		// let mut result = [0.0; N];
		// for i in 0..N { result[i] = self.0[i] / rhs; }
		// Cs(result)
		Cs(array::from_fn(|i| self.0[i] / rhs))
		// ⁉️ AbstractMathCsGeneric::
	}
}
// =============================================================================
// PODPIĘCIE ABSTRAKTU ARYTMETYCZNEGO POD OPERATORY POWYŻSZE
// =============================================================================

impl<const N: usize> AbstractArithmeticCsGeneric for Cs<N>
where Cs<N>: Dim
{
	#[inline]
	fn add_cs(&self, rhs: &Self) -> Self { AbstractMathCsGeneric::add(self, rhs) }
	#[inline]
	fn sub_cs(&self, rhs: &Self) -> Self { AbstractMathCsGeneric::sub(self, rhs) }
	#[inline]
	fn neg_cs(&self) -> Self { -*self }
	#[inline]
	fn mul_scalar(&self, rhs: f64) -> Self { *self * rhs }
	#[inline]
	fn div_scalar(&self, rhs: f64) -> Self { *self / rhs }
}

```

### 032: `./src/libs/cs/math/d2.rs`

```rust
// 📃 ./src/libs/cs/math/d2.rs

use crate::libs::cs::{
	abstracts::{AbstractMathCs2, AbstractSignStrExt},
	model::Cs,
};

impl AbstractMathCs2 for Cs<2> {
	/// 📚 【 POL】: Długość rzutu (promień) na płaszczyznę XY.
	/// 📚 【 ENG】: Projection length (radius) on the XY plane.
	#[rustfmt::skip] #[inline]	fn rxy(&self) -> f64 { self.0[0].hypot(self.0[1]) }

	/// 📚 【 POL】: Azymut matematyczny (od osi X w stronę Y, CCW).
	/// 📚 【 ENG】: Mathematical azimuth (from X-axis towards Y, CCW).
	#[rustfmt::skip] #[inline]	fn arctan_y_x(&self) -> f64 { self.0[1].atan2(self.0[0]) }

	/// 📚 【 POL】: Azymut kompasowy/geodezyjny (od osi Y w stronę X, CW).
	/// 📚 【 ENG】: Compass/geodetic azimuth (from Y-axis towards X, CW).
	#[rustfmt::skip] #[inline]	fn arctan_x_y(&self) -> f64 { self.0[0].atan2(self.0[1]) }

	/// 📚 【 POL】: Konwertuje wektor kartezjański [X, Y] na wektor biegunowy [R, Φ] w obrębie Cs2.
	/// 📚 【 ENG】: Converts a Cartesian vector [X, Y] to a polar vector [R, Φ] within Cs2.
	#[rustfmt::skip] #[inline]	fn to_rf_from_xy(&self) -> Cs<2> { Cs([self.rxy(), self.arctan_y_x()]) }

	/// 📚 【 POL】: Przekształca współrzędne geograficzne [Szerokość, Długość] w radianach na wektor 3D ECEF (X, Y, Z).
	/// 📚 【 ENG】: Transforms geographic coordinates [Latitude, Longitude] in radians to a 3D ECEF vector (X, Y, Z).
	/// ⚙️ 【 POL】: Wykorzystuje zadany promień 'r' (np. promień Ziemi).
	/// ⚙️ 【 ENG】: Uses the specified radius 'r' (e.g., Earth's radius).
	fn to_ecef_from_rad_sn_we(&self, r: f64) -> Cs<3> {
		let (sin_lat, cos_lat) = self.0[0].sin_cos();
		let (sin_lon, cos_lon) = self.0[1].sin_cos();

		// Oś X: 0°N, 0°E (Greenwich na równiku)
		// Oś Y: 0°N, 90°E (Ocean Indyjski na równiku)
		// Oś Z: 90°N (Biegun Północny)
		// Oś X: 0°N, 0°E | Oś Y: 0°N, 90°E | Oś Z: 90°N
		Cs([
			r * cos_lat * cos_lon, // X
			r * cos_lat * sin_lon, // Y
			r * sin_lat,           // Z
		])
	}

	/// 📚 【 POL】: Zwraca numer ćwiartki na płaszczyźnie XY (1-4).
	/// 📚 【 ENG】: Returns the quadrant number on the XY plane (1-4).
	#[rustfmt::skip] #[inline]
	fn q(&self) -> u8 {
		match (self.0[0] >= 0.0, self.0[1] >= 0.0) {
			(true, true) => 1, (false, true) => 2, (false, false) => 3, (true, false) => 4,
		}
	}

	/// 📚 【 POL】: Zwraca znaki kierunkowe osi X i Y w formie tablicy stringów (np. ["+", "-"]).
	/// 📚 【 ENG】: Returns the directional signs of the X and Y axes as an array of strings (e.g., ["+", "-"]).
	#[rustfmt::skip] #[inline]
	fn q_sign(&self) -> [&'static str; 2] { [self.0[0].sign_str(), self.0[1].sign_str()] }

	/// 📚 【 POL】: Kwadrat długości rzutu XY (szybsza alternatywa dla rxy).
	/// 📚 【 ENG】: Squared projection length XY (faster alternative to rxy).
	#[rustfmt::skip] #[inline]	fn rxy_sq(&self) -> f64 { self.0[0] * self.0[0] + self.0[1] * self.0[1] }

	/// 📚 【 POL】: Iloczyn wektorowy 2D (wyznacznik). Znak określa orientację (lewo/prawo).
	/// 📚 【 ENG】: 2D cross product (determinant). The sign determines orientation (left/right).
	#[rustfmt::skip] #[inline]
	fn cross(&self, other: &Cs<2>) -> f64 { self.0[0] * other.0[1] - self.0[1] * other.0[0] }

	/// 📚 【 POL】: Zwraca wektor prostopadły obrócony o 90° w lewo (CCW).
	/// 📚 【 ENG】: Returns a perpendicular vector rotated 90° to the left (CCW).
	#[rustfmt::skip] #[inline]
	fn perp(&self) -> Cs<2> { Cs([-self.0[1], self.0[0]]) }
}

```

### 033: `./src/libs/cs/math/d3.rs`

```rust
// 📃 ./src/libs/cs/math/d3.rs

use crate::libs::{
	angle::AbstractAngle,
	cs::{
		abstracts::{AbstractMathCs3, AbstractSignStrExt},
		model::Cs,
	},
	tolerance,
};

impl AbstractMathCs3 for Cs<3> {
	/// 📚 【 POL】: Długość rzutu (promień) na płaszczyznę XY.
	/// 📚 【 ENG】: Projection length (radius) on the XY plane.
	#[rustfmt::skip] #[inline]	fn rxy(&self)  -> f64 { self.0[0].hypot(self.0[1]) }

	/// 📚 【 POL】: Długość rzutu (promień) na płaszczyznę XZ.
	/// 📚 【 ENG】: Projection length (radius) on the XZ plane.
	#[rustfmt::skip] #[inline]	fn rxz(&self)  -> f64 { self.0[0].hypot(self.0[2]) }

	/// 📚 【 POL】: Długość rzutu (promień) na płaszczyznę YZ.
	/// 📚 【 ENG】: Projection length (radius) on the YZ plane.
	#[rustfmt::skip] #[inline]	fn ryz(&self)  -> f64 { self.0[1].hypot(self.0[2]) }

	/// 📚 【 POL】: Pełna długość wektora w przestrzeni XYZ.
	/// 📚 【 ENG】: Full vector length in XYZ space.
	#[rustfmt::skip] #[inline]	fn rxyz(&self) -> f64 { self.0[0].hypot(self.0[1]).hypot(self.0[2]) }

	// --- KĄTY PŁASKIE (AZYMUTY MATEMATYCZNE CCW) ---

	/// 📚 【 POL】: Azymut na płaszczyźnie XY (od X do Y).
	/// 📚 【 ENG】: Azimuth on the XY plane (from X to Y).
	#[rustfmt::skip] #[inline]	fn arctan_y_x(&self) -> f64 { self.0[1].atan2(self.0[0]) }

	/// 📚 【 POL】: Azymut na płaszczyźnie XZ (od X do Z).
	/// 📚 【 ENG】: Azimuth on the XZ plane (from X to Z).
	#[rustfmt::skip] #[inline]	fn arctan_z_x(&self) -> f64 { self.0[2].atan2(self.0[0]) }

	/// 📚 【 POL】: Azymut na płaszczyźnie YZ (od Y do Z).
	/// 📚 【 ENG】: Azimuth on the YZ plane (from Y to Z).
	#[rustfmt::skip] #[inline]	fn arctan_z_y(&self) -> f64 { self.0[2].atan2(self.0[1]) }

	// --- KĄTY KOMPASOWE / MAPOWE (CW, 0° NA OSI PIONOWEJ) ---

	/// 📚 【 POL】: Azymut kompasowy na XY (0° na osi Y).
	/// 📚 【 ENG】: Compass azimuth on XY (0° on Y-axis).
	#[rustfmt::skip] #[inline]	fn arctan_x_y(&self) -> f64 { self.0[0].atan2(self.0[1]) }

	/// 📚 【 POL】: Azymut kompasowy na XZ (0° na osi Z).
	/// 📚 【 ENG】: Compass azimuth on XZ (0° on Z-axis).
	#[rustfmt::skip] #[inline]	fn arctan_x_z(&self) -> f64 { self.0[0].atan2(self.0[2]) }

	/// 📚 【 POL】: Azymut kompasowy na YZ (0° na osi Z).
	/// 📚 【 ENG】: Compass azimuth on YZ (0° on Z-axis).
	#[rustfmt::skip] #[inline]	fn arctan_y_z(&self) -> f64 { self.0[1].atan2(self.0[2]) }

	// --- KĄTY PRZESTRZENNE (INKLINACJA) ---

	/// 📚 【 POL】: Kąt między wektorem a osią X.
	/// 📚 【 ENG】: Angle between the vector and the X-axis.
	#[rustfmt::skip] #[inline]	fn arccos_x_rxyz(&self) -> f64 { let r = self.rxyz(); if tolerance::is_zero(r) { 0.0 } else { (self.0[0] / r).clamp(-1.0, 1.0).acos() } }

	/// 📚 【 POL】: Kąt między wektorem a osią Y.
	/// 📚 【 ENG】: Angle between the vector and the Y-axis.
	#[rustfmt::skip] #[inline]	fn arccos_y_rxyz(&self) -> f64 { let r = self.rxyz(); if tolerance::is_zero(r) { 0.0 } else { (self.0[1] / r).clamp(-1.0, 1.0).acos() } }

	/// 📚 【 POL】: Kąt między wektorem a osią Z (Inklinacja sferyczna).
	/// 📚 【 ENG】: Angle between the vector and the Z-axis (Spherical inclination).
	#[rustfmt::skip] #[inline]	fn arccos_z_rxyz(&self) -> f64 { let r = self.rxyz(); if tolerance::is_zero(r) { 0.0 } else { (self.0[2] / r).clamp(-1.0, 1.0).acos() } }

	// --- KONWERSJE 3D -> 2D (RZUTY BIEGUNOWE) ---

	/// 📚 【 POL】: Rzutuje wektor 3D na płaszczyznę XY w formacie biegunowym [R, Φ].
	/// 📚 【 ENG】: Projects a 3D vector onto the XY plane in polar format [R, Φ].
	#[rustfmt::skip] #[inline]	fn to_rf_from_xy(&self) -> Cs<2> { Cs([self.rxy(), self.arctan_y_x()]) }

	/// 📚 【 POL】: Rzutuje wektor 3D na płaszczyznę XZ w formacie biegunowym [R, Φ].
	/// 📚 【 ENG】: Projects a 3D vector onto the XZ plane in polar format [R, Φ].
	#[rustfmt::skip] #[inline]	fn to_rf_from_xz(&self) -> Cs<2> { Cs([self.rxz(), self.arctan_z_x()]) }

	/// 📚 【 POL】: Rzutuje wektor 3D na płaszczyznę YZ w formacie biegunowym [R, Φ].
	/// 📚 【 ENG】: Projects a 3D vector onto the YZ plane in polar format [R, Φ].
	#[rustfmt::skip] #[inline]	fn to_rf_from_yz(&self) -> Cs<2> { Cs([self.ryz(), self.arctan_z_y()]) }

	// --- KONWERSJE 3D -> 3D (UKŁADY CYLINDRYCZNE I SFERYCZNE) ---

	/// 📚 【 POL】: Konwertuje XYZ na układ cylindryczny względem osi X [R_yz, Φ_zy, X].
	/// 📚 【 ENG】: Converts XYZ to a cylindrical system relative to the X-axis [R_yz, Φ_zy, X].
	#[rustfmt::skip] #[inline]	fn to_rfx_from_xyz(&self) -> Cs<3> { Cs([self.ryz(),  self.arctan_z_y(), self.0[0]]) }

	/// 📚 【 POL】: Konwertuje XYZ na układ cylindryczny względem osi Y [R_xz, Φ_zx, Y].
	/// 📚 【 ENG】: Converts XYZ to a cylindrical system relative to the Y-axis [R_xz, Φ_zx, Y].
	#[rustfmt::skip] #[inline]	fn to_rfy_from_xyz(&self) -> Cs<3> { Cs([self.rxz(),  self.arctan_z_x(), self.0[1]]) }

	/// 📚 【 POL】: Konwertuje XYZ na układ cylindryczny względem osi Z [R_xy, Φ_yx, Z].
	/// 📚 【 ENG】: Converts XYZ to a cylindrical system relative to the Z-axis [R_xy, Φ_yx, Z].
	#[rustfmt::skip] #[inline]	fn to_rfz_from_xyz(&self) -> Cs<3> { Cs([self.rxy(),  self.arctan_y_x(), self.0[2]]) }

	/// 📚 【 POL】: Konwertuje XYZ na pełny układ sferyczny [R_xyz, Φ_yx, Θ_zr].
	/// 📚 【 ENG】: Converts XYZ to a full spherical system [R_xyz, Φ_yx, Θ_zr].
	#[rustfmt::skip] #[inline]	fn to_rft_from_xyz(&self) -> Cs<3> { Cs([self.rxyz(), self.arctan_y_x(), self.arccos_z_rxyz()]) }

	// --- GEODEZJA ---

	/// 📚 【 POL】: Tworzy wektor ECEF (XYZ) bezpośrednio z danych DMS i promienia.
	/// 📚 【 ENG】: Creates an ECEF vector (XYZ) directly from DMS data and radius.
	#[rustfmt::skip]
	fn to_ecef_from_dms_sn_we(
		sn_d: i16, sn_m: u8, sn_s: f32,
		we_d: i16, we_m: u8, we_s: f32,
		r: f64
	) -> Self {
		use crate::libs::angle::Angle;
		let lat_rad = Angle::from_dms(sn_d, sn_m, sn_s).rad();
		let lon_rad = Angle::from_dms(we_d, we_m, we_s).rad();

		let (sin_lat, cos_lat) = lat_rad.sin_cos();
		let (sin_lon, cos_lon) = lon_rad.sin_cos();

		Cs([
			r * cos_lat * cos_lon,
			r * cos_lat * sin_lon,
			r * sin_lat
		])
	}

	/// 📚 【 POL】: Konwertuje wektor XYZ na geodezyjny format DMS (Szerokość, Długość).
	/// 📚 【 ENG】: Converts a XYZ vector to geodetic DMS format (Latitude, Longitude).
	#[rustfmt::skip]
	fn to_dms_sn_we_from_xyz(&self) -> crate::libs::cs::model::CoordsSphericalEcefSnWeDms {
		use crate::libs::angle::Angle;
		use crate::libs::tolerance;

		let r = self.rxyz();

		// Zabezpieczenie przed osobliwością w samym jądrze Ziemi (r = 0)
		let (lat_rad, lon_rad) = if tolerance::is_zero(r) {
			(0.0, 0.0)
		} else {
			(
				(self.0[2] / r).clamp(-1.0, 1.0).asin(), // Szerokość z osi Z
				self.0[1].atan2(self.0[0])               // Długość z płaszczyzny XY
			)
		};

		// Rzutujemy radiany na nasz izolator Angle
		let lat_angle = Angle::from_rad(lat_rad);
		let lon_angle = Angle::from_rad(lon_rad);

		// Dekodujemy do składowych (Stopnie, Minuty, Sekundy)
		let (lat_d, lat_m, lat_s) = lat_angle.to_dms();
		let (lon_d, lon_m, lon_s) = lon_angle.to_dms();

		// Pakujemy w DTO
		crate::libs::cs::model::CoordsSphericalEcefSnWeDms {
			sn_lat_d: lat_d as i8,
			sn_lat_m: lat_m,
			sn_lat_s: lat_s,
			we_lon_d: lon_d,
			we_lon_m: lon_m,
			we_lon_s: lon_s,
		}
	}

	// --- ANALIZA PRZESTRZENNA ---

	/// 📚 【 POL】: Zwraca numer oktantu (1-8) w którym znajduje się wektor.
	/// 📚 【 ENG】: Returns the octant number (1-8) where the vector is located.
	#[rustfmt::skip] #[inline]
	fn q(&self) -> u8 {
		match (self.0[0] >= 0.0, self.0[1] >= 0.0, self.0[2] >= 0.0) {
			(true, true, true)   => 1, (false, true, true)  => 2, (false, false, true) => 3, (true, false, true)  => 4,
			(true, true, false)  => 5, (false, true, false) => 6, (false, false, false)=> 7, (true, false, false) => 8,
		}
	}

	/// 📚 【 POL】: Zwraca znaki kierunkowe osi XYZ (np. ["+", "-", "+"]).
	/// 📚 【 ENG】: Returns the directional signs of the XYZ axes (e.g., ["+", "-", "+"]).
	#[rustfmt::skip] #[inline]
	fn q_sign(&self) -> [&'static str; 3] {
		[self.0[0].sign_str(), self.0[1].sign_str(), self.0[2].sign_str()]
	}

	/// 📚 【 POL】: Kwadrat pełnej długości wektora 3D.
	/// 📚 【 ENG】: Squared full length of the 3D vector.
	#[rustfmt::skip] #[inline]	fn rxyz_sq(&self) -> f64 { self.0[0] * self.0[0] + self.0[1] * self.0[1] + self.0[2] * self.0[2] }

	/// 📚 【 POL】: Kwadrat długości rzutu na płaszczyznę XY.
	/// 📚 【 ENG】: Squared projection length on the XY plane.
	#[rustfmt::skip] #[inline]	fn rxy_sq(&self) -> f64 { self.0[0] * self.0[0] + self.0[1] * self.0[1] }

	/// 📚 【 POL】: Kwadrat długości rzutu na płaszczyznę XZ.
	/// 📚 【 ENG】: Squared projection length on the XZ plane.
	#[rustfmt::skip] #[inline]	fn rxz_sq(&self) -> f64 { self.0[0] * self.0[0] + self.0[2] * self.0[2] }

	/// 📚 【 POL】: Kwadrat długości rzutu na płaszczyznę YZ.
	/// 📚 【 ENG】: Squared projection length on the YZ plane.
	#[rustfmt::skip] #[inline]	fn ryz_sq(&self) -> f64 { self.0[1] * self.0[1] + self.0[2] * self.0[2] }

	// --- NORMALIZACJE RZUTOWE ---

	/// 📚 【 POL】: Normalizuje rzut XY do długości 1.0, zachowując składową Z.
	/// 📚 【 ENG】: Normalizes the XY projection to length 1.0, preserving the Z component.
	#[rustfmt::skip] #[inline]
	fn normalize_rxy_projection(&self) -> Cs<3> {
		let r = self.rxy();
		if tolerance::is_zero(r) { Cs([0.0, 0.0, self.0[2]]) } else { Cs([self.0[0] / r, self.0[1] / r, self.0[2]]) }
	}

	/// 📚 【 POL】: Normalizuje rzut XZ do długości 1.0, zachowując składową Y.
	/// 📚 【 ENG】: Normalizes the XZ projection to length 1.0, preserving the Y component.
	#[rustfmt::skip] #[inline]
	fn normalize_rxz_projection(&self) -> Cs<3> {
		let r = self.rxz();
		if tolerance::is_zero(r) { Cs([0.0, self.0[1], 0.0]) } else { Cs([self.0[0] / r, self.0[1], self.0[2] / r]) }
	}

	/// 📚 【 POL】: Normalizuje rzut YZ do długości 1.0, zachowując składową X.
	/// 📚 【 ENG】: Normalizes the YZ projection to length 1.0, preserving the X component.
	#[rustfmt::skip] #[inline]
	fn normalize_ryz_projection(&self) -> Cs<3> {
		let r = self.ryz();
		if tolerance::is_zero(r) { Cs([self.0[0], 0.0, 0.0]) } else { Cs([self.0[0], self.0[1] / r, self.0[2] / r]) }
	}

	/// 📚 【 POL】: Iloczyn wektorowy (Cross product). Zwraca wektor ortogonalny.
	/// 📚 【 ENG】: Cross product. Returns an orthogonal vector.
	#[rustfmt::skip] #[inline]
	fn cross(&self, other: &Cs<3>) -> Cs<3> {
		Cs([
			self.0[1] * other.0[2] - self.0[2] * other.0[1],
			self.0[2] * other.0[0] - self.0[0] * other.0[2],
			self.0[0] * other.0[1] - self.0[1] * other.0[0]
		])
	}
}

```

### 034: `./src/libs/cs/model.rs`

```rust
// 📃 ./src/libs/cs/model.rs
use crate::libs::angle::Angle;

// =============================================================================
// 1. RDZEŃ GENERYCZNY (BASE MODEL)
// =============================================================================

/// 📚 【 POL】: Generyczny wrapper dla tablic o stałym rozmiarze, ograniczony do wymiarów 2D i 3D.
/// 📚 【 ENG】: Generic wrapper for fixed-size arrays, restricted to 2D and 3D dimensions.
///
/// ⚠️ 【 POL】: Implementacja ściśle ograniczona do N=2 lub N=3. Inne wymiary nie są wspierane.
/// ⚠️ 【 ENG】: Implementation strictly limited to N=2 or N=3. Other dimensions are not supported.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Cs<const N: usize>(pub [f64; N]);

// =============================================================================
// 2. STRUKTURY DANYCH WSPÓŁRZĘDNYCH (COORDS MODELS)
// =============================================================================

// --- KARTEZJAŃSKIE ---

/// 📚 【 POL】: Współrzędne 2D w układzie kartezjańskim.
/// 📚 【 ENG】: 2D coordinates in the Cartesian system.
/// 💡 Może reprezentować dowolną płaszczyznę rzutowania (XY, XZ, YZ) traktowaną jako przestrzeń dwuwymiarowa.
/// 💡 Can represent any projection plane (XY, XZ, YZ) treated as a two-dimensional space.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CoordsXy {
	pub x: f64,
	pub y: f64,
}

/// 📚 【 POL】: Współrzędne 3D w układzie kartezjańskim (Przestrzeń XYZ).
/// 📚 【 ENG】: 3D coordinates in the Cartesian system (XYZ Space).
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CoordsXyz {
	pub x: f64,
	pub y: f64,
	pub z: f64,
}

// --- BIEGUNOWE I CYLINDRYCZNE ---

/// 📚 【 POL】: Współrzędne 2D w układzie biegunowym (Promień, Azymut).
/// 📚 【 ENG】: 2D coordinates in the Polar system (Radius, Azimuth).
/// 💡 Może reprezentować dowolną płaszczyznę rzutowania (XY, XZ, YZ) traktowaną jako przestrzeń dwuwymiarowa.
/// 💡 Can represent any projection plane (XY, XZ, YZ) treated as a two-dimensional space.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CoordsPolar {
	pub r_d2: f64,
	pub f_y_x: f64, // w radianach
}

/// 📚 【 POL】: Współrzędne 3D w układzie cylindrycznym względem osi Z.
/// 📚 【 ENG】: 3D coordinates in the Cylindrical system relative to the Z-axis.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CoordsCylindricalZ {
	pub r_d2: f64,
	pub f_y_x: f64, // w radianach
	pub z: f64,
}

/// 📚 【 POL】: Współrzędne 3D w układzie cylindrycznym względem osi Y.
/// 📚 【 ENG】: 3D coordinates in the Cylindrical system relative to the Y-axis.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CoordsCylindricalY {
	pub r_d2: f64,
	pub f_z_x: f64, // w radianach
	pub y: f64,
}

/// 📚 【 POL】: Współrzędne 3D w układzie cylindrycznym względem osi X.
/// 📚 【 ENG】: 3D coordinates in the Cylindrical system relative to the X-axis.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CoordsCylindricalX {
	pub r_d2: f64,
	pub f_z_y: f64, // w radianach
	pub x: f64,
}

// --- SFERYCZNE I GEOGRAFICZNE ---

/// 📚 【 POL】: Współrzędne 3D w układzie sferycznym (Promień, Azymut, Inklinacja).
/// 📚 【 ENG】: 3D coordinates in the Spherical system (Radius, Azimuth, Inclination).
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CoordsSpherical {
	pub r_d3: f64,
	pub f_y_x: f64, // w radianach (Azymut w płaszczyźnie XY)
	pub t_z_r: f64, // w radianach (Inklinacja od osi Z)
}

// 📚 【 POL】: Współrzędne geograficzne w formacie DMS (Stopnie, Minuty, Sekundy).
/// 📚 【 ENG】: Geographic coordinates in DMS format (Degrees, Minutes, Seconds).
/// 🗺️ Orientacja: Nz90Ex0 (Oś Z: Biegun N, Oś X: Greenwich).
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CoordsSphericalEcefSnWeDms {
	pub sn_lat_d: i8,  // Szerokość stopnie (-90 do 90)
	pub sn_lat_m: u8,  // Szerokość minuty (0 do 59)
	pub sn_lat_s: f32, // Szerokość sekundy (0.0 do 59.99999)
	pub we_lon_d: i16, // Długość stopnie (-180 do 180)
	pub we_lon_m: u8,  // Długość minuty (0 do 59)
	pub we_lon_s: f32, // Długość sekundy (0.0 do 59.99999)
	                   //pub alt: f64,    // Wysokość nad poziomem morza (m)
}

/// 📚 【 POL】: Współrzędne geograficzne w formacie DDD (Stopnie Dziesiętne).
/// 📚 【 ENG】: Geographic coordinates in DDD format (Decimal Degrees).
/// 🗺️ Orientacja: Nz90Ex0 (Oś Z: Biegun N, Oś X: Greenwich).
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CoordsSphericalEcefSnWeDdd {
	pub sn_lat: Angle, // Szerokość (-90.0 do 90.0)
	pub we_lon: Angle, // Długość (-180.0 do 180.0)
	                   //pub alt: f64,    // Wysokość nad poziomem morza (m)
}

```

### 035: `./src/libs/cs/types.rs`

```rust
// 📃 ./src/libs/cs/types.rs

use super::model::Cs;

/// 📚 【 POL】: Alias typu dla współrzędnych dwuwymiarowych (płaszczyzna).
/// 📚 【 ENG】: Type alias for two-dimensional coordinates (plane).
pub type Cs2 = Cs<2>;

/// 📚 【 POL】: Alias typu dla współrzędnych trójwymiarowych (przestrzeń).
/// 📚 【 ENG】: Type alias for three-dimensional coordinates (space).
pub type Cs3 = Cs<3>;

/// 📚 【 POL】: Marker trait ograniczający implementację metod wyłącznie do wymiarów N=2 lub N=3.
/// 📚 【 ENG】: Marker trait restricting method implementation exclusively to dimensions N=2 or N=3.
pub trait Dim {}

// Pozwalamy na istnienie geometrii tylko w 2D i 3D
impl Dim for Cs<2> {}
impl Dim for Cs<3> {}

```

### 036: `./src/libs/cs/utils.rs`

```rust
// 📃 ./src/libs/cs/utils.rs

// 📚 【 POL】: Implementujemy trait dla f64 (rdzeń) oraz i8/i16 (DMS).
// 📚 【 ENG】: Implementing trait for f64 (core) and i8/i16 (DMS).
crate::impl_sign_str!(f64, 0.0);
crate::impl_sign_str!(i8, 0);
crate::impl_sign_str!(i16, 0);

// impl AbstractSignStrExt for f64 {
//     #[inline] fn sign_str(self) -> &'static str { if self >= 0.0 { "+" } else { "-" } }
// }

```

### 037: `./src/libs/frac.rs`

```rust
// 📃 ./src/libs/frac.rs

use std::f64::consts;

use super::tolerance;

/// 📚 【 POL】: Konstruktor makrowy dla ułamków zwykłych. Zapobiega błędom dzielenia całkowitoliczbowego.
/// 📚 【 ENG】: Macro constructor for common fractions. Prevents integer division errors.
///
/// # Examples: `frac![1 / 2]` -> 0.5 (f64), `frac![5]` -> 5.0 (f64)
#[macro_export]
macro_rules! frac {
	($n:tt / $d:tt) => {
		(($n as f64) / ($d as f64))
	};
	($n:tt) => {
		($n as f64)
	};
}

/// 📚 【 POL】: Konstruktor makrowy dla wielokrotności liczby PI. Zwraca surową wartość f64.
/// 📚 【 ENG】: Macro constructor for multiples of PI. Returns a raw f64 value.
///
/// # Examples: `frac_pi![1 / 2]` -> 1.5707... (PI/2)
#[macro_export]
macro_rules! frac_pi {
	($n:tt / $d:tt) => {
		(($n as f64) / ($d as f64)) * consts::PI
	};
	($n:tt) => {
		($n as f64) * consts::PI
	};
}

/// 📚 【 POL】: Aproksymuje wartość zmiennoprzecinkową do ułamka zwykłego (licznik, mianownik).
/// 📚 【 ENG】: Approximates a floating-point value to a common fraction (numerator, denominator).
///
/// ⚙️ 【 POL】: Wykorzystuje algorytm ułamków łańcuchowych (Continued Fractions) z limitem mianownika 10^6.
/// ⚙️ 【 ENG】: Employs the Continued Fractions algorithm with a denominator limit of 10^6.
pub fn as_frac(value: f64) -> (f64, f64) {
	if tolerance::is_zero(value) {
		return (0.0, 1.0);
	}

	let sign = value.signum();
	let mut val = value.abs();

	let mut num_prev = 0.0;
	let mut den_prev = 1.0;
	let mut num_curr = 1.0;
	let mut den_curr = 0.0;

	for _ in 0..64 {
		let a = val.floor();
		let num_next = a * num_curr + num_prev;
		let den_next = a * den_curr + den_prev;

		if den_next > 1_000_000.0 {
			break;
		}

		num_prev = num_curr;
		den_prev = den_curr;
		num_curr = num_next;
		den_curr = den_next;

		let diff = val - a;

		if tolerance::is_zero(diff) {
			break;
		}
		val = 1.0 / diff;
	}

	(sign * num_curr, den_curr)
}

/// 📚 【 POL】: Rozkłada wartość na ułamek wielokrotności liczby PI (odwrotność makra frac_pi!).
/// 📚 【 ENG】: Decomposes a value into a fraction of PI (inverse of frac_pi! macro).
pub fn as_frac_pi(value: f64) -> (f64, f64) { as_frac(value / consts::PI) }

```

### 038: `./src/libs/tolerance.rs`

```rust
// 📃 ./src/libs/tolerance.rs

/// 📚 【 POL】: Absolutna tolerancja przestrzenna używana do weryfikacji koincydencji punktów i długości wektorów.
/// 📚 【 ENG】: Absolute spatial tolerance used for point coincidence and vector length verification.
pub const EPSILON_SPATIAL: f64 = 1e-9;

/// 📚 【 POL】: Weryfikuje, czy wartość mieści się w zakresie błędu numerycznego bliskiego zeru.
/// 📚 【 ENG】: Checks if the value falls within the numerical error range close to zero.
#[inline]
pub fn is_zero(value: f64) -> bool { value.abs() <= EPSILON_SPATIAL }

/// 📚 【 POL】: Porównuje dwie wartości zmiennoprzecinkowe z uwzględnieniem progu tolerancji jądra.
/// 📚 【 ENG】: Compares two floating-point values considering the kernel's tolerance threshold.
#[inline]
pub fn is_equal(a: f64, b: f64) -> bool { (a - b).abs() <= EPSILON_SPATIAL }

```





---

> | Property | Value |
> | ---: | :--- |
> | **Tool** | `cargo-plot v0.2.0` |
> | **Input** | `.` |
> | **Command** | `cargo plot -o "./.prompt/.src/" -p "./target/+" -p "!./target/" -p "./.git/+" -p "!./.git/" -p "./.github/+" -p "!./.github/" -p "./.vscode/+" -p "!./.vscode/" -p "./.prompt/.src/+" -p "!./.prompt/.src/" -p "./.prompt/.err/+" -p "!./.prompt/.err/" -p "./LICENSE-APACHE" -p "./LICENSE-MIT" -p "*.lock" -p ".gitattributes" -p ".gitignore" -x -v grid --save-archive -b -a --lang en` |
> | **TimeTag** | `2026Q2D092W14_Thu02Apr_194922305` |
> | **Links** | [Crates.io](https://crates.io/crates/cargo-plot) \| [GitHub](https://github.com/j-Cis/cargo-plot/releases) |
> | **Links** | `cargo install cargo-plot` |
> | **Help** | `cargo plot --help` |

---
