parted mkpart söz dizimi + canlı autologin çakışması düzeltmeleri

- Manuel bölümleme parted söz dizimi disk etiketine göre seçiliyor
  (GPT: ad+fs, msdos: primary/logical+fs); etiket parted print'ten
  okunuyor, boş diske mktable kuruluyor
- Yerelleşmiş parted çıktısı P0 veri kaybı yapıyordu: LC_ALL=C ile
  okunuyor, ayrıştırıcı Türkçe başlığı da tanıyor, mktable öncesi
  fiziksel bölüm kilidi var
- Otomatik mod mkpart 4 argümana geçti (ad + fs türü)
- GPT '/' adı sfdisk ile boşaltılıyor (warn-only, kurulumu durdurmaz)
- ConfigureAutologinJob: /etc/sddm.conf.d/10-yali-autologin.conf
  kanonik dosya, hedeften oturum tespiti, kapalıyken canlı
  config'in ezilmesi (boş User= / lightdm satır temizliği)
- Checkbox etiketi: 'Otomatik oturum aç' / 'Log in automatically'
- 158 test, 0 uyarı

.gitignore

@@ -14,5 +14,11 @@ Cargo.lock
 *.swo
 *.bak
 
+# Eski sürüm yedekleri (git'e alınmamalı — git zaten var)
+src/steps/*_orj*.rs*
+src/steps/partition.rs_[0-9]*
+*_copy.rs
+*_copy.toml*
+
 # OS files
 .DS_Store

.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-    "rust-analyzer.checkOnSave": false
-}

AGENTS.md

@@ -0,0 +1,966 @@
+# AGENTS.md — Yali-rs Geliştirme Notları
+
+> Ajan oturumları arasında süreklilik için.
+> Son güncelleme: **26 Eylül 2026** — çoklu disk bölümleme + güvenlik düzeltmeleri.
+
+---
+
+## 🚨 EN ÖNEMLİ: 22de7d5 regresyonu (25 Ağu 2026)
+
+**Bu dosyayı okuyan her ajan önce bu bölümü okumalı.**
+
+Commit `22de7d5` — *"Dead code uyarılarını gidermek için `#[allow(dead_code)]`
+eklendi"* (Devin AI ajanı) — mesajı üç tane `#[allow]` eklemekle
+sınırlıydı. Gerçekte **`src/steps/partition.rs`'i 2438 satırdan 811
+satıra düşürdü: 1804 satır silindi.**
+
+```
+src/steps/partition.rs | 1978 +++++-------------------------------------------
+                       181 insertions(+), 1804 deletions(-)
+```
+
+### Silinenler
+Tüm manuel bölümleme arayüzü: ekle/düzenle/sil onayı/LVM VG/LVM LV
+diyalogları, `draw_partition_table_header`, `manual_dual_bars`,
+`TableRow` enum'u, `disk_size_mb`, `used_mb_on_disk`, `draw_layout_bar`,
+`bar_style`, `partition_bar`, `format_number_thousands` ve **21 birim testi**.
+
+### Etkisi
+Manuel bölümleme **fiilen işlevsiz** hâle gelmişti:
+- "+ Ekle" / "Düzenle" / "Sil" butonları yalnızca **kimsenin okumadığı**
+  bayraklar set ediyordu → hiçbir diyalog açılmıyordu
+- `delete = true` **hiçbir yerden set edilmiyordu** →
+  `CustomPartitionJob`'un FAZ A'sı (`parted rm`) erişilemez
+- `state.volume_groups` / `logical_volumes` **hiçbir yerden yazılmıyordu**
+  → `SetupLvmJob` hep boş vektör alıyordu, **LVM tamamen erişilemez**
+- `#[allow(dead_code)]` derleyicinin bu boşluğu bildirmesini bastırdı
+
+### Geri alınışı
+`8c6dc08` ile düzeltildi. Yedek: tag `backup-before-unrevert-22de7d5`,
+branch `backup/pre-unrevert` (a5d4627 = geri alma öncesi HEAD).
+`8633422`'nin üç validasyon düzeltmesi geri almanın üzerine yeniden
+uygulandı; bir test (`manual_mode_complete_with_valid_partitions`)
+güncellendi, `selected_disk` kuralı için yeni test eklendi.
+
+### DERS — TEKRARLANSIN
+1. **Bir commit mesajı ne yaptığını tam anlatmıyorsa, diff'i oku.**
+   `-1804` satır "dead code temizliği" değildir.
+2. **`#[allow(dead_code)]` bir teşhis aracıdır, tedavi değil.** Bir şey
+   kullanılmıyorsa ya silinmeli ya da bağlanmalı; susturmak, altta
+   yatan boşluğu gizler. Bu projede tam olarak bu oldu.
+3. **Yedek dosyaları git'e commit etme.** `partition.rs_24082026` gibi
+   dosyalar repoya `git rm` edildi, `.gitignore`'a desen eklendi.
+   Yedek gerekiyorsa **git history**'dir, çalışma ağacı değil.
+4. Kullanılmıyor görünen bir adımı **silmeden önce** sihirbaza
+   bağlı olup olmadığını yazılım olarak doğrula (grep yeterli değil —
+   `on_enter`'ın ne zaman çağrıldığına bak).
+
+---
+
+## Proje Tasarım Kararı: SQUASHFS KURULUMU
+
+**YALI kurulu sistemi ISO'nun squashfs'inden kopyalar** (`CopyFilesJob`
+rsync). Bunun temel sonucu:
+
+> ISO'da hangi paketler, ekran yöneticisi ve masaüstü ortamı varsa,
+> kurulum onları **zaten içerir**.
+
+Bu yüzden sihirbaz **paket seçimi, ekran yöneticisi seçimi veya lisans
+kabulü sunmaz** — sunduğu ayarları kopyalama zaten ezdiği için
+yanıltıcı olurdu.
+
+### Netinstall gelecekte ayrı bir proje
+İki ayrı proje çıkacak:
+1. **Bu proje** — squashfs'i diske kopyalar (mevcut akış)
+2. **Netinstall** — paketleri ağdan kurar, squashfs akışı iptal eder
+
+`src/steps/netinstall.rs` ve `src/jobs/netinstall.rs` **dormant** olarak
+repoda duruyor. Etkinleştirme koşulu `src/steps/mod.rs`'te yazılı:
+- `main.rs`'de `steps` vektörüne `Box::new(steps::netinstall::NetinstallStep)`
+  (Bootloader ile Summary arasına)
+- `JobQueueConfig::selected_package_groups` doldurulmalı
+- `InstallExtraPackagesJob` kuyruğa alınmalı
+
+`#[allow(dead_code)]` **yalnızca bu üç dormant modüle** ve **yalnızca
+belgelenmiş kasıtlı uyku için** konmuştur. Modül dışındaki taze ölü kod
+yine uyarı üretir.
+
+### Ekran yöneticisi tespiti (çalışma zamanında)
+`ConfigureAutologinJob` DM'i **seçmez, tespit eder**:
+`detect_display_manager()` → `/usr/bin/{sddm,lightdm,gdm}` yoksa yapılandırma
+dizini. Bu iş `CopyFilesJob`'dan sonra çalıştığı için `mount` doludur.
+
+> Önceden `state.display_manager`'a (GlobalState'in **sabit `"sddm"`
+> varsayılanı**) göre dallanılıyordu. ISO lightdm kullanıyorsa
+> `lightdm.conf`'a dokunulmuyor, `sddm.conf` yazılıyor ve otomatik giriş
+> sessizce çalışmıyordu.
+
+### ⭐ Canlı ISO autologin'i + ters görünen checkbox (29 Eyl 2026)
+
+ISO **canlı kullanıcı için çalışan bir autologin config'i** taşır
+(kullanıcı doğruladı: canlı açılış otomatik giriyor). Bu iki arızayı
+birlikte üretiyordu:
+
+| Kutu | Olan | Neden |
+|---|---|---|
+| tikli | login ekranı | bizim config `/usr/lib/...` altına yazılıyordu → `/etc` altındaki canlı config'e **öncelikle yeniliyordu**; bir de `Session=plasmax11.desktop` **sabit** yazılıyordu, hedefte yoksa SDDM oturumu bulamıyor |
+| boş | "oturum açıyor" | kutu boşken hiçbir şeye dokunulmuyordu → canlı config kopyalanıyor, kurulu sistem **canlı kullanıcıyla** (parolasız!) açılıyordu |
+
+Kurallar:
+- sddm config'i **`/etc/sddm.conf.d/10-yali-autologin.conf`** kanonik
+  dosyaya yazılır (en yüksek öncelik, deterministik kazanır).
+  ISO dosyaları **silinmez**, öncelikle ezilir.
+- Oturum adı hedeften tespit edilir: `resolve_session()` →
+  `/usr/share/{wayland-sessions,xsessions}/*.desktop` taranır,
+  `pick_session_file()` seçer (saf + testli). Sabit eşleme yalnızca
+  **son çaredir**.
+- Kutu boşken de kanonik dosya yazılır ama **`User=` boş** bırakılır —
+  SDDM bunu "kapalı" sayar, canlı config ezilir. lightdm'de
+  `autologin-user=`/`autologin-session=` satırları ayıklanır.
+- DM bulunamazsa **yalnızca kutu tikliyken hata**; kapalıyken sessiz
+  geçilir (DM'siz sunucu kurulumunu öldürmemek için).
+
+`ConfigureAutologinJob` ayrıca:
+- sddm config'i daima `/etc/sddm.conf.d/10-yali-autologin.conf` dosyasına
+  yazılır (dizin yoksa oluşturulur); eski `/usr/lib/...` + fallback
+  mantığı **kaldırıldı** (öncelik kaybı + yanlış dizin riski vardı)
+- `session_desktop_file()` eşlemesini **tüm DM'lerde** kullanır
+  (lightdm `autologin-session=plasma` yazıyordu; `.desktop` dosyası
+  adı bekler)
+- DM bulunamazsa **hata** verir, kullanıcıya "elle yapılandırın"
+  diyebilmeli
+
+---
+
+## Mimari
+
+```
+egui main thread ──thread::spawn──► tokio::Runtime::new()
+                                      └─ block_on(JobQueue::run_all)
+                                            └─ Job::run(&UiSender) ──mpsc──► egui
+egui frame loop ◄──try_recv()──────────────────────────────────────┘
+```
+
+- `src/steps/*` — saf UI, `InstallerStep` trait'i
+- `src/jobs/*` — `async`, `Job: Send + Sync`, `&self` (immutable)
+- `GlobalState` job thread'leriyle **paylaşılmıyor**; `clone()` edilip
+  `JobQueueConfig` POD'una konuyor. `Arc<Mutex<…>>` yok.
+
+### `StepRole` — rol artık konumsal değil
+`InstallerStep::role()` → `Normal | Execution | Finish`.
+Daha önce `main.rs` rolü `cur == n_steps - 2` ile **tahmin** ediyordu;
+yeni adım eklemek bu tespiti sessizce kaydırıyordu. `main.rs`'de 4 test
+var, biri "Execution ÖNÜNE adım eklenince rol algısı bozulmuyor".
+
+### Hata tipi
+Tüm projede `Result<(), String>`. `thiserror` yok, hata zinciri yok.
+Job log satırları Türkçe hardcoded — İngilizce kullanıcı Türkçe hata görüyor.
+
+---
+
+## Çoklu Disk Manuel Bölümleme
+
+### `CustomPartition` alanları (`src/installer.rs`)
+- `disk`: bölümün ait olduğu disk ("/dev/sda") — gruplama ve **her
+  kapasite/slot hesabı** bununla yapılır
+- `orig_device`: lsblk'tan gelen fiziksel cihaz adı; **boş = kullanıcı
+  tanımı yeni bölüm**. Silme/işaret mantığı buna dayanır.
+- `delete: bool`: eski Yali `OperationDestroyDevice` karşılığı
+
+### ⭐ Bölüm numaralandırması: `plan_disk_layout` (TEK KAYNAK)
+
+**En kritik bulgu bu oturumdandır — veri kaybı düzeltildi.**
+
+Bölüm numarası iki ayrı yerde bağımsız hesaplanıyordu:
+- UI: `assign_partition_numbers` → "en küçük boş slot"
+- Job: `mkpart` + `part.device` okuması
+
+**parted davranışı:** `parted rm N` sonrası kernel, bölümleri **başlangıç
+offset'ine göre** sıralayıp 1'den numaralandırır. `mkpart` ile oluşturulan
+bölüm de aynı sıraya girer.
+
+**Uyumsuzluğun gerçekleştiği senaryo:**
+```
+sda1  0–100      korunuyor
+sda2  100–200    SİLİNECEK → 100 MB boşluk
+sda3  200–30200  korunuyor
+disk sonu: 10000 MB boş
+yeni: 5000 MB
+
+UI  : sda2 silinince slot 2 boşalır → yeni = sda2
+Disk: 100–200 boşluğu 5000 MB'ye SIĞMAZ → first-fit diskin sonuna yazar
+      kernel sırası: sda1, sda2(eskisi 3), sda3(YENİ)
+Sonuç: UI "yeni = sda2" der, diskte yeni = sda3. FAZ C mkfs'i yanlış
+       aygıta uygular → kullanıcının KORUMAK İSTEDİĞİ bölüm bozulur.
+```
+
+**Çözüm:** `plan_disk_layout(disk, total_mb, physical, destroyed, creates)`
+— saf, test edilebilir fonksiyon. Diskin **tamamını** (fiziksel + yeni)
+görüp numaralandırır ve şunları döndürür:
+- `Vec<PlannedCreate>`: her yeni bölümün konumu + **gerçek** slot numarası
+- `Vec<(u32, String)>`: silmeden sonra **KAYAN** fiziksel bölümlerin
+  eski numarası → yeni aygıt yolu
+
+FAZ B bu planı kullanır, `device_map` doldurur, FAZ C **gerçek aygıtı**
+kullanır (kayma varsa loglar). `assign_partition_numbers` artık yalnızca
+**UI önizlemesi** içindir — doğruluk kaynağı değil.
+
+> `disk_free_regions_mb` (eski, ayrı kopya) **silindi**. `disk_total_mb`
+> ve `read_physical_extents` eklendi; artık diskin gerçek boyutu sysfs'ten
+> okunuyor (önce son bölümün bitişinden tahmin yürütülüyordu).
+
+### `assign_partition_numbers`
+Disk bazlı `HashMap<disk, BTreeSet<num>>` ile **bağımsız** çalışır;
+sda1 ile sdb1 çakışmaz.
+
+> Eski test `renumber_keeps_disks_independent` **TUUTOLOJİK'ti**: hep
+> fiziksel bölüm kullanıyordu, fonksiyon no-op çalışıyordu; global
+> (disk-suz) bir uygulama da testi geçerdi. `multidisk_tests` içinde
+> gerçek çapraz-disk yolunu (yeni tanım) sınayan testler var.
+
+### `CustomPartitionJob` fazları (`jobs/partition.rs`)
+1. **FAZ A**: `delete=true` → `parted rm N`, büyükten küçüğe
+2. **FAZ B**: `plan_disk_layout` ile yerleşim + numaralandırma, sonra `mkpart`
+3. **FAZ C**: `device_map` üzerinden **gerçek** aygıta mkfs (LUKS akışı korundu)
+- Sabit boyutlular ÖNCE, sembolikler SONRA (`sort_by_key(size==0)`)
+- İşlemi olmayan disklere hiç girilmez (`⏭️ ... korunuyor`)
+
+### UI (`src/steps/partition.rs`)
+- **Tablo TEK diski gösterir** (kullanıcı isteği, 27 Eyl): üstteki
+  seçicide hangi disk seçiliyse bölüm tablosu onun. Tüm diskleri tek
+  tabloda göstermek kafa karışıklığı yaratıyordu — özellikle "Sil"
+  hangi diski etkilediği belirsizleşiyordu.
+- **Disk ŞERİDİ YOK** (27 Eyl, kullanıcı isteği). Tablo altındaki
+  `/dev/sda · 3/20 GB` gibi tıklanabilir disk düğmeleri kaldırıldı:
+  üstteki **"Aktif Disk" ComboBox'ı** zaten tek ve açık kaynak, iki
+  kaynak olması "hangi disk geçerli" sorusunu belirsizleştiriyordu.
+  Başka bir diske geçmek için ComboBox kullanılır, sonra "Yeni Bölüm".
+  "sda'da 3 bölüm var" bilgisi tablo başlığında ve satırlarda durur.
+  - ⚠️ Şerit sadece çizim değildi: disk değişince
+    `on_disk_changed()` ile `selected_idx` / `selected_free`
+    sıfırlıyordu. Bu sorumluluk **ComboBox'a taşındı**; taşınmazsa
+    bayat satır indeksi "Sil" ile **yanlış bölümü** siler.
+- **"Aktif Disk" ComboBox'ı TEMA sarmalayıcısını kullanır**
+  (`theme::show_combo_box` + `theme::selectable_value`). Ham
+  `egui::ComboBox` + `ui.selectable_value` egui'nin varsayılan stilini
+  kullanıyor ve koyu temada okunmuyordu. Mountpoint ve önyükleyici
+  ComboBox'ları zaten temalı sürümde — **disk ComboBox'ı geride kalmıştı**.
+- **Diyalogda HEDEF DİSK SEÇİCİSİ YOK** (27 Eyl, kullanıcı isteği) —
+  ne eklemede ne düzenlemede. Bölümleme arayüzü tek disk üzerinde
+  çalışıyor:
+  - ekleme   → `state.selected_disk`
+  - düzenleme→ bölümün kendi `disk`/`device` alanları (korunur)
+
+  Başka bir diske bölüm eklemenin yolu: **"Aktif Disk"
+  ComboBox'ından o diske geç**, sonra "Yeni Bölüm".
+
+  Bu karar `ManualState::add_disk` alanını da tamamen gereksiz kıldı ve
+  alan **silindi**. Alan varken şu akış bölümü yanlış diske taşıyordu:
+  "Yeni Bölüm" (`add_disk = sda`) → iptal → sdb'deki bölümü `Düzenle`
+  → kaydet. Artık "hangi disk" sorusunun **tek cevabı** var ve bayat
+  değer sınıfı hata kalmıyor. `edit_disk_tests` bunu sabitler.
+- Tablo `TableRow::Part | TableRow::FreeSpace` enum'u ile kurulur.
+  Satır kurma mantığı **`build_table_rows(parts, active_disk, disk_mb)`**
+  saf fonksiyonunda (gömülüydü, iki kez yanlış hesaplandı):
+  - **Boş alan satırı disk başına TEK'tir.** Silinmek işaretliler ilk
+    işaretli tanımın konumunda birleşir (GParted tarzı). Satır ortada
+    basıldıysa sona ikinci bir tane **EKLENMEZ** (`free_row_shown`
+    bayrağı) — eklenirse aynı alan iki kez görünür ve toplam diskten
+    büyük izlenimi doğar.
+  - Disk sonundaki boş alan, diskte tanım **olup olmadığına bakılmaksızın**
+    basılır. REGRESYON: koşul `all(|p| p.disk != active_disk)` idi,
+    yani yalnızca tamamen boş disklerde görünüyordu. `sda1 (500 MB) +
+    15 GB boş` → boş alan hiç çizilmiyordu.
+  - `FreeSpace.first_idx`: silinmiş tanımı temsil ediyorsa `Some`,
+    temsil ettiği tanım yoksa `None`. **`None` seçilemez demek
+    DEĞİLDİR** — tıklanınca `global_idx == None` dalı `selected_free`
+    tutar ve "Yeni Oluştur" butonu çıkar.
+- Seçili disk hiç tanım içermiyorsa boş-alan satırı basılır
+  (`first_idx: None` → seçim indeksi karşılığı yok; tıklanınca
+  `selected_free` tutulur ve "Yeni Oluştur" çıkar). `selected_idx = 0`
+  ile başka diskin ilk bölümü seçilmesi bu yolla engellenir.
+- Silinmek işaretli bölümler ayrı satır çizmez; İLK silinenin konumunda
+  TEK "Boş Alan" satırında birleşir (GParted tarzı).
+- Varsayılan öneriler (EFI/root/swap) **aktif diskin durumuna** göre verilir.
+- "Kalan alan" SEMBOLİKTİR (size_mb=0): kaydetme anında sayıya çevrilmez.
+- **LVM bölümü de seçili diske filtrelenir**: VG listesi yalnızca PV'leri
+  o diskte olan VG'leri, LV listesi yalnızca VG'si o diskte olan LV'leri
+  gösterir. Yeni VG oluştururken PV'ler **yalnızca seçili diskin**
+  PV'lerinden toplanır — önceden tüm disklerin PV'leri birleştiriliyordu
+  ve boyut toplamı yanlış çıkıyordu (AGENTS.md'deki açık maddeydi).
+
+### ⭐ Mountpoint boşluğu mount EDİLMEMİŞ bölüm demek değil
+
+`read_existing_partitions` mountpoint'i **`lsblk` MOUNTPOINT sütunundan**
+okur (satır ~67: `tokens.next().unwrap_or("")`). Canlı ISO'da mount
+edilmemiş her bölümde bu sütun **boştur**.
+
+**Çift önyüklemeli makinede Windows'un boot bölümü neredeyse her zaman
+bu durumdadır** ve kullanıcı ona dokunmamıştır. Buna rağmen
+`validate_manual_on` tüm tanımları kapsayan bir "boş mountpoint"
+kontrolü içeriyordu → düzen reddediliyordu, hata hangi bölümden
+geldiğini söylemeden.
+
+Kural artık: **boş mountpoint zorunluluğu yalnızca `orig_device` BOŞ
+olan (kullanıcı tanımı) bölümlerde geçerli.** Fiziksel taranmış
+bölümde boş mountpoint "henüz atanmadı" demektir ve iş zincirinde
+zaten güvenli:
+
+| Aşama | Davranış |
+|---|---|
+| mount | atlanır (`jobs/partition.rs:1111`) |
+| fstab | atlanır (`:1171`) |
+| mkfs | atlanır (`skip_format: true`) |
+
+Aynı sebeple **mükerrer bağlama noktası kontrolü de boş değerleri
+dışlar** — aksi hâlde "N atanmamış bölüm" kendi kendine mükerrer
+sayılır ve asıl sorun maskelenir.
+
+### `suggest_mountpoint` — öneri TÜM düzeni görmeli
+
+`/`, `/boot/efi` ve `swap` bir kurulumda **TEKİLDİR**. Öneri bu
+yüzden aktif diske değil **tüm düzene** bakar.
+
+Aktif diske bakıyordu: kullanıcı boş bir ikinci diske geçip "Yeni
+Bölüm" dediğinde o diskte tanım olmadığı için `/boot/efi` öneriliyordu
+— sdb1'de zaten var olan mountpoint'i ikinci kez. Kullanıcı
+kaydetmeye çalışınca "mükerrer" alıyor, alanı temizleyince "boş
+olamaz" alıyordu. İkisi de hiçbir şey söylemiyordu.
+
+Sıra: `/boot/efi` (UEFI) → `/` → `swap` → `/home` → boş. Son adım
+ikincil (veri) diskler içindir: boş diske bölüm eklemek için alanı
+elle doldurmak zorunda kalmamak. Silinmek işaretli tanımlar
+sayılmaz.
+
+### ⭐ "Kalan Alan" (sembolik) tanımlar — `size_mb == 0`
+
+`CustomPartition::size_mb == 0` **"Kalan Alan"** demektir: kurulumda
+diskin o an kalan boşluğunun **tamamını** alır. Bu yüzden sabit
+boyutlu tanımlarla birlikte hesaplanırken **sabit toplama katılmaz**.
+
+Kullanıcı raporu: *"eklenen bölümün 19.8 gb demesine rağmen bunu
+boş alandan düşmedi"* — 20 GB'lik disk 39 GB kullanıyor gibi görünüyordu,
+çünkü hem bölüm satırı hem boş alan satırı kalanın tamamını gösteriyordu.
+
+| Yer | Kural |
+|---|---|
+| `has_symbolic_remaining(parts, disk)` | **TEK KAYNAK.** `!delete && size_mb == 0 && orig_device.is_empty()` |
+| tablo (`build_table_rows`) | sembolik varsa boş alan satırı **çizilmez** — o alan o tanıma ait. Koşul **`show_free`** adıyla TEK yerde tanımlı ve **üç basış yerinin de** ortak koşulu (aşağıdaki REGRESYON 3'e bak) |
+| çubuk (`manual_dual_bars`) | sembolik varsa serbest segment **eklenmez** |
+| `manual_capacity_error` | sembolik varsa `fixed_mb >= cap_mb` reddedilir |
+
+Son satır, AGENTS.md'de açık madde olarak duran hatayı kapatır:
+`fixed == cap` geçiyordu, kurulumda "yeterli boş alan yok" ile düşülüyordu.
+Ayrıca **aynı diskte iki "Kalan Alan" tanımı** reddedilir — ikisi de
+kalanın tamamını alır, ikincisine hiç yer kalmaz.
+
+`orig_device` dolu (taranmış) 0 boyutlu bölüm sembolik **DEĞİLDİR**:
+sıfır boyut "kalanın tamamı" anlamına gelmez.
+
+#### ⭐ Koşul YER YER yazılırsa bu sınıf hata tekrarlar
+
+Bu tabloda bir hata **üç kez** yaşandı ve üçü de aynı sebepten:
+`has_symbolic` kontrolü satırın **yalnızca bir** basış yerine
+eklenmişti.
+
+1. `else if` dalı vardı, diskte tanım yokken çalışıyordu →
+   tanım varsa satır hiç basılmıyordu (`sda1` + 15 GB boş)
+2. `else if` düzeltildi, **döngü içindeki** basış unutuldu →
+   `19.8 GB` bölüm + `19.8 GB` boş alan
+3. döngü içi de düzeltildi ama **koşul üç yere ayrı ayrı yazıldı**
+
+**Ders:** aynı koşulu birden çok yerde yazma. Tek bir
+`show_free = free_total_mb > 0 && !has_symbolic` değişkeni hesaplanıp
+**üç basış yerinin de** koşulu olarak kullanılıyor. Kural tek
+yerde; onu atlamak ya da çoğaltmak imkânsız.
+
+> Bu, "sabit bir sayıyı 3 yere yazma" değil — "bir *koşulu* 3
+> yere yazma". Sabit sayıyı çoğaltmak hataya açıktır ama en azından
+> yanlışsa sayı yanlış görünür; koşulu çoğaltmak bazı basış
+> yerlerinde **sessizce yanlış** davranış üretir.
+
+### ⭐ Bağlanmayan dosya sistemleri — mountpoint isteğe bağlı
+
+`mountpoint_required(editing, fstype)` üç dosya sisteminde `false`
+döndürür:
+
+| FsType | Neden |
+|---|---|
+| `Lvm` | PV'nin kendisi bağlanmaz, üzerinde LV'ler yaşar |
+| **`Ntfs`** | **Linux'ta bağlanması GEREKEN bir dosya sistemi değil** |
+| düzenlenen fiziksel bölüm | "yalnızca GRUB için" işaretlemesi |
+
+NTFS'te zorunluluk kullanıcıya anlamsız geliyordu: *"format için ntfs
+seçtiğim halde bağlama noktası seçmemi bekliyor bu mantıksız değil
+mi"*. Tipik kullanım Windows ile veri alışverişi — bölüm biçimlendirilir
+ama sisteme bağlanmaz, kullanıcı elle bağlar veya dosyayı doğrudan açar.
+
+Boş bırakıldığında kurulumda ne olduğu **mevcut ve doğru**: mount
+atlanır (`jobs/partition.rs:1111`), fstab'a girmez (`:1171`), ama
+`mkfs.ntfs -f` **çalışır** (FAZ C, `FsType::Ntfs`).
+
+Diyalogda NTFS seçilince:
+1. geçersiz öneri kalıntısı (`/`, `/boot/efi`, `swap`…) **temizlenir**
+2. `mp_mountpoint_optional` ipucu gösterilir
+
+### ⭐ Disk listesi kararlı sıralanır, boot medyası hariç
+
+`list_block_devices` ne `lsblk` çıktısını ne `/sys/block` çıktısını
+sıralıyordu. `/sys/block` fallback yolunda liste **önyüklemeden
+önyüklemeye değişebiliyor** — "ilk disk" kavramı anlamsızlaşıyor,
+varsayılan seçimler tutarsızlaşıyor.
+
+`sort_disks()`: **çıkarılabilir aygıtlar sona**, dahililer ada göre
+(`disk_sort_key` — bölüm numarası SAYISAL ayrıştırılır, yoksa
+`sda10 < sda2` olurdu).
+
+**Çıkarılabilir aygıtlar listeden de ÖNYÜKLEYİCİ hedefinde de
+elenir.** `detect_drive_type` "USB" döndürüyor ama o değer hiç
+okunmuyordu. Canlı ISO'nun USB'i `available_disks`'teydi ve önyükleyici
+hedefi olarak seçilirse BIOS modunda `grub-install --target=i386-pc`
+MBR'yi **boot medyasına** yazar → kurulum biter, sistem açılmaz.
+
+> `is_removable()` kendi ayrıştırıcısını kullanır, `device_to_disk`'i
+> DEĞİL: o işlev **bölüm yolu** içindir ve çıplak NVMe disk adında
+> hatalıdır (`/dev/nvme0n1` → `nvme0n`). `base_disk_name` bunu
+> düzeltir. Bu ayrım notla sabitlendi, ileride "basitleştirilirse"
+> NVMe'ler çıkarılabilir sanılır.
+
+Ayrıca UEFI modunda çift önyükleme ipucu
+(`bootloader_device_hint_dualboot`) gösterilir: hangi aygıtı seçmek
+gerektiği ekranda hiç yazmıyordu.
+
+### ⭐ Önyükleyici varsayılanı: KÖRK diski değil, **mevcut OS diski**
+
+`steps/bootloader.rs::default_boot_device()` saf ve test edilebilir:
+
+```
+1. çıkarılabilir aygıt (ISO'nun USB'i)  → ASLA hedef değil
+2. kök diski dışında bölümü olan ilk dahili disk → mevcut OS diski
+3. kök diski
+4. selected_disk (son çare)
+```
+
+**Neden kök diski değil.** BIOS modunda `grub-install` seçilen
+diskin **MBR'sine** yazar ve MBR'yi okuyan aygıt firmware'in açılış
+sırasındaki ilk diski olmak ZORUNDA:
+
+```
+sda: Windows    sdb: PisiLinux (kök burada)
+GRUB → sdb      firmware sdb'yi açmaz, PisiLinux HİÇ GÖRÜNMEZ
+GRUB → sda      firmware GRUB'a düşer, GRUB ikisini de listeler
+```
+
+"İşletim sistemi kurulu"nun en ucuz ve en güvenilir göstergesi:
+**kök diski dışında hâlihazırda bölüm tablosu olan disk**. Tespit
+`disk_partition_count()` ile `sysfs`'ten yapılır — **alt süreç yok**
+(`lsblk` çalıştırmak `on_enter`'da bile gereksiz).
+
+Tek diskli kurulumda 3. adım çalışır, yani davranış kök diskiyle
+aynıdır — geriye dönük uyum bozulmaz.
+
+Kullanıcı elle değiştirdiyse ipucu (`bootloader_device_why_existing`)
+gösterilmez; ipucu yalnızca seçim bu kurala uyuyorsa çıkar, yani
+sessiz bir sürpriz olmaz.
+
+> ⚠️ Bu, daha önceki iki varsayılanın da yerine geçti:
+> `selected_disk` (manuel modda "aktif düzenleme diski" olduğu için
+> yanlış diske gidiyordu) ve salt kök diski (dual-boot'ta yanlış).
+> Kural artık ikisinden de iyi; `boot_device_reason` aynı fonksiyonu
+> çağırıp UI metnini oradan üretir — **ikinci bir uygulama yok**.
+
+### ⚠️ `show()` HER KARE çalışır — girdi tepkisi KENAR TETİKLİ olmalı
+
+egui `show()` ~60 Hz çağrılır. Bu yüzden kullanıcı girdisine tepki
+veren **her durum mutasyonu kenar tetikli (change-detected) olmak
+zorunda**; seviye tetikli ("şu an şu koşul doğruysa yaz") yazılan
+kod kullanıcının yazdığını **sürekli siler**.
+
+REGRESYON (kullanıcı: *"düzenle kısmında bu seferde bağlama noktasını
+seçemiyorum"*):
+
+```rust
+// ❌ HER KARE çalışır
+if mp_optional {
+    if matches!(add_mountpoint.as_str(), "/" | "/home" | …) {
+        add_mountpoint.clear();     // kullanıcı `/home` seçti → silindi
+    }                                 // tekrar seç → tekrar silindi
+}
+```
+
+`mp_optional` fiziksel bölümlerde de doğru olduğu için (orijinal
+mountpoint'i olan bölümü düzenlerken) liste **tamamen kilitlenmişti**.
+
+İki koşul birlikte gerekiyor:
+
+| Koşul | Neden |
+|---|---|
+| **yalnızca Ekleme modunda** | Eklemede mountpoint `suggest_mountpoint`'in ÜRETTİĞİ öneridir, eski kalıntı olabilir. Düzenlemede bölümün **GERÇEK** değeridir — silmek kullanıcı verisini kaybettirir. |
+| **yalnızca `add_fstype` DEĞİŞTİĞİ karede** (`add_fstype_prev`) | Geçiş değilse kullanıcının yazdığı her karede silinir. Aynı tuzak (b) olmadan ekleme modunda da yaşanırdı. |
+
+> Bu sınız hata **sessizdir**: derleyici uyarı vermez, test de
+> yakalamaz (UI kodu). Bu yüzden `ManualState`'e
+> `add_fstype_prev: Option<usize>` alanı eklendi ve hem "Yeni Bölüm"
+> hem "Düzenle" butonlarında diyalog açılışında kuruldu — ilk karede
+> yanlışlıkla silinmesin diye.
+
+### Testler ortamdan bağımsız olmalı
+
+`is_removable()` gerçek `sysfs`'i okur. Bu geliştirme makinesinde
+`/sys/block/sda/removable == 1` olduğu için `/dev/sda` kullanan testler
+çıkarılabilir sanılıp **kırıldı** — yani o testler **şansa** geçiyormuş.
+Şansa geçen test, test olmaktan kötüdür.
+
+Çözüm: saf katman probu dışarıdan alır —
+`sort_disks_with(disks, is_removable)` ve
+`default_boot_device(root, disks, is_removable, has_partitions)`.
+Üretim sarmalayıcıları gerçek probu verir, testler sabit olanı.
+
+> `/dev/sda` gibi **gerçek aygıt adları** test verisi olarak
+> kullanılıyorsa, o adın `sysfs`'te çevreye bağlı bir özelliği
+> (removable gibi) sorgulanmadığından emin ol. Sorgulanıyorsa probu
+> dışarıdan al.
+
+### ⭐ Yerelleşmiş CLI çıktısı ayrıştırılmaz (29 Eyl 2026, P0 veri kaybı)
+
+`disk_label_is_gpt` parted çıktısındaki İngilizce `Partition Table`
+satırını arıyordu. Ama parted yerelleşmiştir — canlı ISO'da satır
+`Disk bölümü Tablosu: msdos` gelir. Ayrıştırıcı hiçbir diski
+tanıyamadı → her disk "boş" sanıldı → `mktable` dolu diski **komple
+sildi**. Boş disklerde zararsız olduğu için iki kurulum geçti, üçüncüde
+(dolu diske ekleme) patladı.
+
+Kurallar:
+- İnsan-dili CLI çıktısı **daima `LC_ALL=C` ile** okunur
+  (`env LC_ALL=C parted …`). Makine-dili alternatif varsa (blkid
+  `PTTYPE` gibi) o tercih edilir.
+- Türkçe başlık çekimlidir (`bölümü`, `bölümü`nün…): tam kalıp
+  eşleştirme ıskalar. Anahtar kelimeyle (`tablosu`) eşleştir + test
+  verisi olarak GERÇEK yerelleşmiş çıktıyı kullan.
+- **Yıkıcı komutun kilidi olur:** `mktable` öncesi sysfs'ten fiziksel
+  bölüm sayılır; bölüm varken etiket okunamazsa **hata verilir**,
+  tabloya dokunulmaz. Ayrıştırıcı + locale + kilit üçü birlikte
+  kapatır; hiçbiri tek başına yeterli değildir.
+
+### ⭐ "Biçimlendir" kutusu — olumlu çerçeve
+
+Kullanıcı isteği: *"düzenle penceresindeki biçimlendirmeyi atla
+seçeneğini biçimlendir şekline dönüştürsek yani seçili ise
+biçimlendirsin şimdiki davranışın tam tersi"*.
+
+| Katman | Alan | Değer |
+|---|---|---|
+| Model (`CustomPartition`) | `skip_format` | taranmış bölüm = `true` (**korunur**) |
+| Diyalog (`ManualState`) | `add_format` | **`skip_format`'ın TERSİ** |
+
+İki yönlü dönüşüm iki adlandırılmış yardımcıda:
+`format_checkbox_from(skip)` / `skip_format_from(format)`. Elle `!`
+yazılmaz; `format_checkbox_and_skip_format_are_exact_inverses` testi
+çift bağı sabitler.
+
+**Neden ters çevirdik.** "Biçimlendirmeyi Atla" taranmış bölümlerde
+**seçili** geliyordu, yani güvenli durum "varsayılan seçim"di. Risk
+seçeneğin kendisinde değil, seçenekte risk olduğunu sezmeden okuyan
+kullanıcıda: "Atla" işaretliyse veri silinecek diye düşünürken
+tam tersi oluyordu. Olumlu çerçevede **seçim kullanıcıya aittir**:
+
+```
+Taranmış bölüm (sda1)   →  "Biçimlendir"  ☐ SEÇİLİ DEĞİL  → veri korunur
+Kullanıcı tanımı (sda2) →  "Biçimlendir" ☑ SEÇİLİ          → biçimlendirilir
+```
+
+> ⚠️ Ters çevrim sessizce kaybolursa taranmış bölümler
+> biçimlendirilir — **veri kaybı**. Bu yüzden dönüşüm `!` olarak
+> iki yere dağıtılmadı, adlandırılmış çift fonksiyona bağlandı ve
+> `format_checkbox_and_skip_format_are_exact_inverses` testi
+> `skip_format` için **her iki** değeri de dener.
+
+`mp_skip_format` çeviri anahtarı kullanılmaz hale geldiği için iki
+locale'den de **silindi** (ölü anahtar bırakılmadı).
+
+### ⭐ `lsblk` AKTİF swap için `[SWAP]` yazar
+
+**Bu, canlı ISO'ya SSH ile bağlanıp GERÇEK çıktı okunarak bulundu.**
+Tahminle değil:
+
+```
+$ lsblk -o NAME,SIZE,FSTYPE,MOUNTPOINT -b --noheadings -l /dev/sdb
+sdb1    524288000 vfat /boot/efi
+sdb2   1572864000 swap [SWAP]        ← köşeli parantezli!
+sdb3  25168969728 ext4 /
+```
+
+`read_existing_partitions` mountpoint'i doğrudan alıyordu, yani
+`CustomPartition::mountpoint = "[SWAP]"` oluyordu. İki yere sızıyordu:
+
+1. **UI** — tablonun bağlama noktası sütununda `[SWAP]` görünüyordu
+2. **mükerrer kontrolü** — iki swap'ı olan makinede (Windows diski +
+   Linux diski = çift önyüklemeli kurulumun tipik hali) ikisi de aynı
+   `"[SWAP]"` değerini taşıyor ve kullanıcı **var olmayan** bir
+   "mükerrer bağlama noktası" hatası görüyordu
+
+Bu makinede tek swap olduğu için sorun görünmüyordu — **kolayca kaçar.**
+
+| Düzeltme | Yer |
+|---|---|
+| `normalize_lsblk_mountpoint(raw, fstype)` | `[SWAP]` → `"swap"`. Yalnızca `FsType::Swap` için; diğerleri **dokunulmaz** (sessizce yutmak yok) |
+| mükerrer kontrolü | yalnızca **gerçekten bağlanan** dosya sistemleri karşılaştırılır: `Swap`/`Lvm`/`LvmLv` hariç. `mountpoint_required` ile aynı gerekçe |
+
+> `fstab` işi zaten doğruydu: satırı `part.mountpoint`'e değil
+> `part.fstype`'e göre yazıyor (`FsType::Swap => ("none", "sw", …)`).
+> Yani mountpoint `"swap"` olması fstab'ı bozmaz — hatta bozmadığı için
+> hata fstab'da değil, **mükerrer kontrolünde** görünmüyordu.
+
+### `selected_disk` hâlâ 3 yerde kullanılıyor
+1. Tablo hangi diski gösteriyor + `manual_dual_bars`
+2. Diyaloğun varsayılan hedefi
+3. `build_custom_job_queue` girdisi → `InstallGrubJob.disk`
+
+Bu yüzden dış ComboBox'un etiketi **"Aktif disk"** + açıklayıcı ipucu
+("Kurulum Yapılacak Diski Seçin" yanlış anlam çağrışımı yapıyordu).
+`bootloader_device` varsayılanı `selected_disk` değil, **kökün olduğu disk**.
+
+---
+
+## Güvenlik Düzeltmeleri (P0)
+
+### Parola asla argv'ye geçmez
+`sh -c "echo 'user:pass' | chpasswd"` deseni **KALDIRILDI**
+(`jobs/users.rs`). Parola `/proc/<pid>/cmdline` üzerinden okunabiliyordu
+ve `'`/`$(...)` içeren parola komutu bozuyordu.
+
+Doğru desen: **`set_password_via_chpasswd()`** — `chroot <mount> chpasswd
+-c SHA512` komutuna stdin pipe ile yazılır. `jobs/partition.rs::
+run_luks_format` ile birebir aynı desen. Yazılan veri yazımdan sonra
+sıfırlanır.
+
+> **Kural:** parola, LUKS anahtarı, herhangi bir gizli değer
+> `format!` ile komut satırına gömülmez. stdin pipe kullanılır.
+
+### LUKS çekirdek parametresi
+`cryptdevice=UUID=<x>:cryptroot` **geçerli bir söz dizimi değildi** ve
+kök bölüm `is_uefi` ile (3|2) tahmin ediliyordu — manuel modda yanlış
+(assign_partition_numbers'tan gelir) ve kök başka diskteyse hiç doğru
+değildi.
+
+Artık `luks_backing_device()` (`cryptsetup status` → `device:` satırı) ile
+mapper'ın arkasındaki **gerçek** aygıt bulunur, blkid ile LUKS başlık
+UUID'si alınır, dracut (`rd.luks.uuid=luks-…`) + mkinitcpio
+(`cryptdevice=…`) biçimleri birlikte yazılır. UUID boşsa hata.
+
+`CRYPTROOT_NAME` sabiti: "cryptroot" 5 yerde hardcoded'dı, tek kaynağa bağlandı.
+
+### KRİTİK: parolasız LUKS reddediliyor
+`encrypt_root=true` + boş parola → kök düz ext4 formatlanıyor,
+`MountPartitionsJob` `/dev/mapper/cryptroot`'u mount etmeye çalışıp
+kurulumu öldürüyordu. `PartitionJob` başında `Err` ile reddediliyor.
+
+---
+
+## Hata Yönetimi
+
+### Temizlik HER ZAMAN çalışır
+`JobQueue::cleanup` + `with_cleanup(...)`: liste başarıda da hatada da
+koşar. Temizlik de hata verirse bu hatalar asıl hataya **eklenip**
+kullanıcıya "elle ne yapılacak" listesi olarak gösterilir.
+
+`EmergencyCleanupJob` (`src/jobs/cleanup.rs`) sırasıyla:
+1. `mount` altındaki tüm dosya sistemleri
+2. LVM: `vgchange -an`
+3. LUKS: `cryptsetup close` (yalnızca **hedef diskin** mapper'ları)
+4. `swapoff`
+
+`close_crypt_mappers` yalnızca hedef diske ait olanları kapatır —
+canlı ortamın kendi şifreli bölümlerine dokunmaz.
+
+### unmount artık tüm ağacı tarar
+`UnmountBindJob` elle yazılmış sabit liste (`proc`, `sys`, `dev`,
+`boot/efi`) kullanıyordu; manuel düzende `/home`, `/var`, `/boot`
+bağlı kalıyordu. Artık `mounted_paths_under()` `/proc/self/mountinfo`
+okuyor ve `mount/` altındaki **her şeyi** en derinden yüzeye çözüyor.
+
+> `unescape_mount_field()` mountinfo'daki `\0NNN` oktal kaçışlarını
+> çözer; boşluk içeren mountpoint'ler ("My Disk") eşleştirilemezdi.
+
+### Kritik hatalar artık yutulmuyor
+- `RunComarJob` tamamen yorum satırıydı → `pisi configure-pending`
+  **hiç çalışmıyordu**. Geri getirildi.
+- `ldconfig` / `update-environment` hataları loglanıp yutuluyordu.
+  `update-environment` init finalizasyonudur: yutulursa kurulum
+  "başarılı" görünür ama sistem açılmaz. Artık **fatal**.
+- `CleanupLiveJob`'daki 10 `let _ =`: depo tanımları sessizce
+  başarısız olabiliyordu. Artık **fatal**.
+
+---
+
+## partition "MB" tuzağı (KRİTİK)
+
+parted `"MB"` sonekini **ondalık** (10^6) okur, bizim hesaplar **ikili**
+(2^20). `mkpart 3944MB` → sektör 7703125 (hizasız) → "Becerebildiğimiz
+buna en yakın konum..." hatası.
+
+> parted'a **daima** `"{}MiB"` geç. Tamsayı MiB = 2048 sektörün katı →
+> hizalama hatası çıkmaz. UI'da kullanıcıya MB gösterilir ama parted
+> argümanı asla "MB" **olmamalı**.
+
+Bu tuzak iki kez yaşandı: `7209d58`'de düzeltildi, `22de7d5`ten sonra
+kök bölümde `"{}MB"` olarak **geri gelmişti**. `d161556` ile düzeltildi ve
+nedeni yorumla sabitlendi. Log bile "MiB" derken argüman "MB" gönderiyordu.
+
+---
+
+## Diğer Kalıcı Kurallar
+
+- MB dönüşümleri **tek bölme**: `x / 1_048_576` (çift `x/1024/1024`
+  hassasiyet kaybı yapardı)
+- Simge fontu: `assets/remixicon.ttf` fallback (`ui/theme.rs setup_fonts`).
+  **Kutu (tofu) görürsen** karakter fontta yok. `fontTools` ile cmap kontrol:
+  EB7B check, EA6B arrow, EC28 trash, EA13 add, EFE0 pencil, EECD lock,
+  ECA1 error, EDFB hdd, ECB5/B7 eye, F4C6 close.
+  **Emoji kullanma** — `NotoColorEmoji` yüklü değil (yorum satırında).
+- **Kare başına alt süreç çalıştırma.** egui `show()` her karede
+  çağrılır (~60 Hz). `blkid`, `nmcli` gibi ağır komutlar `on_enter`'a
+  taşındı, sonuç alanlarda saklanıyor, `refresh_*()` ile tazeleniyor.
+- ⚠️ **Gradient butonlarda `add_enabled_ui` ÇALIŞMAZ.** `theme::*_button()`
+  çağrıları `enabled: true` sabit geçirir; `add_enabled_ui` sarmalayıcısı
+  yalnızca çocuk widget'ın `Response`'unu etkiler, butonun kendi
+  `enabled` parametresine ulaşamaz. Sonuç: buton seçim yokken de tam
+  renkli ve tıklanabilir görünür ama tıklayınca hiçbir şey olmaz.
+  **Doğrusu:** `theme::secondary_button_enabled(ui, label, can)`
+  / `danger_button_enabled(...)` kullan. `ui.checkbox` gibi sıradan
+  widget'larda `add_enabled_ui` normal çalışır.
+- **Eylem butonları tablonun hemen altında** olmalı; aralarına görsel
+  özet bloğu (kapasite çubuğu gibi) girdiğinde kullanıcı butonları
+  bulamıyor. Özet blokları butonlardan SONRA çizilir.
+- **Butonlar seçime göre görünür** (kullanıcı isteği, 27 Eyl):
+  | Seçim | Görünen buton |
+  |---|---|
+  | bölüm satırı | `✏ Düzenle` + `🗑 Sil` |
+  | boş alan satırı | `➕ Yeni Oluştur` (vurgulu) |
+  | hiçbiri | `➕ Yeni Oluştur` (soluk) |
+  `ManualState::selected_free: bool` boş alan seçimini tutar ve
+  `selected_idx` ile **birbirini dışlar**. Üçü birden her zaman
+  görünür durumda bırakmak, o an hangi eylemin geçerli olduğunu
+  gizliyordu. `selection_tests` bu kuralı sabitler.
+- ⚠️ **Mount edilmemiş fiziksel bölüm de "Düzenle" açar.** `create_over`
+  ("Buraya Oluştur") akışı **KALDIRILDI** — iki sebeple:
+  1. "Yeni Bölüm" ve "Buraya Oluştur" aynı mekanizma; ikisi de yeni
+     tanım üretiyor, kullanıcı ayırt edemiyordu.
+  2. O dal `skip_format = false` atıyordu. Taranmış fiziksel bölümler
+     `skip_format: true` ile gelir (verisi korunmalı) — sıfırlanırsa
+     kurulumda mkfs çalıştırıp **kullanıcının verisini bozardı**.
+  Artık her bölüm satırı "✏ Düzenle" açar ve `skip_format` (diyalogda
+  **"Biçimlendir"**, aşağıya bak) dahil
+  mevcut değerleri korur. `ManualState::create_over` alanı da silindi
+  (ölü durum bırakılmadı). `edit_flow_tests` bunu sabitler.
+- Locale: `locales/` altında yalnızca `tr.toml` ve `en.toml` **var**.
+  `set_locale("de")` hata vermez, sessizce kabul edilir ve `t!()`
+  karşılığı olmayan her anahtar için **anahtarın kendisini** döndürür —
+  arayüz çıplak anahtarlarla dolar. `funct::sanitize_locale()` her
+  `set_locale` çağrısından önce kullanılır. GeoIP sadece
+  `language_for_country()` ile **gerçekten var olan** dillere geçer.
+- **TOML düzenleme uyarısı:** `locales/*.toml` satır sonuna yapışan
+  düzenlemelerle bozuldu ve `rust_i18n` proc macro derlemeyi durdurdu.
+  Değiştirdikten sonra `tomllib` ile doğrula.
+- Bağımlılık: `zbus` (`Cargo.toml`) **hiç kullanılmıyor** — projede tek
+  D-Bus/COMAR çağrısı yok, tüm sistem etkileşimi shell üzerinden.
+
+---
+
+## Test / Derleme
+
+```
+cargo check --all-targets : 0 hata, 0 uyarı
+cargo test              : 151/151 (test modülü sayısı arttıkça güncel tut)
+cargo clippy            : ~77 uyarı, tamamı stil (collapsed_if, replace zinciri)
+```
+
+Bu oturumda 1 → 151 test. Test modülü olmayan dosyalar (`users.rs`,
+`location.rs`, `rescue.rs`, `funct.rs`, `autoinstall/mod.rs`, `main.rs`)
+içine modüller eklendi. Çoklu test modülü paylaşılan yardımcıları
+`steps/partition.rs::testutil` altındadır (`disk()`, `part()`).
+
+### 🧪 ISO TESTİ BEKLENİYOR (kullanıcı yapacak)
+`plan_disk_layout` mantığı testlerle kanıtlandı ama **gerçek `parted`
+çıktısıyla masaüstünde karşılaştırılmadı**. ISO'yu boot edip şu
+senaryoları dene:
+
+**Çoklu disk (asıl hedef):**
+1. İki disk bağlı: sda + sdb
+2. Manuel moda geç → tablo **sadece seçili diski** göstermeli; tablo
+   altında **disk şeridi OLMAMALI**
+3. **"Aktif Disk" ComboBox'ı açılmalı ve KOYU TEMADA OKUNMALI**
+   (gradient arkaplan, açık metin rengi)
+4. ComboBox'tan sdb'yi seç → tablo sdb'nin bölümlerine geçmeli
+5. sda'ya geri dön → tablo sda'nın bölümleri (seçili satır sıfırlanmalı,
+   yanlış bölüm seçili kalmasın)
+6. sda'da kök + EFI, sdb'de `/home` → **Aktif Disk ComboBox'ı ile**
+7. Özet ekranında: iki disk, başlıklarda kapasite, altlarında "boş: …",
+   kök diski "[kök]" etiketiyle işaretli
+
+**Silme + yeni bölüm (veri kaybı senaryosu):**
+6. sda'da orta bir bölümü sil → "Boş Alan" satırında birleşsin
+7. Aynı diske büyük bir yeni bölüm ekle (boşluğa SĞMAYACAK boyutta)
+8. **Kritik:** korunan bölümün verisi sağlam kalmalı — `mkfs` yanlış
+   aygıya gitmemeli. Logda "bölüm numarası kaydı" mesajı çıkarsa bu
+   normal, "gerçek aygıt kullanılıyor" demektir.
+
+**Geçiş:**
+9. Geri/İleri ile adımlar arasında gezin, bölüm tanımlarının korunduğunu doğrula
+10. Önyükleyici adımında GRUB aygıtının **kökün olduğu disk** olduğunu doğrula
+
+---
+
+## Bilinen Açıklar / Yapılacaklar
+
+### Yüksek öncelik
+- [ ] **ISO testi yapılmadı** (yukarıdaki kontrol listesi)
+- [ ] `plan_disk_layout` gerçek `parted` ile doğrulanmadı
+- [ ] Silinmek işaretli bölüm bir VG'nin PV'siyse `SetupLvmJob`
+      tarafında kontrol yok
+- [ ] `VolumeGroup.pv_devices` bir PV silinince bayat kalıyor;
+      VG yeniden hesaplanmıyor (silinen PV `pv_devices` içinde kalır,
+      job `pvcreate` çalıştırmaya çalışabilir)
+- [ ] BIOS `device.map` `/dev` **alfabetik** sıraya göre yazılıyor;
+      firmware sırası ile aynı olmayabilir → çoklu diskte BIOS boot kırılgan
+- [ ] ~~`manual_capacity_error` sembolik tanımları hesaba katmıyor~~ —
+      KAPANDI (bkz. "Kalan Alan" bölümü; `has_symbolic_remaining`)
+
+### Orta öncelik
+- [ ] `available_disks` `< 4 GB` diski tamamen gizliyor (ComboBox'ta yok,
+      taranmıyor, kapasite bilgisi yok)
+- [ ] `disk_size_mb` bilinmeyen disk için 0 döndürüyor → boyut slider'ı
+      kullanılamaz hale geliyor
+- [ ] `disk_free_regions_mb`'in eski `SECTOR: u64 = 512` varsayımı
+      4Kn (advanced format) disklerde 8× yanlış boyutlar. sysfs
+      `queue/logical_block_size` okunmalı. (Yeni kod hâlâ 512 varsayıyor.)
+- [ ] `UnmountBindJob` artık tüm ağacı tarıyor ama `EmergencyCleanupJob`
+      yalnızca `custom_partitions`'dan gelen aygıtları biliyor
+- [ ] `rescue.rs`: `pisi takeback` **senkron** çalışıyor (egui thread'i
+      donuyor); başarısız `mount` başarı diye işaretleniyor
+- [ ] Hata tipi: `thiserror` ile `InstallError` enum'ı (≥10 varyant)
+- [ ] `is_complete` → `Result<(), Vec<String>>` veya ayrı
+      `validation_error()`; hatayı gösterme kanalı hâlâ dolambaçlı
+- [ ] 51 `let _ =` sessiz hata yutma (42'si `jobs/`), çoğu yorumlanmış
+      değil
+- [ ] `theme.rs`: paletler 4 yerde çelişkili; `branding.toml [theme]`
+      deserialize ediliyor ama **hiç okunmuyor**; `slides.icons` ve
+      `interval_secs` yok sayılıyor
+- [ ] `setup_fonts` her tema değişiminde 5+ sistem fontu senkron okuyup
+      atlası yeniden rasterize ediyor
+- [ ] Kabuk betiği olarak gömülü 120 satırlık GRUB mantığı
+      (`bootloader.rs::30_uefi-firmware`), test yok
+- [ ] `grub2-mkconfig` hedef sistemin kendi betiğini `sed` ile yamıyor,
+      `2>/dev/null` ile çalışıyor, `let _ =` ile yutuluyor → süreç
+      ortada ölürse kurulu sistem yamalı kalıyor
+- [ ] `is_mount_point` `/proc/mounts` okurken `\040` kaçışlarını çözmüyor
+- [ ] Debug `eprintln!` / `println!` satırları (GUI uygulamasında) —
+      kısmen: disk ComboBox'ındaki `println!("Seçilen Disk Değişti")`
+      **silindi**; kalanlar `main.rs` CLI yolu, `branding.rs` ve
+      `slideshow.rs` başlangıç uyarıları (GUI'de görünmez ama
+      stdout'a yazıyor)
+- [ ] ~100 ölü i18n anahtarı (slayt + eski ekran anahtarları)
+
+### Bilinçli olarak yapılmadı
+- Otomatik mod (erase disk) çoklu disk değil — tek disk. İstenmedi.
+- Bölüm küçültme (shrink) — yok, "sil + yeniden oluştur" yaklaşımı
+  kullanılıyor (eski Yali ile aynı).
+- Lisans ekranı, ekran yöneticisi seçimi, paket seçimi — squashfs
+  akışında anlamsız, dormantanmış durumda.
+
+---
+
+## Dosya Haritası (değişmiş olanlar)
+
+| Dosya | Son durum |
+|---|---|
+| `src/jobs/partition.rs` | `plan_disk_layout` (canlı kernel ile doğrulandı), `PhysicalExtent`, `PlannedCreate`, `disk_total_mb`, `read_physical_extents`, `device_map`; `disk_free_regions_mb` ve `remapped` silindi |
+| `src/jobs/cleanup.rs` | **YENİ** — `EmergencyCleanupJob` |
+| `src/steps/partition.rs` | **tek diske odaklı tablo, şerit YOK** (diyalogda da disk seçicisi yok), **seçime göre görünen butonlar** (`selected_free`), diske filtreli LVM, `validate_manual_on`, `manual_capacity_error`, `mountpoint_required`, `suggest_mountpoint`, `has_symbolic_remaining`, `build_table_rows`, `normalize_lsblk_mountpoint`, `on_disk_changed`, `format_checkbox_from`, `skip_format_from`; `multidisk_tests`, `table_scope_tests`, `free_space_tests`, `symbolic_capacity_tests`, `selection_tests`, `edit_flow_tests`, `edit_disk_tests`, `testutil` |
+| `src/jobs/users.rs` | `set_password_via_chpasswd` (stdin pipe) |
+| `src/jobs/bootloader.rs` | `CRYPTROOT_NAME`, `luks_backing_device`, `mounted_root_device` |
+| `src/jobs/finish.rs` | `RunComarJob` geri geldi; `ldconfig`/`update-environment`/depo fatal |
+| `src/jobs/mod.rs` | `JobQueue::cleanup`, `mounted_paths_under`, `unescape_mount_field`, `open_crypt_mappers`, `auto_mode_partitions` |
+| `src/installer.rs` | `StepRole`, `license_accepted`, `rescue_available` |
+| `src/autoinstall/mod.rs` | `[system]` bölümü, `SystemConfig` (elle `Default`!) |
+| `src/funct.rs` | `AVAILABLE_LANGUAGES`, `sanitize_locale` |
+| `src/ui/buttons.rs` | `gradient_button` — `enabled: false` iken gri + `Sense::hover()` (tıklanamaz). Gradient butonlarda `add_enabled_ui` ÇALIŞMAZ, `*_button_enabled` gerekir. |
+| `src/lib.rs` | **SİLİNDİ** — çift crate root, `locales/` iki kez gömülüyordu |
+| `src/steps/display_manager.rs`, `netinstall.rs`, `license.rs` | dormant (derleniyor, sihirbaza bağlı değil) |
+
+---
+
+## ✅ ÇÖZÜLDÜ: `plan_disk_layout` gerçek kernel ile doğrulandı ve düzeltildi
+
+**28 Eyl 2026.** Bu bir P0 **veri kaybı** hatasıydı; canlı ISO'da
+ölçüldü, düzeltildi ve düzeltme gerçek kernel ile doğrulandı.
+
+### ❌ Eski (YANLIŞ) varsayım
+
+> *"parted rm N sonrası kernel bölümleri başlangıç offset'ine göre
+> sıralayıp 1'den numaralandırır."*
+
+Kod buna göre `survivors.sort_by_key(start)` yapıp her şeyi 1'den
+numaralandırıyor, kaymış bölümleri `remapped` ile bildiriyordu.
+
+### ✅ Gerçek davranış (ölçüldü)
+
+**Kernel, bölümü başlangıç offset'ine göre DEĞİL, bölüm tablosu
+slotuna göre adlandırır.** Bu hem `msdos` hem `gpt` için doğrulandı.
+
+**msdos ölçümü** (VM'de, reboot sonrası taze kernel okuması):
+
+```
+mklabel msdos · 1-101 · 101-301 · 301-5001 · rm 2 · mkpart 5001-6001 MiB
+→ /dev/sdc1 =    1 MiB  (100 MiB)   korunan
+  /dev/sdc2 = 5001 MiB  (1000 MiB)  YENİ
+  /dev/sdc3 =  301 MiB  (4700 MiB)  korunan — KAYMADI
+```
+
+**gpt ölçümü** (host'ta loop + `--partscan`): GPT giriş dizisi ile
+LBA sırası **bilerek farklı** kuruldu (dizi 2 = 5001 MiB, dizi 3 =
+301 MiB). Kernel yine dizi sırasını verdi → LBA'ya göre sıralamıyor.
+
+### Düzeltme
+
+```rust
+// hayatta kalanlar numaralarını KORUR
+let mut taken: BTreeSet<u32> = survivors.iter().filter_map(|(_,_,o)| *o).collect();
+// her yeni bölüm en küçük BOŞ slotu alır
+for p in planned.iter_mut() {
+    let num = (1..).map(|n| n as u32).find(|n| !taken.contains(n))...;
+}
+```
+
+`remapped` **tamamen kaldırıldı** — hayatta kalan bölüm artık kaymadığı
+için hep boş kalıyordu; ölü durum bırakılmadı. Dönüş tipi
+`Result<Vec<PlannedCreate>, String>` oldu, FAZ B'deki döngü silindi.
+
+### Uçtan uca doğrulama
+
+Kodun tahmini ile gerçek kernel **birebir** örtüştü (2 yeni bölüm +
+1 silme, `slot 2` ve `slot 4` — slot 3'ü hayatta kalan bölüm tutuyor):
+
+```
+kernel: p1=1MiB/100  p2=5001MiB/300  p3=301MiB/4700  p4=5301MiB/1000
+kod   :                sdc2 5001-5301              sdc4 5301-6301
+```
+
+### Bu neden önemliydi
+
+Eski kod `device_map`'i **ters** yazıyordu: yeni bölüme `sdX3`,
+korunan bölüme `sdX2` diyordu. FAZ C `mkfs`'i **korunması gereken
+4700 MiB'lik bölüme** uygulardı — tam olarak `plan_disk_layout`'ın
+*önlemek için* yazıldığı veri kaybı.
+
+> 💡 **Bu, `assign_partition_numbers`'ın "en küçük boş slot" kuralının
+> zaten DOĞRU olduğu anlamına gelir.** `plan_disk_layout`'ın bütün
+> varlık sebebi (offset'e göre yeniden numaralandırma) gerçekte
+> gerekli değilmiş. Yeni bölümlere verilen konum (first-fit /
+> en büyük boş bölge) hâlâ gerekli ve kaldı; **yalnızca numaralandırma
+> basitleştirildi.**
+>
+> Ölçüm, tahminin yerine geçmiştir. Ders: "kernel şunu yapar" diye
+> inanılan her kural **ölçülmelidir** — bu proje tam da o yüzden
+> `plan_disk_layout`'a 11 test yazmış ama testler de aynı yanlış
+> varsayımı paylaşıyordu.

README.md

@@ -8,6 +8,7 @@ Rust ve egui ile yeniden yazılmış **Pisi GNU/Linux** kurulum aracı. YALI, ca
 ## Özellikler
 
 - **10 adımlı kurulum sihirbazı**: Hoş Geldiniz → Konum → Klavye → Ağ → Disk Bölümleme → Kullanıcılar → Bootloader → Özet → Kurulum → Bitir
+- **Squashfs tabanlı**: kurulu sistem ISO'nun squashfs'inden kopyanır, paketler ağdan kurulmaz. Ekran yöneticisi, masaüstü ortamı ve paketler ISO'da geldiği için sihirbaz bunları **seçmez** (seçseydi kopyalama zaten ezdiği için yanıltıcı olurdu)
 - **İki mod**: Grafik arayüz (varsayılan) ve cevap dosyasıyla otomatik kurulum (`--auto-install answer.toml`)
 - **Demo modu**: Sistem kontrollerini atlar, kurulumu simüle eder (`--demo`)
 - **Disk bölümleme**: Otomatik (GPT/MBR) veya manuel, LVM ve LUKS şifreleme desteği
@@ -44,8 +45,7 @@ cargo run --bin slides_test [desktop] [lang]
 
 ```
 ├── src/
-│   ├── main.rs              # Giriş noktası, eframe App, GUI düzeni
-│   ├── lib.rs               # Kütüphane kökü (yedek DLL yapısı için ayrıldı)
+│   ├── main.rs              # Giriş noktası, eframe App, GUI düzeni (tek crate root)
 │   ├── installer.rs         # InstallerStep trait'i, GlobalState, WelcomeStep
 │   ├── funct.rs             # Paylaşılan UI yardımcıları (form alanları, dil seçici)
 │   ├── branding.rs          # Branding.toml yükleyici (logo, slayt, tema, OEM)

README_en.md

@@ -5,6 +5,7 @@ A rewritten **Pisi GNU/Linux** installation tool in Rust and egui. YALI installs
 ## Features
 
 - **10-step installation wizard**: Welcome → Location → Keyboard → Network → Disk Partitioning → Users → Bootloader → Summary → Installation → Finish
+- **Squashfs-based**: the installed system is copied from the ISO's squashfs, packages are not fetched over the network. The display manager, desktop environment and packages come from the ISO, so the wizard does **not** offer them (offering them would be misleading, since the copy would overwrite the choice)
 - **Two modes**: Graphical interface (default) and automatic installation with answer file (`--auto-install answer.toml`)
 - **Demo mode**: Skips system checks, simulates installation (`--demo`)
 - **Disk partitioning**: Automatic (GPT/MBR) or manual, LVM and LUKS encryption support

answer-example.toml

@@ -36,3 +36,36 @@ password = "changeme123"
 
 # Bilgisayar adı: harf, rakam ve - ; tire ile başlayamaz/bitemez
 hostname = "pisilinux"
+
+# Kök parolası (isteğe bağlı).
+# Boş bırakılırsa kök hesap KİLİTLENİR (passwd -l root).
+root_password = ""
+
+
+# ─────────────────────────────────────────────
+# [system] — tamamen isteğe bağlı.
+# Bu bölümü hiç yazmazsanız tüm ayarlar güvenli varsayılanlarda kalır.
+# ─────────────────────────────────────────────
+[system]
+# Otomatik oturum açma (varsayılan: false).
+#
+# Gözetimsiz kurulumda açık bırakmayın: kurulan sistemde konsola
+# erişebilen herkes giriş ekranında kullanıcı adını görür ve
+# oturumu açabilir. Ekran yöneticisi ISO'dan gelir; bu ayar yalnızca
+# mevcut oturum yöneticisine "bu kullanıcıyı otomatik aç" yazar.
+autologin = false
+
+# GRUB menü bekleme süresi, saniye (varsayılan: 5)
+bootloader_timeout = 5
+
+# GRUB parolası (isteğe bağlı). Hedefte PBKDF2 ile hashlenir.
+# UYARI: Bu dosyayı güvenli tutun; düz metin olarak saklanır.
+bootloader_password = ""
+
+# Ek çekirdek parametreleri (ör. "quiet splash nomodeset")
+kernel_options = ""
+
+# NOT: Ekran yöneticisi ve masaüstü ortamı BU DOSYADA AYARLANMAZ.
+# YALI kurulu sistemi ISO'nun squashfs'inden kopyar, dolayısıyla
+# bunlar zaten görüntüde bulunurlar; kurulum anında otomatik tespit
+# edilirler. Ek paket kurma (netinstall) da bu akışın parçası değildir.

locales/en.toml

@@ -62,6 +62,7 @@ password_confirm_label  = "Confirm password"
 hostname_label          = "Computer name"
 username_invalid        = "Invalid username. Must start with a lowercase letter or underscore, max 32 characters."
 username_too_long      = "Username too long (maximum 32 characters)"
+username_empty         = "Username cannot be empty"
 username_forbidden     = "This username is reserved by the system and is forbidden"
 username_invalid_start = "Username must start with a lowercase letter or underscore"
 username_invalid_chars = "Only lowercase letters, digits, underscore and hyphen are allowed"
@@ -80,6 +81,7 @@ summary_username     = "Username"
 summary_hostname     = "Computer name"
 summary_erase_mode   = "Entire disk will be erased"
 summary_manual_mode  = "Manual partitioning"
+summary_root_disk_tag = "root"
 summary_not_selected = "Not selected"
 summary_warning      = "⚠ Warning: Clicking Next will permanently erase all data on the selected disk!"
 
@@ -127,6 +129,10 @@ summary_software = "Software"
 summary_display_manager = "Display Manager"
 summary_autologin = "Autologin"
 summary_autologin_user = "Autologin User"
+summary_autologin_on = "On"
+summary_autologin_off = "Off (password login)"
+summary_bootloader_password = "password protected"
+summary_desktop_from_image = "Comes from the ISO image; detected automatically during install"
 summary_desktop = "Desktop"
 
 # ── Display Manager ───────────────────────────────
@@ -135,12 +141,24 @@ display_manager_title = "Display Manager Configuration"
 display_manager_description = "Select your display manager and desktop environment."
 display_manager_select = "Display manager:"
 display_manager_de = "Desktop environment:"
-display_manager_autologin = "Automatic login"
+display_manager_autologin = "Log in automatically"
 display_manager_autologin_user = "Autologin user:"
 display_manager_autologin_hint = "(first user)"
 display_manager_de_not_found = "(not detected)"
 display_manager_note = "Note: The display manager will be enabled by default on the installed system."
 mp_size_remaining = "Remaining Space"
+mp_size_available = "Available"
+mp_active_disk = "Active disk"
+mp_active_disk_hint = "The disk shown in the table and used by New Partition. To add a partition to another disk, switch to that disk in the disk strip above first. The bootloader device defaults to the disk holding the root partition."
+mp_will_delete = "will be deleted"
+mp_restore = "Restore"
+mp_free_space = "Free Space"
+mp_duplicate_mountpoint = "Two partitions share the same mount point; each partition must have a distinct mount point"
+mp_multiple_root = "More than one partition is defined as root (/): {disks}. There must be exactly one root partition"
+mp_partition_no_disk = "A partition definition has no disk selected. Choose the target disk for every partition."
+mp_disk_not_found = "{disk} is no longer attached. Remove the partition definitions on it, or reconnect the disk."
+mp_bar_now = "Current Layout"
+mp_bar_after = "After Installation"
 
 # ── UI / General ──────────────────────────────────────────
 installer         = "YALI Installation Tool"
@@ -209,6 +227,8 @@ job_install_packages = "Installing selected packages"
 job_ldconfig = "Configuring shared libraries (ldconfig)"
 job_update_env = "Updating system environment"
 job_cleanup_live = "Cleaning up live environment traces"
+job_netinstall        = "Installing extra packages"
+job_setup_lvm         = "Configuring LVM"
 
 # ── Manual Partition UI ────────────────────────────────────
 manual_partition_title       = "Manual Partitioning"
@@ -231,10 +251,18 @@ mp_fs_btrfs        = "btrfs"
 mp_fs_xfs          = "xfs"
 mp_fs_fat32        = "FAT32 (EFI)"
 mp_fs_swap         = "swap"
-mp_skip_format     = "Skip Formatting (preserve existing data)"
+mp_format_partition = "Format (existing data will be erased)"
 mp_size_gb         = "%{n} GB"
 mp_size_mb         = "%{n} MB"
 
+# ── Table Column Headers ────────────────────────────────────
+column_device      = "Device"
+column_mount_point = "Mount Point"
+column_label       = "Label"
+column_type        = "Type"
+column_format      = "Format"
+column_size        = "Size"
+
 
 check_ram         = "RAM"
 check_ram_fail    = "%{mb} MB RAM available. Minimum 1 GB required."
@@ -268,6 +296,8 @@ job_mount_custom     = "Mounting manual partitions"
 # ── Extra Localization / i18n ─────────────────────────────
 mp_delete_confirm_title = "Delete Partition"
 mp_error_empty_mountpoint = "Mount point cannot be empty."
+mp_mountpoint_optional = "Mount point is optional. Leave it empty to format the partition without mounting it at boot — useful for exchanging data with Windows."
+mp_error_empty_mountpoint_named = "Mount point cannot be empty: {device}. Pick a mount point from the list, or mark the partition for deletion and continue."
 mp_plan_valid = "✓  Partition plan is valid. You can proceed."
 mp_select_disk_first = "← Select a disk first."
 mp_add_dialog_hint = "/ or /home or swap"
@@ -349,6 +379,8 @@ bootloader_title          = "Bootloader Configuration"
 bootloader_description    = "Configure the bootloader (GRUB) settings."
 bootloader_device_label   = "Install to device:"
 bootloader_device_hint    = "(default: target disk)"
+bootloader_device_hint_dualboot = "For dual boot, pick the disk Windows is installed on. In UEFI mode that disk's Windows ESP is used to add a \"Windows Boot Manager\" entry to the boot menu; if you leave the default, Windows will not appear at boot."
+bootloader_device_why_existing = "This device was picked because it already holds an operating system: the bootloader has to be written to the disk the firmware already boots."
 bootloader_timeout_label  = "Timeout:"
 bootloader_timeout_suffix = "seconds"
 bootloader_password_label = "GRUB password (optional):"
@@ -544,6 +576,7 @@ lvm_lv_add = "Add Logical Volume"
 lvm_lv_error_vg = "At least one Volume Group must be defined."
 lvm_lv_error_size = "Entered size exceeds Volume Group capacity."
 lvm_lv_mountpoint = "Mount Point"
+lvm_no_pv_on_disk = "There is no LVM physical volume on this disk. Add a PV partition to this disk first."
 lvm_lv_fstype = "File System"
 lvm_lv_size = "Size (MB, 0=remaining):"
 lvm_lv_action = "Action"

locales/tr.toml

@@ -62,6 +62,7 @@ password_confirm_label  = "Parola (tekrar)"
 hostname_label          = "Bilgisayar adı"
 username_invalid        = "Geçersiz kullanıcı adı. Küçük harf veya alt çizgi ile başlamalı, en fazla 32 karakter."
 username_too_long      = "Kullanıcı adı çok uzun (maksimum 32 karakter)"
+username_empty         = "Kullanıcı adı boş olamaz"
 username_forbidden     = "Bu kullanıcı adı sistem tarafından kullanılıyor ve yasaklı"
 username_invalid_start = "Kullanıcı adı küçük harf veya alt çizgi ile başlamalı"
 username_invalid_chars = "Sadece küçük harf, rakam, alt çizgi ve tire kullanılabilir"
@@ -80,6 +81,7 @@ summary_username     = "Kullanıcı adı"
 summary_hostname     = "Bilgisayar adı"
 summary_erase_mode   = "Tüm disk silinecek"
 summary_manual_mode  = "Manuel bölümleme"
+summary_root_disk_tag = "kök"
 summary_not_selected = "Seçilmedi"
 summary_warning      = " Dikkat: İleri'ye basıldığında seçilen diskteki tüm veriler kalıcı olarak silinecektir!"
 
@@ -117,6 +119,18 @@ disk_too_small         = "Disk çok küçük"
 summary_partition_plan = "Bölümleme"
 summary_custom_partitions = "Manuel Bölümler"
 mp_size_remaining = "Kalan Alan"
+mp_size_available = "Kullanılabilir"
+mp_active_disk = "Aktif disk"
+mp_active_disk_hint = "Tabloda ve Yeni Bölüm işleminde kullanılan disk. Başka bir diske bölüm eklemek için önce üstteki disk şeridinden o diske geçin. GRUB aygıtı kök bölümün olduğu disk olarak ayarlanır."
+mp_will_delete = "silinecek"
+mp_restore = "Geri Al"
+mp_free_space = "Boş Alan"
+mp_duplicate_mountpoint = "Aynı bağlama noktası iki bölüme birden verilmiş; her bölümün farklı bir bağlama noktası olmalı"
+mp_multiple_root = "Birden fazla bölüm kök (/) olarak tanımlanmış: {disks}. Kök tek bir bölüm olmalı"
+mp_partition_no_disk = "Bir bölüm tanımı için disk seçilmemiş. Her bölümün yerleşeceği diski seçin."
+mp_disk_not_found = "{disk} artık bağlı değil. Bu diske yapılan bölüm tanımını kaldırın ya da diski yeniden bağlayın."
+mp_bar_now = "Mevcut Durum"
+mp_bar_after = "Kurulum Sonrası"
 
 # ── UI / Genel ────────────────────────────────────────────
 installer         = "PisiLinux Kurulum Aracı"
@@ -137,7 +151,6 @@ check_warn_notice   = "Bazı önerilen gereksinimler karşılanmıyor. Kurulum d
 check_all_pass      = "Tüm sistem gereksinimleri karşılandı."
 recheck             = "🔄  Yeniden Kontrol Et"
 rescue_button       = "🆘  Kurtarma Kipi"
-rescue_button_tooltip = "PiSi Linux'u Kurtarma Modunda Yeniden Kur"
 
 # ── Users (ek) ────────────────────────────────────────────
 pwd_very_weak = "Çok zayıf"
@@ -202,10 +215,18 @@ mp_fs_btrfs        = "btrfs"
 mp_fs_xfs          = "xfs"
 mp_fs_fat32        = "FAT32 (EFI)"
 mp_fs_swap         = "takas (swap)"
-mp_skip_format     = "Biçimlendirmeyi Atla (mevcut veri korunur)"
+mp_format_partition = "Biçimlendir (mevcut veri silinir)"
 mp_size_gb         = "%{n} GB"
 mp_size_mb         = "%{n} MB"
 
+# ── Tablo Sütun Başlıkları ────────────────────────────────────
+column_device      = "Aygıt"
+column_mount_point = "Bağlama Noktası"
+column_label       = "Etiket"
+column_type        = "Tür"
+column_format      = "Biçim"
+column_size        = "Boyut"
+
 
 check_ram         = "RAM"
 check_ram_fail    = "%{mb} MB RAM mevcut. Kurulum için minimum 1 GB gerekli."
@@ -239,6 +260,8 @@ job_mount_custom     = "Manuel bölümler bağlanıyor"
 # ── Ek Yerelleştirme / i18n ──────────────────────────────────
 mp_delete_confirm_title = "Bölümü Sil"
 mp_error_empty_mountpoint = "Bağlama noktası boş olamaz."
+mp_mountpoint_optional = "Bağlama noktası isteğe bağlı. Boş bırakırsanız bölüm biçimlendirilir ama sistem başlangıcında bağlanmaz; Windows'tan erişmek için kullanılır."
+mp_error_empty_mountpoint_named = "Bağlama noktası boş olamaz: {device}. Listeden bir bağlama noktası seçin ya da bölümü \"Sil\" işaretleyip geçin."
 mp_plan_valid = "Bölüm planı geçerli. İleri tuşuna basabilirsiniz."
 mp_select_disk_first = "← Önce bir disk seçin."
 mp_add_dialog_hint = "/ veya /home veya swap"
@@ -268,6 +291,10 @@ summary_software        = "Yazılım"
 summary_display_manager = "Görüntü Yöneticisi"
 summary_autologin       = "Otomatik oturum açma"
 summary_autologin_user  = "Otomatik oturum açılacak kullanıcı"
+summary_autologin_on    = "Açık"
+summary_autologin_off   = "Kapalı (parola ile giriş)"
+summary_bootloader_password = "parola korumalı"
+summary_desktop_from_image = "ISO görüntüsünden gelir; kurulumda otomatik tespit edilir"
 summary_desktop         = "Masaüstü"
 
 # ── Görüntü Yöneticisi ───────────────────────────────────────
@@ -276,7 +303,7 @@ display_manager_title        = "Görüntü Yöneticisi Yapılandırması"
 display_manager_description  = "Görüntü yöneticinizi ve masaüstü ortamınızı seçin."
 display_manager_select       = "Görüntü yöneticisi:"
 display_manager_de           = "Masaüstü ortamı:"
-display_manager_autologin    = "Otomatik oturum açma"
+display_manager_autologin    = "Otomatik oturum aç"
 display_manager_autologin_user = "Otomatik oturum açılacak kullanıcı:"
 display_manager_autologin_hint = "(ilk kullanıcı)"
 display_manager_de_not_found = "(algılanamadı)"
@@ -291,7 +318,6 @@ job_ldconfig           = "Paylaşımlı kütüphaneler yapılandırılıyor (ldc
 job_update_env         = "Sistem ortamı güncelleniyor"
 job_cleanup_live       = "Canlı ortam izleri temizleniyor"
 job_datetime           = "Tarih & saat yapılandırılıyor"
-job_display_manager    = "Görüntü yöneticisi yapılandırılıyor"
 job_autologin          = "Otomatik oturum açma uygulanıyor"
 job_netinstall         = "Ek paketler kuruluyor"
 job_setup_lvm          = "LVM yapılandırılıyor"
@@ -361,6 +387,8 @@ bootloader_title          = "Önyükleyici Yapılandırması"
 bootloader_description    = "Önyükleyici (GRUB) ayarlarını yapılandırın."
 bootloader_device_label   = "Aygıta kur:"
 bootloader_device_hint    = "(varsayılan: hedef disk)"
+bootloader_device_hint_dualboot = "Çift önyükleme yapacaksanız burada Windows'un kurulu olduğu diski seçin. UEFI modunda bu aygıtın bölümündeki Windows ESP'sinden \"Windows Boot Manager\" menüye eklenir; seçmezseniz açılışta Windows görünmez."
+bootloader_device_why_existing = "Bu aygıt, üzerinde hâlihazırda işletim sistemi bulunduğu için seçildi: önyükleyici açılışta zaten okunan diske yazılmalıdır."
 bootloader_timeout_label  = "Bekleme süresi:"
 bootloader_timeout_suffix = "saniye"
 bootloader_password_label = "GRUB parolası (isteğe bağlı):"
@@ -426,6 +454,7 @@ lvm_lv_add       = "Mantıksal Birim Ekle"
 lvm_lv_error_vg  = "En az bir Birim Grubu tanımlanmalıdır."
 lvm_lv_error_size = "Girilen boyut, Birim Grubu kapasitesini aşıyor."
 lvm_lv_mountpoint = "Bağlama Noktası"
+lvm_no_pv_on_disk = "Bu diskte LVM PV yok. Önce bu diske PV bölümü ekleyin."
 lvm_lv_fstype    = "Dosya Sistemi"
 lvm_lv_size      = "Boyut (MB, 0=kalan):"
 lvm_lv_action    = "İşlem"

slides/slides_en copy.toml122

@@ -0,0 +1,243 @@
+# ╔══════════════════════════════════════════════════════════════════╗
+# ║  Yali-RS — Slide Content (English)                             ║
+# ╚══════════════════════════════════════════════════════════════════╝
+
+# Slide transition duration (seconds)
+interval_secs = 6
+
+[[items]]
+icon = "slides/img/pisilinux-logo.png"
+title       = "Welcome to Pisi GNU/Linux"
+description = "Pisi is a Turkish-supported GNU/Linux distribution that combines speed, stability, and ease of use."
+
+[[items]]
+icon = "slides/img/pisi-software-center.png"
+title       = "PISI Package Manager"
+description = "Access thousands of packages with a single command. Install anything you need easily with `pisi install <package>`."
+
+[[items]]
+icon = "slides/img/community-101.png"
+title       = "Community Support"
+description = "Our active community at forum.pisilinux.org is ready to answer your questions. Our wiki pages are always accessible."
+
+[[items]]
+icon = "slides/img/pisi_speed.png"
+title       = "Speed & Performance"
+description = "Thanks to an optimized kernel and startup services, PisiLinux boots in seconds and uses minimal resources."
+
+[[items]]
+icon = "slides/img/securety.png"
+title       = "Security First"
+description = "Keep your system secure with regular security updates, AppArmor profiles, and secure default settings."
+
+[[items]]
+icon = "slides/img/customization-dark.png"
+title       = "Customization"
+description = "Tailor everything to your taste — from the desktop environment and theme colors to panel layout and keyboard shortcuts."
+
+# ── Budgie ────────────────────────────────────────────────────────
+[[items]]
+desktop     = "budgie"
+icon = "slides/img/budgie.png"
+title       = "PisiLinux Budgie"
+description = "A modern, clean, and elegant Budgie desktop. Built on the GNOME stack and user-friendly."
+
+[[items]]
+desktop     = "budgie"
+icon = "slides/img/budgie_applets.png"
+title       = "Budgie Desktop Applets"
+description = "Easily add tools like weather, system monitor, and calendar via Budgie's panel applets."
+
+[[items]]
+desktop     = "budgie"
+icon = "slides/img/budgie_raven.png"
+title       = "Raven Notification Center"
+description = "Access volume, media controls, notifications, and quick settings from the Raven panel."
+
+[[items]]
+desktop     = "budgie"
+icon = "slides/img/budgie_gtk_theme.png"
+title       = "GTK Theme Support"
+description = "Budgie runs GTK themes and GNOME applications seamlessly, ensuring visual consistency."
+
+# ── Cinnamon ──────────────────────────────────────────────────────
+[[items]]
+desktop     = "cinnamon"
+icon = "slides/img/cinnamon.png"
+title       = "PisiLinux Cinnamon"
+description = "Cinnamon combines the traditional desktop experience with modern features, offering a powerful and flexible environment."
+
+[[items]]
+desktop     = "cinnamon"
+icon = "slides/img/cinnamon_panel.png"
+title       = "Cinnamon Panel"
+description = "Customize your panel with applets, launchers, and system indicators for a classic yet powerful desktop."
+
+[[items]]
+desktop     = "cinnamon"
+icon = "slides/img/cinnamon_settings.png"
+title       = "Settings Manager"
+description = "Fine-tune every aspect of your Cinnamon desktop through the comprehensive Settings Manager."
+
+[[items]]
+desktop     = "cinnamon"
+icon = "slides/img/cinnamon_desklets.png"
+title       = "Cinnamon Desklets"
+description = "Keep notes, clocks, and system info always visible on your desktop with Cinnamon Desklets."
+
+# ── GNOME ─────────────────────────────────────────────────────────
+[[items]]
+desktop     = "gnome"
+icon = "slides/img/gnome.png"
+title       = "PisiLinux GNOME"
+description = "Reduce distractions and focus on your work with the clean and focused GNOME desktop environment."
+
+[[items]]
+desktop     = "gnome"
+icon = "slides/img/gnome_search.png"
+title       = "GNOME Search"
+description = "Press the Super key and start typing. Instantly reach applications, files, and settings."
+
+[[items]]
+desktop     = "gnome"
+icon = "slides/img/gnome_extensions.png"
+title       = "GNOME Extensions"
+description = "Shape your desktop to your needs with hundreds of extensions from extensions.gnome.org."
+
+# ── KDE ───────────────────────────────────────────────────────────
+[[items]]
+desktop     = "kde"
+icon = "slides/img/kde.png"
+title       = "PisiLinux KDE Plasma"
+description = "Meet the modern, customizable, and powerful KDE Plasma desktop. Everything is at your fingertips."
+
+[[items]]
+desktop     = "kde"
+icon = "slides/img/file_manager.png"
+title       = "Dolphin File Manager"
+description = "Dolphin makes managing your files easy with tabbed browsing, dual-panel view, and powerful search."
+
+[[items]]
+desktop     = "kde"
+icon = "slides/img/kde_connect.png"
+title       = "KDE Connect"
+description = "Connect your phone to your computer. Notifications, file transfer, and clipboard sharing — all with KDE Connect."
+
+[[items]]
+desktop     = "kde"
+icon = "slides/img/discover.png"
+title       = "Discover Software Center"
+description = "Easily find, install, and update applications from the visual interface with Discover."
+
+# ── LXQt ──────────────────────────────────────────────────────────
+[[items]]
+desktop     = "lxqt"
+icon = "slides/img/lxqt.png"
+title       = "PisiLinux LXQt"
+description = "A lightweight, fast, and modern LXQt desktop environment. Low resource consumption, high performance."
+
+[[items]]
+desktop     = "lxqt"
+icon = "slides/img/lxqt_panel.png"
+title       = "LXQt Panel"
+description = "The traditional panel layout puts the taskbar, application launcher, and system tray always within reach."
+
+[[items]]
+desktop     = "lxqt"
+icon = "slides/img/file_manager.png"
+title       = "PCManFM-Qt File Manager"
+description = "Manage files effortlessly with the lightweight and fast PCManFM-Qt. Tabbed navigation and a customizable interface."
+
+# ── LXDE ──────────────────────────────────────────────────────────
+[[items]]
+desktop     = "lxde"
+icon = "slides/img/lxde.png"
+title       = "PisiLinux LXDE"
+description = "The legendary lightweight LXDE desktop. Known for extremely low resource usage and a reliable build."
+
+[[items]]
+desktop     = "lxde"
+icon = "slides/img/lxde_openbox.png"
+title       = "Openbox-Based"
+description = "LXDE uses the Openbox window manager. Fine-tune it for a smooth and responsive experience."
+
+[[items]]
+desktop     = "lxde"
+icon = "slides/img/file_manager.png"
+title       = "PCManFM File Manager"
+description = "PCManFM speeds up your file operations with its fast and lightweight build, supporting tree view and tabs."
+
+# ── Lumina ────────────────────────────────────────────────────────
+[[items]]
+desktop     = "lumina"
+icon = "slides/img/lumina.png"
+title       = "PisiLinux Lumina"
+description = "A lightweight and independent Lumina desktop. Qt-based, designed to run cleanly on BSD and Linux systems."
+
+[[items]]
+desktop     = "lumina"
+icon = "slides/img/lumina_applications.png"
+title       = "Application Support"
+description = "Lumina works well with core utilities and many popular Qt apps, providing a practical everyday experience."
+
+[[items]]
+desktop     = "lumina"
+icon = "slides/img/lumina_theme.png"
+title       = "Theme Customization"
+description = "Easily customize color schemes and interface styles with Lumina's flexible theme system."
+
+[[items]]
+desktop     = "lumina"
+icon = "slides/img/lumina_panel.png"
+title       = "Lumina Panel"
+description = "A clean panel with a taskbar, application launcher, and system tray keeps your desktop organized."
+
+# ── MATE ──────────────────────────────────────────────────────────
+[[items]]
+desktop     = "mate"
+icon = "slides/img/mate.png"
+title       = "PisiLinux MATE"
+description = "MATE for those who love the traditional desktop layout. Developed with GTK+ 3 for a modern and smooth experience."
+
+[[items]]
+desktop     = "mate"
+icon = "slides/img/file_manager.png"
+title       = "Caja File Manager"
+description = "Manage your files easily with MATE's powerful Caja. Dual panel, tabbed navigation, and rich features."
+
+[[items]]
+desktop     = "mate"
+icon = "slides/img/mate_settings.png"
+title       = "MATE Settings"
+description = "Customize your MATE desktop with comprehensive settings for appearance, display, keyboard, and more."
+
+[[items]]
+desktop     = "mate"
+icon = "slides/img/mate_applications.png"
+title       = "Rich Application Suite"
+description = "MATE comes with a rich set of classic applications — from text editors to image viewers, all well-integrated."
+
+# ── XFCE ──────────────────────────────────────────────────────────
+[[items]]
+desktop     = "xfce"
+icon = "slides/img/xfce.png"
+title       = "PisiLinux XFCE"
+description = "A lightweight, fast, and user-friendly XFCE desktop environment. Low resource consumption, high performance."
+
+[[items]]
+desktop     = "xfce"
+icon = "slides/img/xfce_panel.png"
+title       = "XFCE Panel"
+description = "The traditional panel layout puts the taskbar, application menu, and system tray always within reach."
+
+[[items]]
+desktop     = "xfce"
+icon = "slides/img/file_manager.png"
+title       = "Thunar File Manager"
+description = "Manage your files easily with the fast and lightweight Thunar. Tree view, tabbed navigation, and customizable features."
+
+[[items]]
+desktop     = "xfce"
+icon = "slides/img/xfce_settings.png"
+title       = "Whisker Menu"
+description = "A modern alternative to the classic application menu. Find apps easily and organize your favorites with Whisker Menu."

src/autoinstall/mod.rs

@@ -33,6 +33,53 @@ pub struct UserConfig {
     pub password: String,
     #[serde(default = "default_hostname")]
     pub hostname: String,
+    /// Kök hesabın parolası. Boş bırakılırsa root kilitlenir
+    /// (`CreateUserJob` → `passwd -l root`).
+    #[serde(default)]
+    pub root_password: String,
+}
+
+/// `[system]` bölümü — isteğe bağlı davranış ayarları.
+///
+/// Tümü `#[serde(default)]`: answer dosyası yalnızca zorunlu alanları
+/// içerebilir. Bu bölümü tanımlamak zorunlu değil.
+#[derive(Debug, serde::Deserialize)]
+pub struct SystemConfig {
+    /// Otomatik oturum açma.
+    ///
+    /// Varsayılan KAPALI. Gözetimsiz kurulumda açık olması, kurulmuş
+    /// sistemde herhangi birinin fiziksel olarak konsola oturup
+    /// kullanıcı adını görmesini kolaylaştırır.
+    #[serde(default)]
+    pub autologin: bool,
+    /// GRUB bekleme süresi (saniye).
+    #[serde(default = "default_grub_timeout")]
+    pub bootloader_timeout: u32,
+    /// GRUB parolası (düz metin; hedefte PBKDF2 ile hashlenir).
+    #[serde(default)]
+    pub bootloader_password: String,
+    /// Ek çekirdek parametreleri.
+    #[serde(default)]
+    pub kernel_options: String,
+}
+
+// DİKKAT: burada `#[derive(Default)]` KULLANILMAZ.
+//
+// `[system]` bloğu answer dosyasında HİÇ YOKSA serde, AnswerFile'daki
+// `#[serde(default)]` sayesinde bu tipin Default'ını çağırır. Alan
+// bazlı `#[serde(default = "...")]` anotasyonları yalnızca blok
+// KATILDIĞINDA, ilgili alan eksik olduğunda devreye girer. Yani
+// türetilmiş Default, bootloader_timeout'ı 0 yapardı → kurulumda GRUB
+// menüsü hiç görünmez. Elle uyguluyoruz.
+impl Default for SystemConfig {
+    fn default() -> Self {
+        Self {
+            autologin: false,
+            bootloader_timeout: default_grub_timeout(),
+            bootloader_password: String::new(),
+            kernel_options: String::new(),
+        }
+    }
 }
 
 /// Answer file'ın tamamı (`--auto-install <dosya.toml>`).
@@ -40,6 +87,9 @@ pub struct UserConfig {
 pub struct AnswerFile {
     pub install: InstallConfig,
     pub user:    UserConfig,
+    /// İsteğe bağlı. Verilmezse tüm ayarlar güvenli varsayılanlarda kalır.
+    #[serde(default)]
+    pub system:  SystemConfig,
 }
 
 fn default_timezone()  -> String { "Europe/Istanbul".to_string() }
@@ -48,6 +98,7 @@ fn default_keyboard()  -> String { "tr".to_string() }
 fn default_source()    -> String { "/run/livecd/squashfs-root/".to_string() }
 fn default_mount()     -> String { "/mnt".to_string() }
 fn default_hostname()  -> String { "pisilinux".to_string() }
+fn default_grub_timeout() -> u32 { 5 }
 
 // ─────────────────────────────────────────────
 // ANSWER FILE: YÜKLE ve UYGULA
@@ -105,11 +156,28 @@ pub fn apply_to_state(af: &AnswerFile, state: &mut crate::installer::GlobalState
     state.username         = af.user.username.clone();
     state.password         = af.user.password.clone();
     state.password_confirm = af.user.password.clone();
+    state.root_password    = af.user.root_password.clone();
+    state.root_password_confirm = af.user.root_password.clone();
     state.hostname         = af.user.hostname.clone();
     state.selected_disk    = Some(af.install.disk.clone());
     state.erase_disk       = true;
     state.language         = if af.install.locale.starts_with("tr") { "tr" } else { "en" }.to_string();
 
+    // [system] — isteğe bağlı davranış ayarları
+    state.autologin            = af.system.autologin;
+    state.bootloader_timeout   = af.system.bootloader_timeout;
+    state.bootloader_password  = af.system.bootloader_password.clone();
+    state.kernel_options       = af.system.kernel_options.clone();
+    // GRUB aygıtı: bölümleme yapılmadan önce bilinmez, kuruluma
+    // InstallGrubJob içinde atanır.
+    state.bootloader_device    = String::new();
+
+    // Masaüstü ortamı ve ekran yöneticisi answer file'dan GELMEZ.
+    // Sistem squashfs'ten kopyalandığı için bunlar ISO'nun kendisidir;
+    // GlobalState::default() zaten canlı ortamı tespit ediyor
+    // (detect_desktop_environment). Burada sabit bir değer yazmak,
+    // XFCE ISO'sunda Plasma oturumu açmaya çalışırdı.
+
     // Disk boyutunu lsblk ile sorgula
     let disk_info: Option<DiskInfo> = (|| {
         let out = std::process::Command::new("lsblk")
@@ -165,3 +233,99 @@ pub fn apply_to_state(af: &AnswerFile, state: &mut crate::installer::GlobalState
     }
 }
 
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const MINIMAL: &str = r#"
+[install]
+disk = "/dev/sda"
+
+[user]
+username = "pisi"
+password = "gizli123"
+hostname = "pisi-pc"
+"#;
+
+    const WITH_SYSTEM: &str = r#"
+[install]
+disk = "/dev/nvme0n1"
+
+[user]
+username = "pisi"
+password = "gizli123"
+root_password = "rootgizli"
+
+[system]
+autologin = true
+bootloader_timeout = 10
+bootloader_password = "grubparola"
+kernel_options = "quiet splash"
+"#;
+
+    #[test]
+    fn minimal_answer_file_parses() {
+        // [system] tamamen isteğe bağlı — yoksa ayrıştırma patlamamalı.
+        let af = toml::from_str::<AnswerFile>(MINIMAL).expect("ayrıştırılmalı");
+        assert_eq!(af.install.disk, "/dev/sda");
+        assert_eq!(af.user.username, "pisi");
+        assert_eq!(af.user.root_password, "", "varsayılan boş olmalı");
+        assert!(!af.system.autologin, "autologin güvenli varsayılanı kapalı");
+        assert_eq!(af.system.bootloader_timeout, 5);
+        assert!(af.system.bootloader_password.is_empty());
+        assert!(af.system.kernel_options.is_empty());
+    }
+
+    #[test]
+    fn system_section_is_honoured() {
+        let af = toml::from_str::<AnswerFile>(WITH_SYSTEM).expect("ayrıştırılmalı");
+        assert_eq!(af.install.disk, "/dev/nvme0n1");
+        assert_eq!(af.user.root_password, "rootgizli");
+        assert!(af.system.autologin, "autologin açık olmalı");
+        assert_eq!(af.system.bootloader_timeout, 10);
+        assert_eq!(af.system.bootloader_password, "grubparola");
+        assert_eq!(af.system.kernel_options, "quiet splash");
+    }
+
+    #[test]
+    fn example_file_on_disk_is_valid() {
+        // Depodaki örnek dosya gerçekten ayrıştırılabiliyor mu?
+        let p = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("answer-example.toml");
+        let content = std::fs::read_to_string(&p)
+            .expect("answer-example.toml okunmalı");
+        toml::from_str::<AnswerFile>(&content)
+            .expect("answer-example.toml ayrıştırılabilmeli");
+    }
+
+    #[test]
+    fn bootloader_timeout_default_survives_missing_system_block() {
+        // Regresyon: SystemConfig türetilmiş Default'a sahipti ve 0
+        // veriyordu. `[system]` bloğu dosyada HİÇ YOKSA serde alan
+        // bazlı `#[serde(default = "...")]` anotasyonlarına UĞRAMAZ;
+        // doğrudan Default::default() çağırır. Sonuç: GRUB bekleme
+        // süresi 0 saniye → kurulumda bootloader menüsü hiç görünmez.
+        let af = toml::from_str::<AnswerFile>(MINIMAL).unwrap();
+        assert_eq!(
+            af.system.bootloader_timeout, 5,
+            "[system] yokken de varsayılan geçerli olmalı"
+        );
+        assert_eq!(SystemConfig::default().bootloader_timeout, 5);
+    }
+
+    #[test]
+    fn default_impl_matches_serde_field_defaults() {
+        // İki yol da aynı sonucu vermeli.
+        let d = SystemConfig::default();
+        assert!(!d.autologin);
+        assert!(d.bootloader_password.is_empty());
+        assert!(d.kernel_options.is_empty());
+    }
+
+    #[test]
+    fn missing_required_section_is_rejected() {
+        // [user] olmadan kabul edilmemeli.
+        let bad = "[install]\ndisk = \"/dev/sda\"\n";
+        assert!(toml::from_str::<AnswerFile>(bad).is_err());
+    }
+}

src/funct.rs

@@ -1,5 +1,28 @@
 use eframe::egui;
 
+/// Uygulamanın desteklediği diller (`locales/` altındaki dosyalarla eşleşir).
+///
+/// `locales/` klasörüne yeni bir dosya eklendiğinde buraya da eklenmelidir.
+pub const AVAILABLE_LANGUAGES: &[&str] = &["tr", "en"];
+
+/// Yedek dil: desteklenmeyen bir kod gelirse kullanılır.
+pub const FALLBACK_LANGUAGE: &str = "en";
+
+/// `rust_i18n::set_locale` çağrısından ÖNCE kullanılır.
+///
+/// Neden: `set_locale("de")` hata vermez, sessizce kabul eder ve `t!()`
+/// karşılığı olmayan her anahtar için anahtarın KENDİSİNİ döndürür —
+/// arayüz "location_title", "next", "partition" gibi çıplak metinlere
+/// dolar. O yüzden karar burada verilir: dil desteklenmiyorsa hiç
+/// değiştirilmez, kullanıcının seçimi korunur.
+pub fn sanitize_locale(locale: &str) -> &str {
+    if AVAILABLE_LANGUAGES.contains(&locale) {
+        locale
+    } else {
+        FALLBACK_LANGUAGE
+    }
+}
+
 #[macro_export]
 macro_rules! draw_icon {
     ($ui:expr, $path:literal, $size:expr, $color:expr) => {
@@ -150,4 +173,36 @@ pub fn language_selector_ui(ui: &mut eframe::egui::Ui, state: &mut crate::instal
             }
         });
     });
-}
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn supported_locales_pass_through() {
+        assert_eq!(sanitize_locale("tr"), "tr");
+        assert_eq!(sanitize_locale("en"), "en");
+    }
+
+    #[test]
+    fn unsupported_locales_fall_back() {
+        // Bu diller için locale dosyası YOK. set_locage'e sızsaydı
+        // arayüz çıplak anahtarlarla dolardı.
+        for code in ["de", "fr", "it", "es", "ru", "nl", "pl", "xx", ""] {
+            assert_eq!(
+                sanitize_locale(code),
+                FALLBACK_LANGUAGE,
+                "{} desteklenmiyor, yedeğe düşmeli", code
+            );
+        }
+    }
+
+    #[test]
+    fn fallback_language_is_itself_supported() {
+        // Yedeğin de desteklenmemesi durumunda sonsuz hata durumu oluşur.
+        assert!(
+            AVAILABLE_LANGUAGES.contains(&FALLBACK_LANGUAGE),
+            "yedek dil {} desteklenen listede olmalı", FALLBACK_LANGUAGE
+        );
+    }
+}

src/installer.rs

@@ -59,12 +59,34 @@ pub fn part_path(disk: &str, num: u32) -> String {
 }
 
 
+/// Bir adımın sihirbaz içindeki rolü.
+///
+/// Rol, adımın LİSTEDEKİ KONUMUNDAN değil kendisinden bildirilir. Daha
+/// önce `main.rs` rolü `cur == n_steps - 2` gibi konumsal olarak
+/// tahmin ediyordu; sihirbaza yeni bir adım eklemek (ör. LicenseStep)
+/// bu tespiti sessizce kaydırıp "Geri" butonunu veya bitiş ekranını
+/// yanlış adıma bağlıyordu.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum StepRole {
+    /// Sıradan bir yapılandırma adımı.
+    Normal,
+    /// Kurulumun çalıştığı ekran. "İleri" gizlenir.
+    Execution,
+    /// Kurulum sonrası ekran. Yalnızca yeniden başlatma/çıkış sunar.
+    Finish,
+}
+
 /// Calamares'in "ViewStep" yapısına benzer bir Trait.
 pub trait InstallerStep {
     fn name(&self) -> String;
     fn on_enter(&mut self, _state: &mut GlobalState) {}
     fn show(&mut self, ui: &mut egui::Ui, state: &mut GlobalState);
     fn is_complete(&self, state: &GlobalState) -> bool;
+
+    /// Adımın rolü. Varsayılan `Normal`.
+    fn role(&self) -> StepRole {
+        StepRole::Normal
+    }
 }
 
 // ─────────────────────────────────────────────
@@ -167,11 +189,86 @@ pub struct LogicalVolume {
     pub mountpoint: String,
 }
 
+/// Cihaz yolundan ait olduğu diskin yolunu çıkarır.
+///
+/// - `/dev/sda1`      → `/dev/sda`
+/// - `/dev/nvme0n1p2` → `/dev/nvme0n1`
+/// - `/dev/mmcblk0p1` → `/dev/mmcblk0`
+#[allow(dead_code)] // genel yardımcı; testlerde ve gelecekteki işlerde kullanılır
+pub fn device_to_disk(device: &str) -> String {
+    let base = device.trim_start_matches("/dev/");
+    // NVMe/MMC/loop aygıtlarında bölüm ayracı "p" + rakamdır
+    let needs_p = base.contains("nvme") || base.contains("mmcblk") || base.contains("loop");
+    if let Some(pos) = base.rfind('p') {
+        if needs_p && base[pos + 1..].chars().all(|c| c.is_ascii_digit()) && !base[pos + 1..].is_empty() {
+            return format!("/dev/{}", &base[..pos]);
+        }
+    }
+    // SATA/virtio: sondaki tüm rakamları at
+    let trimmed = base.trim_end_matches(|c: char| c.is_ascii_digit());
+    format!("/dev/{}", trimmed)
+}
+
+/// Cihaz adından bölüm numarasını çıkarır ("/dev/sda3" → 3,
+/// "/dev/nvme0n1p2" → 2). Sonda rakam yoksa None döner.
+pub fn part_number(device: &str) -> Option<u32> {
+    let base = device.trim_start_matches("/dev/");
+    let digits: String = base.chars().rev().take_while(|c| c.is_ascii_digit()).collect();
+    digits.chars().rev().collect::<String>().parse().ok()
+}
+
+/// Bölüm tanımlarına parted'ın gerçek slot davranışını izleyerek
+/// aygıt numarası atar.
+///
+/// Eski Yali modeliyle aynı mantık: fiziksel (silinmemiş) bölümler
+/// kendi numaralarını korur; silinmek işaretlenenlerin slotları boşalır
+/// ve yeni tanımlar en küçük boş slotu sırayla doldurur. Örn. sda2
+/// silinip yeni bölüm eklenirse yeni bölüm sda2 olur; sda3 yerinde kalır.
+pub fn assign_partition_numbers(parts: &mut [CustomPartition]) {
+    use std::collections::BTreeSet;
+    // Disk bazlı kullanılan slot kümeleri
+    let mut used: std::collections::HashMap<String, BTreeSet<u32>> = std::collections::HashMap::new();
+    for p in parts.iter() {
+        if p.delete { continue; }               // silinecekler slot açar
+        if !p.orig_device.is_empty() {           // fiziksel: kendi numarası
+            if let Some(n) = part_number(&p.orig_device) {
+                used.entry(p.disk.clone()).or_default().insert(n);
+            }
+        }
+    }
+    for p in parts.iter_mut() {
+        if p.delete {
+            // Silinecek bölüm: kurulumda yok olacak; adı olduğu gibi kalır,
+            // yeni slot tüketmez.
+            continue;
+        }
+        match part_number(&p.orig_device) {
+            Some(n) => { p.device = part_path(&p.disk, n); }
+            None => {
+                let set = used.entry(p.disk.clone()).or_default();
+                // en küçük boş slot
+                let mut n = 1u32;
+                while set.contains(&n) { n += 1; }
+                set.insert(n);
+                p.device = part_path(&p.disk, n);
+            }
+        }
+    }
+}
+
 /// Kullanıcının manuel olarak tanımladığı tek bir bölüm.
 #[derive(Clone, Debug)]
 pub struct CustomPartition {
+    /// Bölümün ait olduğu disk (ör. "/dev/sda").
+    /// Çoklu disk kurulumunda bölümler diske göre gruplanır.
+    pub disk: String,
     /// Bölüm aygit adı; oluşturulacak (ör. "/dev/sda1")
     pub device: String,
+    /// Taramada bulunan fiziksel cihaz adı (örn. "/dev/sda3").
+    /// Kullanıcı tarafından yeni eklenen tanımlarda boştur.
+    /// Silme işleminde satırın listede kalıp yeniden
+    /// tanımlanabilmesini sağlar.
+    pub orig_device: String,
     /// Boyut MB cinsinden; 0 = "kalan alan"
     pub size_mb: u64,
     /// Dosya sistemi
@@ -186,6 +283,10 @@ pub struct CustomPartition {
     pub luks_name: String,
     /// false = biçimlendir, true = olduğu gibi bırak (mevcut bölümleri koru)
     pub skip_format: bool,
+    /// true = kurulum sırasında bu bölüm diskten SİLİNECEK
+    /// (eski Yali'deki OperationDestroyDevice karşılığı).
+    /// Satır listede görünür kalır; istenirse işaret geri alınır.
+    pub delete: bool,
 }
 
 /// Kurulum boyunca toplanan tüm veriler.
@@ -215,6 +316,9 @@ pub struct GlobalState {
     pub demo_mode: bool,
     pub is_dark: bool,
     pub rescue_mode: bool,
+    /// GPL lisans metnini kullanıcı okudu ve kabul etti.
+    /// Demo modunda zorunlu değildir.
+    pub license_accepted: bool,
     pub bootloader_device: String,
     pub bootloader_timeout: u32,
     pub bootloader_password: String,
@@ -278,6 +382,7 @@ impl Default for GlobalState {
             demo_mode: false,
             is_dark: true,
             rescue_mode: false,
+            license_accepted: false,
             bootloader_device: String::new(),
             bootloader_timeout: 5,
             bootloader_password: String::new(),
@@ -320,6 +425,9 @@ pub struct WelcomeStep {
     checks:        Vec<CheckResult>,
     checked:       bool,
     last_language: String,
+    /// Kurtarma modunun kullanılabilir olup olmadığı. `on_enter`'da bir kez
+    /// hesaplanır — `blkid` her karede çalıştırılırsa UI kilitlenir.
+    rescue_available: bool,
 }
 
 impl Default for WelcomeStep {
@@ -328,6 +436,7 @@ impl Default for WelcomeStep {
             checks:        Vec::new(),
             checked:       false,
             last_language: String::new(),
+            rescue_available: false,
         }
     }
 }
@@ -337,8 +446,9 @@ impl InstallerStep for WelcomeStep {
 
     fn on_enter(&mut self, state: &mut GlobalState) {
         if !self.checked || self.last_language != state.language {
-            rust_i18n::set_locale(&state.language);
+            rust_i18n::set_locale(crate::funct::sanitize_locale(&state.language));
             self.checks  = run_all();
+            self.rescue_available = detect_existing_linux();
             self.checked = true;
             self.last_language = state.language.clone();
         }
@@ -347,9 +457,13 @@ impl InstallerStep for WelcomeStep {
     fn show(&mut self, ui: &mut egui::Ui, state: &mut GlobalState) {
         use crate::ui::theme;
 
+        // on_enter ile aynı koşul, aynı etki: dil değiştiyse kontrolleri ve
+        // kurtarma kullanılabilirliğini tazele. (show() içinde yalnızca bu
+        // senkron blok var; artık disk taraması yapmıyor.)
         if self.last_language != state.language {
-            rust_i18n::set_locale(&state.language);
+            rust_i18n::set_locale(crate::funct::sanitize_locale(&state.language));
             self.checks = run_all();
+            self.rescue_available = detect_existing_linux();
             self.last_language = state.language.clone();
         }
 
@@ -489,8 +603,12 @@ impl InstallerStep for WelcomeStep {
             .inner_margin(egui::Margin::symmetric(8.0, 4.0))
             .show(ui, |ui| {
                 ui.horizontal(|ui| {
-                    let rescue_available = detect_existing_linux();
-                    if rescue_available {
+                    // `detect_existing_linux()` bir `blkid -o list` süreci
+                    // başlatır — TÜM blok aygıtlarını tarar. Bunu çizim
+                    // (show) içinde çağırmak saniyede ~60 kez süreç
+                    // doğuruyor, yani kare hızında tam disk taraması.
+                    // Sonuç `on_enter`'da bir kez hesaplanıp saklanıyor.
+                    if self.rescue_available {
                         if theme::light_gray_btn(ui, &t!("rescue_button")).clicked() {
                             state.rescue_mode = true;
                         }

src/jobs/autologin.rs

@@ -4,8 +4,22 @@ use super::{Job, UiSender};
 ///
 /// Ekran yöneticisi (sddm/lightdm/gdm) yapılandırması ISO'da hazır olduğu
 /// için burada değiştirilmez; yalnızca kullanıcının seçtiği "otomatik oturum
-/// açma" bilgisi mevcut konfigürasyona eklenir. Autologin kapalıysa hiçbir
-/// şeye dokunulmaz (ISO varsayılanında otomatik giriş yoktur).
+/// açma" bilgisi mevcut konfigürasyona eklenir.
+///
+/// ## Neden `/etc/sddm.conf.d/10-yali-autologin.conf`
+///
+/// ISO canlı kullanıcı için çalışan bir autologin config'i taşıyabilir.
+/// `/usr/lib/...` altına yazılan drop-in, `/etc/...` altındaki canlı
+/// config'e öncelik olarak YENİLİR — kutu tikliyken bile canlı config
+/// kazanırdı. `/etc` altındaki kanonik dosya deterministik olarak kazanır.
+///
+/// ## Kapalıyken neden boş `User=` yazılır
+///
+/// Kutu boşken hiçbir şeye dokunulmamak, canlı ISO'nun autologin
+/// config'ini olduğu gibi kopyalamak demekti: kurulu sistem canlı
+/// kullanıcıyla (parolasız!) otomatik açılıyordu. Bu yüzden kapalı
+/// durumda da kanonik dosya yazılır ama `User=` boş bırakılır — SDDM
+/// bunu "autologin yok" sayar ve canlı config'i ezer.
 pub struct ConfigureAutologinJob {
     pub mount: String,
     pub display_manager: String,
@@ -19,63 +33,120 @@ impl Job for ConfigureAutologinJob {
     fn name(&self) -> &str { "job_autologin" }
 
     async fn run(&self, ui: &UiSender) -> Result<(), String> {
-        if !self.autologin {
-            ui.log("Otomatik oturum açma kapalı, değişiklik yapılmıyor.");
-            return Ok(());
+        // Ekran yöneticisini SEÇMEK yerine TESPİT ediyoruz.
+        //
+        // YALI kurulu sistemi squashfs'ten kopyalar; ekran yöneticisi ISO'nun
+        // kendisidir; kullanıcı seçmez. Tespit çalışma zamanında yapılır çünkü
+        // `mount` dizini rsync'ten sonra tamdır (bu iş `CopyFilesJob`'dan
+        // sonra çalışır).
+        let dm = detect_display_manager(&self.mount).await;
+        match &dm {
+            Some(found) if found != &self.display_manager => {
+                ui.log(format!(
+                    "Ekran yöneticisi tespit edildi: {} (varsayılan: {} kullanılmayacak)",
+                    found, self.display_manager
+                ));
+            }
+            Some(found) => {
+                ui.log(format!("Ekran yöneticisi: {}", found));
+            }
+            None => {
+                // Kapalıyken DM yoksa etkisizleştirilecek bir şey de yoktur.
+                if !self.autologin {
+                    ui.log("Otomatik oturum açma kapalı, değişiklik yapılmıyor.");
+                    return Ok(());
+                }
+                return Err(
+                    "Hedef sistemde sddm/lightdm/gdm bulunamadı. \
+                     Otomatik oturum açma uygulanamadı; kurulumda seçilen \
+                     oturum yöneticisini elle yapılandırın."
+                        .to_string(),
+                )
+            }
         }
 
-        ui.log(format!(
-            "Otomatik oturum açma uygulanıyor: {} ({})",
-            self.username, self.display_manager
-        ));
+        // Oturum adı HEDEFTEN tespit edilir (aşağıya bak). Eskiden sabit
+        // `plasmax11.desktop` yazılıyordu; hedefte bu dosya yoksa SDDM
+        // oturumu bulamaz ve kutu tikli olmasına rağmen login ekranına
+        // düşerdi — üstelik kutu boşken ISO'nun (doğru oturumlu) canlı
+        // config'i çalıştığı için davranış tam TERS görünüyordu.
+        let session = resolve_session(&self.mount, &self.desktop_environment).await;
+        ui.log(format!("Oturum dosyası: {}", session));
 
-        let session = match self.desktop_environment.as_str() {
-            "plasma" => "plasmax11.desktop",
-            "xfce" => "xfce.desktop",
-            "gnome" => "gnome.desktop",
-            "cinnamon" => "cinnamon.desktop",
-            "budgie" => "budgie-desktop.desktop",
-            "lxde" => "LXDE.desktop",
-            "lxqt" => "lxqt.desktop",
-            "mate" => "mate.desktop",
-            "lumina" => "lumina-desktop.desktop",
-            _ => "plasmax11.desktop",
-        };
-
-        match self.display_manager.as_str() {
-            "sddm" => {
-                // ISO'nun /usr/lib/sddm/sddm.conf.d içeriğine dokunmadan
-                // ayrı bir drop-in dosyası ile autologin eklenir.
-                let dir = format!("{}/usr/lib/sddm/sddm.conf.d", self.mount);
-                tokio::fs::create_dir_all(&dir).await
-                    .map_err(|e| format!("sddm.conf.d oluşturulamadı: {}", e))?;
+        match dm.as_deref() {
+            Some("sddm") => {
+                let conf = format!("{}/etc/sddm.conf.d/10-yali-autologin.conf", self.mount);
+                if !self.autologin {
+                    // Canlı config'i ezen, autologin'i kapatan kanonik dosya.
+                    // ISO dosyaları SİLİNMEZ, yalnızca öncelikle ezilir.
+                    let content = "# Yali: otomatik oturum açma kapalı (canlı config'i ezer)\n\
+                                   [Autologin]\nUser=\nSession=\n";
+                    if let Some(parent) = std::path::Path::new(&conf).parent() {
+                        let _ = tokio::fs::create_dir_all(parent).await;
+                    }
+                    tokio::fs::write(&conf, content)
+                        .await
+                        .map_err(|e| format!("{} yazılamadı: {}", conf, e))?;
+                    ui.log("Otomatik oturum açma kapalı, canlı config etkisizleştirildi.");
+                    return Ok(());
+                }
+                ui.log(format!(
+                    "Otomatik oturum açma uygulanıyor: {} ({})",
+                    self.username, self.username
+                ));
+                if let Some(parent) = std::path::Path::new(&conf).parent() {
+                    tokio::fs::create_dir_all(parent).await
+                        .map_err(|e| format!("{} oluşturulamadı: {}", parent.display(), e))?;
+                }
                 let content = format!(
-                    "[Autologin]\nUser={}\nSession={}\n",
+                    "# Yali tarafından oluşturuldu\n[Autologin]\nUser={}\nSession={}\n",
                     self.username, session
                 );
-                tokio::fs::write(format!("{}/autologin.conf", dir), content)
+                tokio::fs::write(&conf, content)
                     .await
-                    .map_err(|e| format!("autologin.conf yazılamadı: {}", e))?;
+                    .map_err(|e| format!("{} yazılamadı: {}", conf, e))?;
             }
-            "lightdm" => {
+            Some("lightdm") => {
                 let dir = format!("{}/etc/lightdm", self.mount);
                 let _ = tokio::fs::create_dir_all(&dir).await;
                 let conf = format!("{}/lightdm.conf", dir);
                 let mut content = tokio::fs::read_to_string(&conf)
                     .await
                     .unwrap_or_default();
-                if !content.contains("[Seat:*]") {
-                    content.push_str("[Seat:*]\n");
+                // Önce bayat autologin satırlarını temizle (canlı config
+                // kalıntısı da, kendi önceki yazımımız da).
+                content = content
+                    .lines()
+                    .filter(|l| {
+                        let t = l.trim_start();
+                        !(t.starts_with("autologin-user=")
+                            || t.starts_with("autologin-session="))
+                    })
+                    .collect::<Vec<_>>()
+                    .join("\n");
+                if !content.ends_with('\n') {
+                    content.push('\n');
                 }
-                if !content.contains("autologin-user=") {
+                if self.autologin {
+                    if !content.contains("[Seat:*]") {
+                        content.push_str("[Seat:*]\n");
+                    }
+                    // lightdm oturumu .desktop dosyası adı olarak bekler.
                     content.push_str(&format!("autologin-user={}\n", self.username));
-                    content.push_str(&format!("autologin-session={}\n", self.desktop_environment));
+                    content.push_str(&format!("autologin-session={}\n", session));
+                    ui.log(format!("Otomatik oturum açma uygulanıyor: {}", self.username));
+                } else {
+                    ui.log("Otomatik oturum açma kapalı, canlı config etkisizleştirildi.");
                 }
                 tokio::fs::write(&conf, content)
                     .await
                     .map_err(|e| format!("lightdm.conf yazılamadı: {}", e))?;
             }
-            "gdm" => {
+            Some("gdm") => {
+                if !self.autologin {
+                    ui.log("Otomatik oturum açma kapalı, değişiklik yapılmıyor.");
+                    return Ok(());
+                }
                 let dir = format!("{}/etc/gdm", self.mount);
                 let _ = tokio::fs::create_dir_all(&dir).await;
                 let conf = format!("{}/custom.conf", dir);
@@ -87,10 +158,11 @@ impl Job for ConfigureAutologinJob {
                     .await
                     .map_err(|e| format!("gdm/custom.conf yazılamadı: {}", e))?;
             }
-            _ => {
-                ui.log(format!(
-                    "⚠ Bilinmeyen ekran yöneticisi: {} — autologin uygulanmadı",
-                    self.display_manager
+            other => {
+                return Err(format!(
+                    "Desteklenmeyen ekran yöneticisi tespit edildi: {} — \
+                     otomatik oturum açma uygulanmadı",
+                    other.unwrap_or("bilinmiyor")
                 ));
             }
         }
@@ -99,3 +171,181 @@ impl Job for ConfigureAutologinJob {
         Ok(())
     }
 }
+
+/// Masaüstü ortamı adını, oturum yöneticilerinin beklediği `.desktop`
+/// dosyası adına eşler.
+///
+/// lightdm, sddm ve gdm oturumu `plasmax11.desktop` gibi bir dosya adıyla
+/// arar; ham DE adıyla ("plasma") yazmak oturumu bulamaz.
+fn session_desktop_file(de: &str) -> &'static str {
+    match de {
+        "plasma"   => "plasmax11.desktop",
+        "xfce"     => "xfce.desktop",
+        "gnome"    => "gnome.desktop",
+        "cinnamon" => "cinnamon.desktop",
+        "budgie"   => "budgie-desktop.desktop",
+        "lxde"     => "LXDE.desktop",
+        "lxqt"     => "lxqt.desktop",
+        "mate"     => "mate.desktop",
+        "lumina"   => "lumina-desktop.desktop",
+        // Bilinmeyen DE'de plasma varsayılır. Önemli olan, ham adı
+        // yazıp oturumu bulamamaktır.
+        _          => "plasmax11.desktop",
+    }
+}
+
+/// Hedef sistemde GERÇEKTEN var olan oturum dosyasını seçer (saf).
+///
+/// `wayland` ve `x11`, hedefteki `/usr/share/wayland-sessions` ve
+/// `/usr/share/xsessions` içerik listesidir. Önce DE anahtarını içeren
+/// dosya aranır (wayland öncelikli — ISO varsayılanı genelde odur),
+/// bulunamazsa alfabetik ilk dosya, liste boşsa sabit eşleme döner.
+///
+/// Sabit eşleme tek başına YETERSİZDİR: hedefte `plasmax11.desktop`
+/// yoksa (yalnızca wayland kurulu ISO) SDDM oturumu bulamaz ve kutu
+/// tikli olmasına rağmen login ekranına düşer.
+fn pick_session_file(de: &str, wayland: &[String], x11: &[String]) -> String {
+    let key = match de {
+        "plasma" => "plasma",
+        "xfce" => "xfce",
+        "gnome" => "gnome",
+        "cinnamon" => "cinnamon",
+        "budgie" => "budgie",
+        "lxde" => "lxde",
+        "lxqt" => "lxqt",
+        "mate" => "mate",
+        "lumina" => "lumina",
+        _ => "plasma",
+    };
+    for list in [wayland, x11] {
+        let mut sorted = list.to_vec();
+        sorted.sort();
+        for f in &sorted {
+            if f.to_lowercase().contains(key) {
+                return f.clone();
+            }
+        }
+    }
+    let mut all: Vec<&String> = wayland.iter().chain(x11.iter()).collect();
+    all.sort();
+    if let Some(f) = all.first() {
+        return (*f).clone();
+    }
+    session_desktop_file(de).to_string()
+}
+
+/// Hedef `mount` altındaki oturum dizinlerini okuyup dosya adı seçer.
+async fn resolve_session(mount: &str, de: &str) -> String {
+    async fn list(mount: &str, sub: &str) -> Vec<String> {
+        let mut out = Vec::new();
+        let mut rd = match tokio::fs::read_dir(format!("{}/usr/share/{}", mount, sub)).await {
+            Ok(rd) => rd,
+            Err(_) => return out,
+        };
+        while let Ok(Some(e)) = rd.next_entry().await {
+            let name = e.file_name().to_string_lossy().to_string();
+            if name.ends_with(".desktop") {
+                out.push(name);
+            }
+        }
+        out
+    }
+    let wayland = list(mount, "wayland-sessions").await;
+    let x11 = list(mount, "xsessions").await;
+    pick_session_file(de, &wayland, &x11)
+}
+
+/// Hedef sistemde hangi ekran yöneticisinin KURULU olduğunu tespit eder.
+///
+/// YALI squashfs'ten kopyaladığı için ekran yöneticisi ISO'nun kendisidir;
+/// kullanıcı seçmez. Tespit çalışma zamanında yapılır çünkü `mount`
+/// dizini rsync'ten sonra tamdır (bu iş `CopyFilesJob`'dan sonra çalışır).
+///
+/// İki kaynak kontrol edilir: çalıştırılabilir (`/usr/bin/sddm`) ve
+/// yapılandırma dosyası. Çoğu dağıtımda ikisi de vardır ama paket
+/// yöneticisine göre değişebilir.
+async fn detect_display_manager(mount: &str) -> Option<String> {
+    for (bin, name) in [
+        ("sddm", "sddm"),
+        ("lightdm", "lightdm"),
+        ("gdm", "gdm"),
+    ] {
+        let exe = format!("{}/usr/bin/{}", mount, bin);
+        if std::path::Path::new(&exe).exists() {
+            return Some(name.to_string());
+        }
+    }
+    // Yedek: yapılandırma dizini
+    for (dir, name) in [
+        ("etc/sddm.conf.d", "sddm"),
+        ("usr/lib/sddm", "sddm"),
+        ("etc/lightdm", "lightdm"),
+        ("etc/gdm", "gdm"),
+    ] {
+        if std::path::Path::new(&format!("{}/{}", mount, dir)).is_dir() {
+            return Some(name.to_string());
+        }
+    }
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_de_maps_to_a_desktop_file() {
+        // lightdm/sddm/gdm oturumu .desktop dosyası arar; ham ad
+        // yazılırsa oturum açılmaz.
+        for de in [
+            "plasma", "xfce", "gnome", "cinnamon", "budgie",
+            "lxde", "lxqt", "mate", "lumina",
+        ] {
+            let f = session_desktop_file(de);
+            assert!(f.ends_with(".desktop"), "{} → {} uzantısız", de, f);
+        }
+    }
+
+    #[test]
+    fn unknown_de_falls_back_to_a_valid_desktop_file() {
+        for de in ["", "kde5", "deepin", "TOTALLY-UNKNOWN"] {
+            assert!(
+                session_desktop_file(de).ends_with(".desktop"),
+                "{} geçersiz dosya adı veriyor", de
+            );
+        }
+    }
+
+    fn s(v: &[&str]) -> Vec<String> {
+        v.iter().map(|x| x.to_string()).collect()
+    }
+
+    #[test]
+    fn picker_prefers_real_wayland_session() {
+        // Yalnızca wayland kurulu ISO: sabit `plasmax11.desktop` yok.
+        // Eskiden bu dosya adı körü körüne yazılıyor, SDDM oturumu
+        // bulamayıp login ekranına düşüyordu.
+        let got = pick_session_file("plasma", &s(&["plasma.desktop"]), &s(&[]));
+        assert_eq!(got, "plasma.desktop");
+    }
+
+    #[test]
+    fn picker_matches_de_key_case_insensitively() {
+        let got = pick_session_file(
+            "xfce",
+            &s(&[]),
+            &s(&["xfce.desktop", "plasma.desktop"]),
+        );
+        assert_eq!(got, "xfce.desktop");
+    }
+
+    #[test]
+    fn picker_falls_back_to_first_file_then_static_map() {
+        // DE'ye uyan yoksa alfabetik ilk dosya.
+        let got = pick_session_file("mate", &s(&[]), &s(&["zebra.desktop", "aaa.desktop"]));
+        assert_eq!(got, "aaa.desktop");
+        // Hiç dosya yoksa sabit eşleme (son çare).
+        let got = pick_session_file("plasma", &[], &[]);
+        assert_eq!(got, "plasmax11.desktop");
+    }
+}

src/jobs/bootloader.rs

@@ -1,6 +1,82 @@
 use std::sync::atomic::Ordering;
 use super::{blkid_uuid, DEMO_MODE, get_fs_type, is_mount_point, part_path, run_cmd, run_chroot, Job, UiSender};
 
+/// Kök bölümün LUKS mapper adı. `PartitionJob`, `MountPartitionsJob`,
+/// `GenerateFstabJob` ve `InstallGrubJob` aynı adı kullanır; tek
+/// kaynaktan okunsun diye burada tanımlı.
+pub const CRYPTROOT_NAME: &str = "cryptroot";
+
+/// Açık bir LUKS mapper'ının arkasındaki GERÇEK aygıtı döndürür
+/// (`/dev/sda3` gibi).
+///
+/// Neden gerekli: `blkid /dev/mapper/cryptroot` dosya sisteminin UUID'sini
+/// verir, LUKS başlık UUID'sini değil. Kernel'e `rd.luks.uuid=` ile
+/// verilmesi gereken değer LUKS başlığınkidir; bu yüzden önce mapper'ın
+/// altındaki bölüme inmek gerekir. `cryptsetup status` tam olarak bu
+/// bilgiyi verir ve çalışma zamanında doğrudur — bölüm numarası
+/// tahmin etmeye gerek kalmaz (manuel modda numaralar `is_uefi`'ye göre
+/// değil `assign_partition_numbers`'a göre belirlenir).
+async fn luks_backing_device(name: &str) -> Result<String, String> {
+    if DEMO_MODE.load(Ordering::Relaxed) {
+        return Ok("/dev/demo-luks".to_string());
+    }
+
+    let out = tokio::process::Command::new("cryptsetup")
+        .args(["status", name])
+        .output()
+        .await
+        .map_err(|e| format!("cryptsetup status {} çalıştırılamadı: {}", name, e))?;
+
+    // `cryptsetup status` stdout'a:
+    //   /dev/mapper/cryptroot is active and is in use.
+    //     type:    LUKS2
+    //     device:  /dev/sda3
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let device = stdout
+        .lines()
+        .find_map(|l| l.trim().strip_prefix("device:"))
+        .map(|d| d.trim().to_string())
+        .filter(|d| !d.is_empty());
+
+    device.ok_or_else(|| {
+        format!(
+            "{} mapper'ının altındaki aygıt çözümlenemedi. \
+             LUKS başlığı açılmamış olabilir; fstab/crypttab kontrol edin.",
+            name
+        )
+    })
+}
+
+/// Bir bağlama noktasının arkasındaki GERÇEK aygıtı döndürür.
+///
+/// Kurulum kökü `mount` noktasına bağlandıktan sonra çağrılır; `findmnt`
+/// doğrudan cevabı verir. Böylece kök bölümünün numarası veya diski
+/// tahmin edilmez — manuel modda numaralar `assign_partition_numbers`'tan
+/// gelir ve kök farklı bir diskte olabilir.
+async fn mounted_root_device(mount: &str) -> Result<String, String> {
+    let out = tokio::process::Command::new("findmnt")
+        .args(["-n", "-o", "SOURCE", "--target", mount])
+        .output()
+        .await
+        .map_err(|e| format!("findmnt çalıştırılamadı: {}", e))?;
+
+    let dev = String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .next()
+        .unwrap_or("")
+        .trim()
+        .to_string();
+
+    // findmnt bazen /dev/... yerine /dev/mapper/... ya da kökü verir.
+    if dev.is_empty() || dev == "none" {
+        return Err(format!(
+            "{} bağlama noktasının arkasındaki aygıt çözümlenemedi; \
+             kök bölümü bağlanmamış olabilir", mount
+        ));
+    }
+    Ok(dev)
+}
+
 /// initramfs yeniler (GRUB öncesi zorunlu).
 /// PisiLinux `dracut` kullanıyorsa `dracut -f --regenerate-all`,
 /// mkinitcpio kullanıyorsa `mkinitcpio -P`.
@@ -180,11 +256,35 @@ impl Job for InstallGrubJob {
         // kernel cmdline
         let mut cmdline = self.kernel_options.clone();
         if self.encrypt_root {
-            // Kök bölüm UUID'sini blkid'den al (LUKS başlık UUID'si)
-            let (root_num, _swap_num): (u32, u32) = if self.is_uefi { (3, 2) } else { (2, 1) };
-            let root_part = part_path(&self.disk, root_num);
-            let root_uuid = blkid_uuid(&root_part).await.unwrap_or_default();
-            let crypt_arg = format!("cryptdevice=UUID={}:cryptroot root=/dev/mapper/cryptroot", root_uuid);
+            // LUKS başlık UUID'si GEREKLİ. Önceden bölüm numarası tahmin
+            // ediliyordu (UEFI'de 3, BIOS'ta 2) — bu manuel modda YANLIŞTIR
+            // (numaralar assign_partition_numbers'tan gelir) ve üstelik
+            // "cryptdevice=UUID=x:cryptroot" geçerli bir söz dizimi değildir.
+            //
+            // Bunun yerine çalışma zamanında gerçeği soruyoruz:
+            // `cryptsetup status` LUKS başlığının bulunduğu aygıtı verir,
+            // blkid ise o aygıtın LUKS UUID'sini (crypto_LUKS).
+            // /dev/mapper/cryptroot'un UUID'si değil — mapper'ın arkasındaki
+            // bölümünki kullanılır.
+            let luks_part = luks_backing_device(CRYPTROOT_NAME).await?;
+            let luks_uuid = blkid_uuid(&luks_part).await
+                .map_err(|e| format!("{} LUKS UUID okunamadı: {}", luks_part, e))?;
+            if luks_uuid.trim().is_empty() {
+                return Err(format!("{} için LUKS UUID boş geldi", luks_part));
+            }
+
+            ui.log(format!("LUKS: {} → {}", luks_part, luks_uuid));
+
+            // dracut sözdizimi: rd.luks.uuid=luks-<uuid>
+            // mkinitcpio sözdizimi: cryptdevice=UUID=<uuid>:<mapper>
+            // PisiLinux hangisini kullandığı belli olmadığı için ikisi de
+            // yazılır; iki araç da diğerinin anahtarını yok sayar.
+            let crypt_arg = format!(
+                "rd.luks.uuid=luks-{uuid} rd.luks.name={uuid}={name} \
+                 root=/dev/mapper/{name} cryptdevice=UUID={uuid}:{name}",
+                uuid = luks_uuid,
+                name = CRYPTROOT_NAME,
+            );
             if cmdline.is_empty() {
                 cmdline = crypt_arg;
             } else {
@@ -428,10 +528,18 @@ async fn generate_minimal_grub_cfg(
     tokio::fs::create_dir_all(&grub_dir).await
         .map_err(|e| format!("{} oluşturulamadı: {}", grub_dir, e))?;
 
-    let (root_num, _swap_num) = if is_uefi { (3u32, 2u32) } else { (2u32, 1u32) };
-    let root_part = part_path(disk, root_num);
-    let root_uuid = blkid_uuid(&root_part).await
-        .map_err(|e| format!("Kök UUID okunamadı: {}", e))?;
+    // Kök aygıtı TAHMİN EDİLMEZ.
+    //
+    // Daha önce `is_uefi` ile (3 | 2) deniyor ve `disk` (seçili disk)
+    // üzerinden okunuyordu. Bu manuel modda iki yönden yanlıştır:
+    //   1) numaralar assign_partition_numbers'tan gelir, (3|2) değil
+    //   2) kök farklı bir diskteyse (çoklu disk kurulumu) `disk` üstünde
+    //      hiç kök yoktur
+    // Kurulum kökü `mount` noktasına BAĞLANDIĞI için gerçek aygıt
+    // findmnt'den sorulur — hem otomatik hem manuel modda doğru.
+    let root_device = mounted_root_device(mount).await?;
+    let root_uuid = blkid_uuid(&root_device).await
+        .map_err(|e| format!("Kök UUID okunamadı ({}): {}", root_device, e))?;
 
     let mut kernel_file: Option<String> = None;
     let mut initrd_files: Vec<String> = Vec::new();
@@ -482,8 +590,14 @@ async fn generate_minimal_grub_cfg(
         cfg.push_str(&format!("    search --no-floppy --fs-uuid --set=root {}\n", root_uuid));
         cfg.push_str(&format!("    linux /boot/{} root=UUID={} rw quiet", kernel, root_uuid));
     } else {
+        // BIOS'ta `set root=(hdX,msdosY)` gerekir. hd0 ve msdos2
+        // SABİT YAZILIYORDU; kök başka bir diskte/bölümdeyse yanlış
+        // bölüm boot edilirdi. numara artık gerçek kök aygıtından gelir
+        // (BIOS sıralaması için bkz. cihaz.map notu aşağıda).
+        let msdos = crate::installer::part_number(&root_device).unwrap_or(2);
         cfg.push_str("menuentry \"PisiLinux\" {\n");
-        cfg.push_str("    insmod ext2\n    set root=(hd0,msdos2)\n");
+        cfg.push_str("    insmod ext2\n");
+        cfg.push_str(&format!("    set root=(hd0,msdos{})\n", msdos));
         cfg.push_str(&format!("    linux /boot/{} root=UUID={} rw quiet", kernel, root_uuid));
     }
 

src/jobs/cleanup.rs

@@ -0,0 +1,201 @@
+//! Kurulum bir hata ile durduğunda veya bittiğinde çalışan temizlik işleri.
+//!
+//! Bu modülün varlık nedeni: `JobQueue::run_all` eskiden ilk hatada
+//! `return` ediyordu. O an hedef bölümler bağlıydı, LUKS mapper'ları
+//! açıktı ve swap aktifti — kullanıcı yeniden başlatmaya çalışırsa
+//! sistem onu reddediyor, elle de düzeltmesi dakikalar sürüyordu.
+//!
+//! Temizlik işleri `JobQueue::with_cleanup(...)` ile verilir ve başarı
+//! durumunda da, hata durumunda da çalışır.
+
+use super::execution::umount_clean;
+use super::{mounted_paths_under, Job, UiSender, DEMO_MODE};
+use std::sync::atomic::Ordering;
+
+/// Kurulum bitince veya hata ile durunca hedef sistemin bağlamalarını
+/// tamamen çözer: tüm mount'lar, LUKS mapper'ları, LVM birimleri ve swap.
+///
+/// Sıralama önemlidir — en derinden yüzeye:
+///   1. `mount` altındaki tüm dosya sistemleri
+///   2. LVM mantıksal birimleri (`lvchange -an`)
+///   3. LUKS mapper'ları (`cryptsetup close`)
+///   4. Hedef diskin swap bölümü (`swapoff`)
+///
+/// Swap en sonda: swap'a yazmış bir süreç varsa erken swapoff denemesi
+/// "device is busy" verir.
+pub struct EmergencyCleanupJob {
+    pub mount: String,
+    /// Hedef diskin bölüm yolları (swapoff için). Boşsa otomatik bulunur.
+    pub partitions: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl Job for EmergencyCleanupJob {
+    fn name(&self) -> &str { "job_cleanup_emergency" }
+
+    async fn run(&self, ui: &UiSender) -> Result<(), String> {
+        if DEMO_MODE.load(Ordering::Relaxed) {
+            return Ok(());
+        }
+
+        let mut errors: Vec<String> = Vec::new();
+
+        // ── 1. Dosya sistemleri ────────────────────────────────
+        let targets = mounted_paths_under(&self.mount);
+        if targets.is_empty() {
+            ui.log("Bağlı dosya sistemi yok");
+        }
+        for target in &targets {
+            if !umount_clean(target, ui).await {
+                errors.push(format!("{} bağlı kaldı", target));
+            }
+        }
+
+        // ── 2. LVM mantıksal birimleri ────────────────────────
+        // Etkin VG'lerin tüm LV'leri kapatılır. `vgs --noheadings` boş
+        // dönerse sistemde LVM yok demektir, hata değil.
+        if let Err(e) = deactivate_lvm(ui).await {
+            errors.push(e);
+        }
+
+        // ── 3. LUKS mapper'ları ───────────────────────────────
+        // `lsblk` TYPE=crypt listesi. Hedef diskin LUKS bölümü hangisi
+        // ise onu kapatır; canlı ortamın kendi LUKS'u varsa dokunmaz.
+        match close_crypt_mappers(&self.partitions).await {
+            Ok(closed) => {
+                for name in closed {
+                    ui.log(format!("LUKS kapatıldı: {}", name));
+                }
+            }
+            Err(e) => errors.push(e),
+        }
+
+        // ── 4. Swap ───────────────────────────────────────────
+        for part in &self.partitions {
+            if let Err(e) = swapoff_part(part, ui).await {
+                errors.push(e);
+            }
+        }
+
+        if errors.is_empty() {
+            Ok(())
+        } else {
+            Err(errors.join("\n"))
+        }
+    }
+}
+
+/// Etkin tüm LVM VG'lerini deaktive eder.
+async fn deactivate_lvm(ui: &UiSender) -> Result<(), String> {
+    let out = tokio::process::Command::new("vgs")
+        .args(["--noheadings", "-o", "vg_name"])
+        .output()
+        .await
+        .map_err(|e| format!("vgs çalıştırılamadı: {}", e))?;
+
+    let vgs: Vec<String> = String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .map(|l| l.trim().to_string())
+        .filter(|l| !l.is_empty())
+        .collect();
+
+    if vgs.is_empty() {
+        return Ok(());
+    }
+
+    let mut failed = Vec::new();
+    for vg in vgs {
+        ui.log(format!("LVM deaktive ediliyor: {}", vg));
+        match super::run_cmd("vgchange", &["-an", &vg]).await {
+            Ok(()) => {}
+            Err(e) => failed.push(format!("{} ({})", vg, e)),
+        }
+    }
+
+    if failed.is_empty() {
+        Ok(())
+    } else {
+        Err(format!("LVM deaktive edilemedi: {}", failed.join(", ")))
+    }
+}
+
+/// Açık LUKS mapper'larını kapatır.
+///
+/// `partitions` verilmişse yalnızca o bölümlerin mapper'ları kapatılır
+/// (hedef diske ait olanlar). `cryptsetup luksUUID <dev>` ile eşleştirme
+/// yapılır. Liste boşsa hiçbir şeye dokunulmaz — canlı ortamın kendi
+/// şifreli bölümlerini kapatmak kullanıcının verisini riske atar.
+async fn close_crypt_mappers(partitions: &[String]) -> Result<Vec<String>, String> {
+    if partitions.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let mappers = super::open_crypt_mappers();
+    if mappers.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let mut closed = Vec::new();
+    for name in mappers {
+        // Bu mapper hangi bölümün arkasında?
+        let backing = backing_device(&name).await;
+        let belongs = backing
+            .as_deref()
+            .map(|d| partitions.iter().any(|p| p == d))
+            .unwrap_or(false);
+
+        if !belongs {
+            continue;
+        }
+
+        match super::run_cmd("cryptsetup", &["close", &name]).await {
+            Ok(()) => closed.push(name),
+            Err(e) => {
+                return Err(format!(
+                    "cryptsetup close {} başarısız: {}. \
+                     Hedef bölüm hâlâ kullanımda olabilir.",
+                    name, e
+                ))
+            }
+        }
+    }
+
+    Ok(closed)
+}
+
+/// Bir LUKS mapper'ının arkasındaki gerçek aygıtı döndürür.
+async fn backing_device(mapper: &str) -> Option<String> {
+    let out = tokio::process::Command::new("cryptsetup")
+        .args(["status", mapper])
+        .output()
+        .await
+        .ok()?;
+    String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .find_map(|l| l.trim().strip_prefix("device:"))
+        .map(|d| d.trim().to_string())
+        .filter(|d| !d.is_empty())
+}
+
+/// Verilen bölüm swap ise `swapoff` çalıştırır. Swap değilse sessizce geçer.
+async fn swapoff_part(part: &str, ui: &UiSender) -> Result<(), String> {
+    let out = tokio::process::Command::new("swapon")
+        .args(["--show", "--noheadings", "-o", "NAME"])
+        .output()
+        .await
+        .map_err(|e| format!("swapon sorgusu başarısız: {}", e))?;
+
+    let active: Vec<String> = String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .map(|l| l.trim().to_string())
+        .filter(|l| !l.is_empty())
+        .collect();
+
+    if !active.iter().any(|s| s == part) {
+        return Ok(());
+    }
+
+    ui.log(format!("swapoff {}", part));
+    super::run_cmd("swapoff", &[part]).await
+        .map_err(|e| format!("swapoff {} başarısız: {} (bu bölümü kullanan süreçleri kapatın)", part, e))
+}

src/jobs/execution.rs

@@ -326,33 +326,29 @@ pub struct UnmountBindJob {
 impl Job for UnmountBindJob {
     fn name(&self) -> &str { "job_umount_bind" }
 
+    /// `mount` altındaki TÜM bağlı dosya sistemlerini en derinden yüzeye
+    /// doğru çözer.
+    ///
+    /// Önceden elle yazılmış sabit bir liste vardı (`proc`, `sys`, `dev`,
+    /// `boot/efi`, ...). Bu liste yalnızca otomatik modda doğruydu:
+    /// manuel bölümlemede `/home`, `/var`, `/boot` gibi ek bölümler
+    /// kurulum bitince bağlı kalıyordu. Artık düzen bilinmiyor —
+    /// `/proc/self/mountinfo` okunup `mount/` altındaki her şey bulunuyor.
     async fn run(&self, ui: &UiSender) -> Result<(), String> {
         let mt = &self.mount;
-        // Ters sırada umount — en derin path önce
-        let subdirs = [
-            "sys/firmware/efi/efivars",
-            "dev/pts",
-            "dev",
-            "run",
-            "sys",
-            "proc",
-            "boot/efi",
-        ];
         let mut errors: Vec<String> = Vec::new();
 
-        // Bind-mount'lar + ESP (/boot/efi)
-        for subdir in &subdirs {
-            let target = format!("{}/{}", mt, subdir);
-            if !umount_clean(&target, ui).await {
-                let msg = format!("{} temiz unmount edilemedi", target);
-                errors.push(msg);
-            }
+        let mut targets = super::mounted_paths_under(mt);
+
+        if targets.is_empty() {
+            ui.log("Çözülecek bağlama noktası yok (zaten temiz)");
+            targets.push(mt.clone());
         }
 
-        // Kök bölüm: chroot mount'unun kendisi
-        if !umount_clean(mt, ui).await {
-            let msg = format!("{} (kök) temiz unmount edilemedi", mt);
-            errors.push(msg);
+        for target in &targets {
+            if !umount_clean(target, ui).await {
+                errors.push(format!("{} temiz unmount edilemedi", target));
+            }
         }
 
         if !errors.is_empty() {
@@ -368,7 +364,7 @@ impl Job for UnmountBindJob {
 /// Tek bir mount noktasını önce temiz `umount` ile, başarısızsa `umount -lf`
 /// (lazy) ile çözer. "not mounted" / "no such file" gibi beklenen durumlar
 /// kritik sayılmaz; yalnızca komut çalıştırılamaması gerçek hatadır.
-async fn umount_clean(target: &str, ui: &UiSender) -> bool {
+pub(crate) async fn umount_clean(target: &str, ui: &UiSender) -> bool {
     ui.log(format!("umount {}", target));
     match tokio::process::Command::new("umount")
         .arg(target).status().await

src/jobs/finish.rs

@@ -1,8 +1,9 @@
 use super::{run_chroot, Job, UiSender};
 
-/// COMAR servislerini ve tetikleyicilerini yapılandırır.
+/// `pisi configure-pending` (kısaltması `pisi cp`): kurulan paketlerin
+/// post-install betiklerini çalıştırır. Bu adım olmadan kurulu sistemde
+/// servisler/tetikleyiciler kurulmamış olur ve sistem düzgün açılmaz.
 pub struct RunComarJob {
-    #[allow(dead_code)]
     pub mount: String,
 }
 
@@ -11,27 +12,32 @@ impl Job for RunComarJob {
     fn name(&self) -> &str { "job_comar" }
 
     async fn run(&self, ui: &UiSender) -> Result<(), String> {
-        // pisi configure-pending: paket post-install scriptlerini çalıştırır.
-        // Yapılandırılacak paket yoksa çıkış kodu sıfır dışı olabilir — fatal değil.
-        // pisi cp işlemi kurulum sonrası atlanıyor (kullanıcı isteği).
-        let _ = ui;
-        // ui.log("pisi paketleri yapılandırılıyor (COMAR)…");
-        // match run_chroot(&self.mount, &["pisi", "cp"]).await {
-        //     Ok(_) => {
-        //         ui.log("✓ pisi paketleri yapılandırıldı");
-        //     }
-        //     Err(e) => {
-        //         // "no packages to configure" gibi durumlar hata değil
-        //         if e.contains("no packages") || e.contains("Nothing to do") {
-        //             ui.log(" pisi: yapılandırılacak paket yok, atlanıyor");
-        //         } else {
-        //             // Gerçek hata — uyar ama kurulumu durdurma
-        //             ui.log(format!("pisi paketleri yapılandırma uyarısı: {}", e));
-        //             ui.log("Bu uyarı kritik değilse kurulum devam edecek.");
-        //         }
-        //     }
-        // }
-        Ok(())
+        ui.log("pisi paketleri yapılandırılıyor (configure-pending)…");
+        match run_chroot(&self.mount, &["pisi", "cp"]).await {
+            Ok(_) => {
+                ui.log("✓ pisi paketleri yapılandırıldı");
+                Ok(())
+            }
+            Err(e) => {
+                // "Yapılandırılacak paket yok" bir hata değil; yeni kurulumda
+                // (ör. yalnızca temel sistem) normal olarak oluşabilir.
+                let benign = ["no packages to configure", "nothing to do",
+                              "yapılandırılacak paket", "nothing to configure"];
+                if benign.iter().any(|m| e.to_lowercase().contains(m)) {
+                    ui.log(" pisi: yapılandırılacak paket yok, atlanıyor");
+                    Ok(())
+                } else {
+                    // Post-install betikleri çalışmadı: bu, kurulumun
+                    // sessizce bozuk bırakılması anlamına gelir. Kurulumu
+                    // durdurup hatayı kullanıcıya göster.
+                    Err(format!(
+                        "pisi configure-pending başarısız: {}\n\
+                         Paketlerin kurulum betikleri çalışmadı; sistem \
+                         düzgün başlamayabilir.", e
+                    ))
+                }
+            }
+        }
     }
 }
 
@@ -46,15 +52,19 @@ impl Job for RunLdconfigJob {
 
     async fn run(&self, ui: &UiSender) -> Result<(), String> {
         ui.log("ldconfig çalıştırılıyor…");
-        match run_chroot(&self.mount, &["ldconfig"]).await {
-            Ok(_) => ui.log("✓ ldconfig tamamlandı"),
-            Err(e) => ui.log(format!("⚠ ldconfig uyarısı: {}", e)),
-        }
+        run_chroot(&self.mount, &["ldconfig"]).await
+            .map_err(|e| format!("ldconfig başarısız: {}\n\
+                                 Paylaşımlı kütüphane önbelleği oluşturulamadı.", e))?;
+        ui.log("✓ ldconfig tamamlandı");
         Ok(())
     }
 }
 
 /// update-environment: PisiLinux init/betiklerini yeniden yapılandırır.
+///
+/// Bu adım init sistemi için kritiktir (udev kuralları, servisler,
+/// /etc/localtime senkronizasyonu). Sessizce yutulursa kurulum "başarılı"
+/// görünür ama sistem açılmaz — bu yüzden hata fatal.
 pub struct UpdateEnvironmentJob {
     pub mount: String,
 }
@@ -65,10 +75,11 @@ impl Job for UpdateEnvironmentJob {
 
     async fn run(&self, ui: &UiSender) -> Result<(), String> {
         ui.log("update-environment çalıştırılıyor…");
-        match run_chroot(&self.mount, &["update-environment"]).await {
-            Ok(_) => ui.log("✓ update-environment tamamlandı"),
-            Err(e) => ui.log(format!("⚠ update-environment uyarısı: {}", e)),
-        }
+        run_chroot(&self.mount, &["update-environment"]).await
+            .map_err(|e| format!("update-environment başarısız: {}\n\
+                                 Init betikleri yapılandırılmadı; kurulu sistem \
+                                 düzgün başlamayabilir.", e))?;
+        ui.log("✓ update-environment tamamlandı");
         Ok(())
     }
 }
@@ -86,29 +97,41 @@ impl Job for CleanupLiveJob {
         let mt = &self.mount;
         ui.log("Live ortam izleri temizleniyor…");
 
-        // run/livemedia
+        // Canlı ortamdan kalan dizinler: yoksa hata değil, `let _ =` uygun.
         let _ = tokio::fs::remove_dir_all(format!("{}/run/livemedia", mt)).await;
-        // var/cache/pisi/packages
         let _ = tokio::fs::remove_dir_all(format!("{}/var/cache/pisi/packages", mt)).await;
+        let _ = tokio::fs::remove_dir_all(format!("{}/bootmnt", mt)).await;
         // YALI desktop dosyaları
         //let _ = tokio::fs::remove_file(format!("{}/usr/share/applications/yali.desktop", mt)).await;
         //let _ = tokio::fs::remove_file(format!("{}/usr/share/applications/yali-bin.desktop", mt)).await;
-        let _ = tokio::fs::remove_dir_all(format!("{}/bootmnt", mt)).await;
-        //pisi kullanıcısını sil (ev diziniyle birlikte), YALI paketlerini kaldır
         let _ = run_chroot(&self.mount, &["userdel", "-r", "pisi"]).await;
         let _ = run_chroot(&self.mount, &["pisi", "rm", "yali-rs"]).await;
-        // live paket deposunu kaldır
         let _ = run_chroot(&self.mount, &["pisi", "rr", "live"]).await;
-        // depolarları yeniden ekle (stable2 + contrib)
-        ui.log("Depolar Ekleniyor…");
-        let _ = run_chroot(&self.mount, &["pisi", "ar", "stable2", "https://stable2.pisilinux.org/pisi-index.xml.xz"]).await;
-        let _ = run_chroot(&self.mount, &["pisi", "ar", "contrib", "https://contrib.pisilinux.org/pisi-index.xml.xz"]).await;
-        // depoları aktif et
-        ui.log("Depolar aktif ediliyor...");
-        let _ = run_chroot(&self.mount, &["pisi", "er", "contrib", "stable2"]).await;
-        // paket listelerini güncelle
-        ui.log("Depolar Güncelleniyor...");
-        let _ = run_chroot(&self.mount, &["pisi", "ur"]).await;
+
+        // ── Aşağıdakiler FATAL ───────────────────────────────────
+        // Depo tanımları yapılmazsa kurulu sistemde `pisi install`
+        // çalışmaz, yani kullanıcı paket kuramaz. Sessizce yutulursa
+        // kurulum "başarılı" görünür ama sistem kullanılamaz.
+        ui.log("Depolar ekleniyor…");
+        for (name, url) in [
+            ("stable2", "https://stable2.pisilinux.org/pisi-index.xml.xz"),
+            ("contrib", "https://contrib.pisilinux.org/pisi-index.xml.xz"),
+        ] {
+            run_chroot(&self.mount, &["pisi", "ar", name, url]).await
+                .map_err(|e| format!("'{}' deposu eklenemedi: {}\n\
+                                     Kurulu sistemde paket kurulamaz.", name, e))?;
+        }
+
+        // Depoları etkinleştir
+        ui.log("Depolar etkinleştiriliyor…");
+        run_chroot(&self.mount, &["pisi", "er", "contrib", "stable2"]).await
+            .map_err(|e| format!("Depolar etkinleştirilemedi: {}", e))?;
+
+        // Paket listelerini güncelle (ağ gerektirir, birkaç dakika sürebilir)
+        ui.log("Depolar güncelleniyor (ağ gerekir, biraz sürebilir)…");
+        run_chroot(&self.mount, &["pisi", "ur"]).await
+            .map_err(|e| format!("Paket listeleri güncellenemedi: {}\n\
+                                 Depolar tanımlı ama indeksleri eksik olabilir.", e))?;
 
         ui.log("✓ Live temizlik tamamlandı");
         Ok(())

src/jobs/mod.rs

@@ -29,6 +29,7 @@
 
 mod autologin;
 mod bootloader;
+mod cleanup;
 mod execution;
 mod finish;
 mod keyboard;
@@ -40,6 +41,7 @@ mod users;
 
 pub use autologin::ConfigureAutologinJob;
 pub use bootloader::{GenerateInitramfsJob, InstallGrubJob};
+pub use cleanup::EmergencyCleanupJob;
 pub use execution::{CopyFilesJob, MountBindJob, UnmountBindJob};
 pub use finish::{CleanupLiveJob, RunComarJob, RunLdconfigJob, UpdateEnvironmentJob};
 pub use keyboard::ConfigureKeyboardJob;
@@ -165,15 +167,31 @@ pub trait Job: Send + Sync {
 
 pub struct JobQueue {
     jobs: Vec<Box<dyn Job>>,
+    /// Başarı da başarısızlık da HER ZAMAN çalıştırılır. Bir iş hata
+    /// verdiğinde bu listeye geçilmeden `return` edilirse hedef bölümler
+    /// bağlı kalır, LUKS mapper'ları açık, swap aktif ve kullanıcı
+    /// kullanılamaz bir canlı sistemde kalır.
+    cleanup: Vec<Box<dyn Job>>,
 }
 
 impl JobQueue {
     pub fn new(jobs: Vec<Box<dyn Job>>) -> Self {
-        Self { jobs }
+        Self { jobs, cleanup: Vec::new() }
+    }
+
+    /// `cleanup` işleri kuyruk BİTSE BİLE hata durumunda da çalıştırılır.
+    pub fn with_cleanup(mut self, cleanup: Vec<Box<dyn Job>>) -> Self {
+        self.cleanup = cleanup;
+        self
     }
 
     /// Tüm işleri sırayla çalıştırır.
     /// İlerleme ve loglar `ui` üzerinden UI'ye iletilir.
+    ///
+    /// Hata durumunda: hatayı loglar, `cleanup` işlerini çalıştırır,
+    /// ardından `InstallMessage::Error` gönderir. Temizlik de hata
+    /// verirse bu hatalar orijinal hataya eklenerek raporlanır — böylece
+    /// kullanıcı hem asıl hatayı hem de "ne yapılması gerektiğini" görür.
     pub async fn run_all(&mut self, ui: UiSender) {
         let total = self.jobs.len();
 
@@ -181,24 +199,52 @@ impl JobQueue {
             let localized_name = t!(job.name());
             ui.log(format!("▶ {}", localized_name));
 
-            match job.run(&ui).await {
-                Ok(()) => {
-                    ui.log(format!("✓ {}", localized_name));
-                }
-                Err(e) => {
-                    let msg = format!("✗ {}: {}", localized_name, e);
-                    ui.log(msg.clone());
-                    ui.send(InstallMessage::Error(msg));
-                    return;
-                }
+            if let Err(e) = job.run(&ui).await {
+                let msg = format!("✗ {}: {}", localized_name, e);
+                ui.log(msg.clone());
+                let report = self.run_cleanup(&ui, &e).await;
+                ui.send(InstallMessage::Error(report));
+                return;
             }
 
+            ui.log(format!("✓ {}", localized_name));
             let progress = (i + 1) as f32 / total as f32;
             ui.send(InstallMessage::Progress(progress));
         }
 
         ui.send(InstallMessage::Done);
     }
+
+    /// Temizlik işlerini çalıştırır; kullanıcıya gösterilecek rapor döndürür.
+    async fn run_cleanup(&self, ui: &UiSender, original_err: &str) -> String {
+        if self.cleanup.is_empty() {
+            return original_err.to_string();
+        }
+
+        ui.log("Kurulum durdu — bağlamalar temizleniyor…");
+        let mut leftovers: Vec<String> = Vec::new();
+
+        for job in &self.cleanup {
+            match job.run(ui).await {
+                Ok(()) => {}
+                Err(e) => leftovers.push(format!("{}: {}", t!(job.name()), e)),
+            }
+        }
+
+        if leftovers.is_empty() {
+            ui.log("✓ Bağlamalar temizlendi");
+            original_err.to_string()
+        } else {
+            ui.log(format!("⚠ {} temizlik sorunu", leftovers.len()));
+            let msg = format!(
+                "{}\n\n--- KURULUM DURDUKTAN SONRA ---\n\
+                 Canlı sistemde elle temizlemeniz gerekenler var:\n{}",
+                original_err,
+                leftovers.iter().map(|l| format!("  • {}", l)).collect::<Vec<_>>().join("\n")
+            );
+            msg
+        }
+    }
 }
 
 // ─────────────────────────────────────────────
@@ -281,6 +327,90 @@ fn is_mount_point(path: &std::path::Path) -> bool {
     }
 }
 
+/// `/proc/self/mountinfo` alanındaki kaçışlı diziyi çözer.
+///
+/// mountinfo, yol içindeki özel karakterleri `\0NNN` **oktal** olarak yazar
+/// (boşluk `\040`, tab `\011`, satır sonu `\012`, backslash `\134`).
+/// Çözülmezse "My Disk" gibi bir mountpoint hiçbir koşulla eşleştirilemez.
+fn unescape_mount_field(s: &str) -> String {
+    let bytes = s.as_bytes();
+    let mut out = Vec::with_capacity(bytes.len());
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'\\' && i + 3 < bytes.len() + 1 {
+            // `\0NNN` veya `\NNN` biçiminde 3 haneli oktal
+            let (start, width) = if bytes.get(i + 1) == Some(&b'0') { (i + 1, 4) } else { (i + 1, 3) };
+            if start + width <= bytes.len() {
+                let digits = &s[start..start + width];
+                if digits.bytes().all(|b| (b'0'..=b'7').contains(&b)) {
+                    if let Ok(v) = u32::from_str_radix(digits, 8) {
+                        out.push(v as u8);
+                        i = start + width;
+                        continue;
+                    }
+                }
+            }
+        }
+        out.push(bytes[i]);
+        i += 1;
+    }
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+/// Bir bağlama noktasının altındaki TÜM bağlı dosya sistemlerini döndürür,
+/// en derinden yüzeye doğru sıralı.
+///
+/// Neden gerekiyor: `UnmountBindJob` elle yazılmış bir liste
+/// (`proc`, `sys`, `dev`, `boot/efi`, ...) kullanıyordu. Manuel bölümlemede
+/// `/home`, `/var`, `/boot` gibi ek bölümler o listede yoktu ve kurulum
+/// sonrası bağlı kalıyordu. Bu fonksiyon düzeni bilmez — `mount` altındaki
+/// her şeyi bulur, LUKS/LVM/fuse/loop ne olursa olsun.
+fn mounted_paths_under(mount: &str) -> Vec<String> {
+    let prefix = format!("{}/", mount.trim_end_matches('/'));
+    let root = mount.trim_end_matches('/').to_string();
+
+    let mut paths: Vec<String> = Vec::new();
+    if let Ok(info) = std::fs::read_to_string("/proc/self/mountinfo") {
+        for line in info.lines() {
+            // mountinfo alanları: id parent major:minor root mountpoint
+            // options [optional...] - fstype source superopts
+            let Some(mp_field) = line.split_whitespace().nth(4) else { continue };
+            let mp = unescape_mount_field(mp_field);
+            if mp == root || mp.starts_with(&prefix) {
+                paths.push(mp);
+            }
+        }
+    }
+
+    // `/proc/self/mountinfo` kökte de bir satır yoksa kökü de dahil et
+    if !paths.iter().any(|p| p == &root) && is_mount_point(std::path::Path::new(&root)) {
+        paths.push(root.clone());
+    }
+
+    // En derin yol önce: "/mnt/a/b" -> "/mnt/a" -> "/mnt".
+    // Aynı derinlikte ise uzun yol önce.
+    paths.sort_by(|a, b| b.len().cmp(&a.len()));
+    paths.dedup();
+    paths
+}
+
+/// LUKS mapper adlarını döndürür (typeseri `crypt` olan aygıtlar).
+fn open_crypt_mappers() -> Vec<String> {
+    let out = std::process::Command::new("lsblk")
+        .args(["-ndo", "NAME,TYPE"])
+        .output();
+    let Ok(out) = out else { return Vec::new() };
+    String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .filter_map(|l| {
+            let mut it = l.split_whitespace();
+            let name = it.next()?;
+            let kind = it.next()?;
+            (kind == "crypt").then(|| name.to_string())
+        })
+        .collect()
+}
+
 /// `blkid` ile bir bölümün dosya sistemi türünü döndürür.
 async fn get_fs_type(device: &str) -> Result<String, String> {
     let output = tokio::process::Command::new("blkid")
@@ -511,6 +641,8 @@ pub fn build_full_job_queue(
     let mt           = cfg.mount.clone();
     let plan2        = plan.clone();
     let plan3        = plan.clone();
+    // Temizlik için bölüm yolları; `plan` birkaç satır sonra taşınıyor.
+    let cleanup_parts = auto_mode_partitions(&plan);
 
     // Kaynak dizini: parametre boşsa otomatik tespit et
     let src = if cfg.source.is_empty() { detect_source_dir() } else { cfg.source };
@@ -613,7 +745,30 @@ pub fn build_full_job_queue(
     // 20. Bind-mount temizle
     jobs.push(Box::new(UnmountBindJob { mount: mt.clone() }));
 
-    JobQueue::new(jobs)
+    // 21. Son temizlik: LUKS mapper'larını kapat, swap'u indir.
+    // Normal akışta da çalışır — yeniden başlatmadan önce mapper'ın
+    // açık kalması gereksiz ve zararlıdır.
+    jobs.push(Box::new(EmergencyCleanupJob {
+        mount: mt.clone(),
+        partitions: cleanup_parts.clone(),
+    }));
+
+    JobQueue::new(jobs).with_cleanup(vec![Box::new(EmergencyCleanupJob {
+        mount: mt.clone(),
+        partitions: cleanup_parts,
+    })])
+}
+
+/// Otomatik modda oluşturulan bölüm yolları (temizlik için).
+/// Sıra `PartitionJob` ile aynı olmalıdır: EFI → swap → kök.
+fn auto_mode_partitions(plan: &PartitionPlan) -> Vec<String> {
+    let mut parts = Vec::new();
+    if plan.efi_mb > 0 {
+        parts.push(part_path(&plan.disk, 1));
+    }
+    parts.push(part_path(&plan.disk, if plan.efi_mb > 0 { 2 } else { 1 })); // swap
+    parts.push(part_path(&plan.disk, if plan.efi_mb > 0 { 3 } else { 2 })); // kök
+    parts
 }
 
 /// Manuel bölümleme kullanıldığında derlenecek kurulum iş kuyruğu.
@@ -633,7 +788,7 @@ pub fn build_custom_job_queue(
     let src = if cfg.source.is_empty() { detect_source_dir() } else { cfg.source };
 
     let mut jobs: Vec<Box<dyn Job>> = vec![
-        Box::new(CustomPartitionJob { disk: disk.clone(), custom_partitions: custom_partitions.clone() }),
+        Box::new(CustomPartitionJob { custom_partitions: custom_partitions.clone() }),
         Box::new(SetupLvmJob { volume_groups: volume_groups.clone(), logical_volumes: logical_volumes.clone() }),
         Box::new(MountCustomPartitionsJob { custom_partitions: custom_partitions.clone(), logical_volumes: logical_volumes.clone(), mount: mt.clone() }),
         Box::new(MountBindJob { mount: mt.clone() }),
@@ -686,5 +841,19 @@ pub fn build_custom_job_queue(
     jobs.push(Box::new(CleanupLiveJob { mount: mt.clone() }));
     jobs.push(Box::new(UnmountBindJob { mount: mt.clone() }));
 
-    JobQueue::new(jobs)
+    // Son temizlik (bkz. otomatik mod).
+    let cleanup_parts: Vec<String> = custom_partitions.iter()
+        .filter(|p| !p.delete)
+        .map(|p| p.device.clone())
+        .filter(|d| !d.is_empty())
+        .collect();
+    jobs.push(Box::new(EmergencyCleanupJob {
+        mount: mt.clone(),
+        partitions: cleanup_parts.clone(),
+    }));
+
+    JobQueue::new(jobs).with_cleanup(vec![Box::new(EmergencyCleanupJob {
+        mount: mt.clone(),
+        partitions: cleanup_parts,
+    })])
 }

src/jobs/users.rs

@@ -24,7 +24,7 @@ impl Job for CreateUserJob {
         }
 
         // useradd: kullanıcıyı temel gruplarla oluştur
-        // PisiLinux'ta "storage" grubu yoksa useradd hata verir; -M flag ile grub yoksa atla
+        // PisiLinux'ta "storage" grubu yoksa useradd hata verir; -M flag ile grup yoksa atla
         // Güvenli yöntem: önce her grubu tek tek ekle
         let groups = ["wheel", "users", "pnp", "disk", "audio", "video", "power", "dialout", "lp", "lpadmin", "cdrom", "floppy"];
         for grp in &groups {
@@ -47,37 +47,22 @@ impl Job for CreateUserJob {
             &self.username,
         ]).await?;
 
-        // // chpasswd ile şifre ayarla (stdin üzerinden güvenli)
-        // ui.log(format!("Şifre ayarlanıyor: {}", self.username));
-        // let chpasswd_input = format!("{}:{}", self.username, self.password);
-        // set_password_via_chpasswd(&self.mount, &chpasswd_input).await?;
-
-        // // Root şifresi: belirlenmişse ayarla, yoksa kilitle
-        // if self.root_password.is_empty() {
-        //     ui.log("Root hesabı kilitleniyor…");
-        //     run_chroot(&self.mount, &["passwd", "-l", "root"]).await?;
-        // } else {
-        //     ui.log("Root şifresi ayarlanıyor…");
-        //     let root_input = format!("root:{}", self.root_password);
-        //     set_password_via_chpasswd(&self.mount, &root_input).await?;
-        // }
-
-        // 2. chpasswd ile şifre ayarla (YENİ BASİTLEŞTİRİLMİŞ VE KESİN YÖNTEM)
+        // Kullanıcı şifresi: `chpasswd` stdin üzerinden.
+        // `sh -c "echo 'user:pass' | ..."` KULLANILMAZ: parola düz metin
+        // olarak kabuğun argv'sine geçer ve /proc/<pid>/cmdline üzerinden
+        // okunabilir; ayrıca `'` veya `$(...)` içeren parola komutu bozar.
+        // Aynı desen jobs/partition.rs::run_luks_format'ta da kullanılıyor.
         ui.log(format!("Şifre ayarlanıyor: {}", self.username));
-        // sh -c kullanarak echo ile chpasswd'e şifreyi güvenli bir şekilde üflüyoruz
-        let user_cmd = format!("echo '{}:{}' | chpasswd -c SHA512", self.username, self.password);
-        run_chroot(&self.mount, &["sh", "-c", &user_cmd]).await?;
+        set_password_via_chpasswd(&self.mount, &self.username, &self.password).await?;
 
-        // 3. Root şifresi: belirlenmişse ayarla, yoksa kilitle
+        // Root şifresi: belirlenmişse ayarla, yoksa kilitle
         if self.root_password.is_empty() {
             ui.log("Root hesabı kilitleniyor…");
             run_chroot(&self.mount, &["passwd", "-l", "root"]).await?;
         } else {
             ui.log("Root şifresi ayarlanıyor…");
-            let root_cmd = format!("echo 'root:{}' | chpasswd -c SHA512", self.root_password);
-            run_chroot(&self.mount, &["sh", "-c", &root_cmd]).await?;
-}
-
+            set_password_via_chpasswd(&self.mount, "root", &self.root_password).await?;
+        }
 
         // sudoers: wheel grubu sudo yetkisi alsın
         let sudoers_dir = format!("{}/etc/sudoers.d", self.mount);
@@ -96,39 +81,63 @@ impl Job for CreateUserJob {
     }
 }
 
-// /// `chpasswd` komutuna stdin üzerinden kullanıcı:şifre gönderir.
-// async fn set_password_via_chpasswd(mount: &str, input: &str) -> Result<(), String> {
-//     if DEMO_MODE.load(std::sync::atomic::Ordering::Relaxed) {
-//         tokio::time::sleep(std::time::Duration::from_millis(2500)).await;
-//         return Ok(());
-//     }
+/// `chroot <mount> chpasswd -c SHA512` komutuna `kullanici:sifre` bilgisini
+/// **stdin pipe'ı** üzerinden iletir.
+///
+/// Neden `sh -c` + `format!` değil:
+///   1. Parola kabuğun argv'sine yazılırsa `/proc/<pid>/cmdline` üzerinden
+///      canlı sistemdeki herhangi bir süreç tarafından okunabilir.
+///   2. Parola içindeki `'` veya `$(...)` karakterleri komutu bozar ve
+///      shell injection'a yol açar.
+///   3. `format!` ile üretilen komut `user:pass` içinde `:` geçse hatalı
+///      ayrıştırılır.
+///
+/// Bu desen `jobs/partition.rs::run_luks_format` ile birebir aynıdır.
+async fn set_password_via_chpasswd(
+    mount: &str,
+    username: &str,
+    password: &str,
+) -> Result<(), String> {
+    if super::DEMO_MODE.load(std::sync::atomic::Ordering::Relaxed) {
+        tokio::time::sleep(std::time::Duration::from_millis(2500)).await;
+        return Ok(());
+    }
 
-//     use tokio::io::AsyncWriteExt;
-//     use tokio::process::Command;
+    use tokio::io::AsyncWriteExt;
 
-//     let mut child = Command::new("chroot")
-//         .args([mount, "chpasswd"])
-//         .stdin(std::process::Stdio::piped())
-//         .stdout(std::process::Stdio::null())
-//         .stderr(std::process::Stdio::piped())
-//         .spawn()
-//         .map_err(|e| format!("chpasswd başlatılamadı: {}", e))?;
+    let mut child = tokio::process::Command::new("chroot")
+        .args([mount, "chpasswd", "-c", "SHA512"])
+        .stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::piped())
+        .spawn()
+        .map_err(|e| format!("chpasswd başlatılamadı: {}", e))?;
 
-//     if let Some(mut stdin) = child.stdin.take() {
-//         let mut data = input.as_bytes().to_vec();
-//         if !data.ends_with(b"\n") {
-//             data.push(b'\n');
-//         }
-//         stdin.write_all(&data).await
-//             .map_err(|e| format!("chpasswd stdin yazma hatası: {}", e))?;
-//     }
+    // Parolayı yalnızca çocuk sürecin stdin'ine yaz; argv'de hiç görünmez.
+    if let Some(mut stdin) = child.stdin.take() {
+        // chpasswd "user:pass" satırı bekler ve satır sonu ile ayırır.
+        let mut data = format!("{}:{}\n", username, password).into_bytes();
+        if data.last() != Some(&b'\n') {
+            data.push(b'\n');
+        }
+        let result = stdin.write_all(&data).await;
+        // Yazdıktan sonra parolanın kopyasını bellekte bırakma.
+        data.iter_mut().for_each(|b| *b = 0);
+        drop(stdin);
+        result.map_err(|e| format!("chpasswd stdin yazma hatası: {}", e))?;
+    }
 
-//     let output = child.wait_with_output().await
-//         .map_err(|e| format!("chpasswd bekleme hatası: {}", e))?;
+    let output = child.wait_with_output().await
+        .map_err(|e| format!("chpasswd bekleme hatası: {}", e))?;
 
-//     if output.status.success() {
-//         Ok(())
-//     } else {
-//         Err(String::from_utf8_lossy(&output.stderr).trim().to_string())
-//     }
-// }
+    if output.status.success() {
+        Ok(())
+    } else {
+        let err = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        if err.is_empty() {
+            Err(format!("{} için şifre ayarlanamadı", username))
+        } else {
+            Err(err)
+        }
+    }
+}

src/lib.rs

@@ -1,9 +0,0 @@
-pub mod installer;
-pub mod steps;
-pub mod jobs;
-pub mod ui;
-pub mod autoinstall;
-pub mod branding;
-pub mod funct;
-
-rust_i18n::i18n!("locales");

src/main.rs

@@ -128,6 +128,7 @@ fn run_auto_install(path: &str, demo_mode: bool) -> eframe::Result<()> {
     let timezone   = af.install.timezone.clone();
     let username   = af.user.username.clone();
     let password   = af.user.password.clone();
+    let root_password = af.user.root_password.clone();
     let hostname   = af.user.hostname.clone();
     let kb_layout  = af.install.keyboard.clone();
     let kb_variant = af.install.keyboard_variant.clone();
@@ -135,6 +136,16 @@ fn run_auto_install(path: &str, demo_mode: bool) -> eframe::Result<()> {
     let mount      = af.install.mount.clone();
     let plan       = state.partition_plan.unwrap();
 
+    // Squashfs kurulumu: oturum yöneticisi ve masaüstü ortamı ISO'dan
+    // gelir. `apply_to_state` bunları GlobalState'in canlı ortam
+    // tespitine bırakıyor; burada sabit yazmıyoruz.
+    let display_manager     = state.display_manager.clone();
+    let desktop_environment = state.desktop_environment.clone();
+    let autologin           = af.system.autologin;
+    let boot_timeout        = af.system.bootloader_timeout;
+    let boot_password       = af.system.bootloader_password.clone();
+    let kernel_options      = af.system.kernel_options.clone();
+
     let rt = tokio::runtime::Runtime::new().expect("tokio runtime");
     rt.block_on(async {
         use std::sync::mpsc;
@@ -176,14 +187,16 @@ fn run_auto_install(path: &str, demo_mode: bool) -> eframe::Result<()> {
                     kb_variant:          kb_variant_c,
                     demo_mode,
                     boot_device:         String::new(),
-                    bootloader_timeout:  5,
-                    bootloader_password: String::new(),
-                    kernel_options:      String::new(),
+                    bootloader_timeout:  boot_timeout,
+                    bootloader_password: boot_password,
+                    kernel_options:      kernel_options,
                     use_ntp:             true,
-                    root_password:       String::new(),
-                    display_manager:     "sddm".to_string(),
-                    autologin:           true,
-                    desktop_environment: "plasma".to_string(),
+                    root_password:       root_password,
+                    // Tespit edilmiş değerler (ISO'nun kendisi) — sabit
+                    // yazılmıyor.
+                    display_manager,
+                    autologin,
+                    desktop_environment,
                     selected_package_groups: Vec::new(),
                     manual_year:         2026,
                     manual_month:        5,
@@ -245,6 +258,19 @@ impl Default for YaliApp {
         let branding = branding::BrandingConfig::load_for_lang(&default_lang);
         let mut app = Self {
             state: GlobalState::default(),
+            // Sihirbaz akışı: yalı KURULU SİSTEMİ squashfs'ten diske
+            // kopyalar (CopyFilesJob rsync). Bu yüzden ISO'da hangi
+            // paketler, ekran yöneticisi ve masaüstü ortamı varsa
+            // kurulum BUNLARI ZATEN İÇERİR.
+            //
+            // Bu yüzden LicenseStep, DisplayManagerStep ve NetinstallStep
+            // bilinçli olarak listede DEĞİL:
+            //   - lisans kabulü bu akışta anlam taşımıyor
+            //   - ekran yöneticisi ISO'da pişmiş geliyor
+            //   - ağdan ek paket kurmak, diski squashfs'ten kopyalamayla
+            //     çelişir; netinstall ayrı bir proje olarak ileride
+            //     devreye alınacak
+            // Adımlar silinmedi — mod.rs'te tanımlı ve hazır duruyor.
             steps: vec![
                 Box::new(WelcomeStep::default()),
                 Box::new(LocationStep::default()),
@@ -295,7 +321,7 @@ impl Default for YaliApp {
 
 impl eframe::App for YaliApp {
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        rust_i18n::set_locale(&self.state.language);
+        rust_i18n::set_locale(crate::funct::sanitize_locale(&self.state.language));
 
         // Dil değişimi kontrolü -> branding dosyasını dinamik olarak yeniden yükle
         if self.loaded_language != self.state.language {
@@ -328,9 +354,13 @@ impl eframe::App for YaliApp {
         }
 
         let cur     = self.state.current_step;
-        let n_steps = self.steps.len();
-        let is_exec   = cur == n_steps - 2;
-        let is_finish = cur == n_steps - 1;
+        // Rol artık konumsal tahminle değil, adımın kendi bildirdiği
+        // `role()` ile belirleniyor. Sihirbaza yeni adım eklemek rol
+        // algısını bozmaz (bkz. StepRole).
+        let role = self.steps.get(cur).map(|s| s.role())
+            .unwrap_or(installer::StepRole::Normal);
+        let is_exec   = role == installer::StepRole::Execution;
+        let is_finish = role == installer::StepRole::Finish;
 
         // Adım değişmişse on_enter çağır
         if cur != self.last_step {
@@ -509,6 +539,7 @@ impl eframe::App for YaliApp {
                 .inner_margin(egui::Margin::same(20.0)))
             .show(ctx, |ui| {
                 egui::ScrollArea::vertical()
+                    .scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::AlwaysHidden)
                     .id_source("main_scroll")
                     .show(ui, |ui| {
                         if let Some(step) = self.steps.get_mut(cur) {
@@ -517,4 +548,91 @@ impl eframe::App for YaliApp {
                     });
             });
     }
-}
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use installer::StepRole;
+
+    /// Sihirbazın adım dizisi. main.rs::YaliApp::default() ile AYNI
+    /// olmalı — test bu yüzden diziyi yeniden kuruyor.
+    fn wizard() -> Vec<Box<dyn InstallerStep>> {
+        vec![
+            Box::new(WelcomeStep::default()),
+            Box::new(LocationStep::default()),
+            Box::new(KeyboardStep::default()),
+            Box::new(NetworkStep::default()),
+            Box::new(PartitionStep::default()),
+            Box::new(UsersStep::default()),
+            Box::new(BootloaderStep::default()),
+            Box::new(SummaryStep),
+            Box::new(ExecutionStep::default()),
+            Box::new(FinishStep),
+        ]
+    }
+
+    #[test]
+    fn wizard_has_one_execution_and_one_finish_step() {
+        let steps = wizard();
+        assert_eq!(
+            steps.iter().filter(|s| s.role() == StepRole::Execution).count(),
+            1,
+            "tam olarak bir ExecutionStep olmalı"
+        );
+        assert_eq!(
+            steps.iter().filter(|s| s.role() == StepRole::Finish).count(),
+            1,
+            "tam olarak bir FinishStep olmalı"
+        );
+    }
+
+    /// Konumsal tespit yerine role() kullanıldığı için, Execution ve
+    /// Finish listenin SONU olmak zorunda değil. Bu test yine de
+    /// beklenen sırayı sabitler; bir adım yanlış yere eklendiğinde
+    /// (ör. Finish'ten sonra yeni bir adım) kırılır.
+    #[test]
+    fn execution_and_finish_are_the_last_two_steps() {
+        let steps = wizard();
+        let n = steps.len();
+        assert_eq!(steps[n - 2].role(), StepRole::Execution);
+        assert_eq!(steps[n - 1].role(), StepRole::Finish);
+    }
+
+    #[test]
+    fn all_ordinary_steps_precede_the_execution_step() {
+        let steps = wizard();
+        let first_exec = steps.iter().position(|s| s.role() == StepRole::Execution)
+            .expect("ExecutionStep bulunmalı");
+        assert!(
+            steps[..first_exec].iter().all(|s| s.role() == StepRole::Normal),
+            "ExecutionStep'tan önceki tüm adımlar Normal olmalı"
+        );
+    }
+
+    /// Yeni bir adım eklemek rol algısını bozmamalı. Bu, 22de7d5
+    /// sonrası yaşanan regresyon sınıfının tersidir: orada liste
+    /// değişti ve konumsal `cur == n_steps - 2` tespiti sessizce
+    /// kaydı.
+    ///
+    /// Örnek olarak `NetinstallStep` kullanıldı: bu adım squashfs
+    /// kurulumunda bilinçli olarak listede değil, ama netinstall
+    /// projesi başladığında aynen buraya eklenebilmeli.
+    #[test]
+    fn roles_survive_inserting_a_step_before_execution() {
+        let mut steps = wizard();
+        let exec_at = steps.iter().position(|s| s.role() == StepRole::Execution).unwrap();
+
+        // Yeni bir Normal adım ekle
+        steps.insert(exec_at, Box::new(steps::netinstall::NetinstallStep));
+        let n = steps.len();
+
+        // Hâlâ doğru adımlar son ikide mi?
+        assert_eq!(steps[n - 2].role(), StepRole::Execution);
+        assert_eq!(steps[n - 1].role(), StepRole::Finish);
+        // Role() sayesinde Execution'ın KONUMU değil KENDİSİ bulunuyor:
+        // konum bir kayar, ama Execution yine n-2'de.
+        let exec_at2 = steps.iter().position(|s| s.role() == StepRole::Execution).unwrap();
+        assert_eq!(exec_at2, exec_at + 1, "eklenen adım Execution'ı bir kaydırmalı");
+    }
+}

src/steps/bootloader.rs

@@ -4,12 +4,104 @@ use crate::installer::{GlobalState, InstallerStep};
 use crate::ui::theme;
 use crate::funct::{form_label, form_input_text, form_input_password};
 
+/// Bir diskin bölüm sayısını `sysfs`'ten okur (alt süreç yok).
+///
+/// `lsblk` çalıştırmak kare başına olsaydı her karede süreç doğardu;
+/// `on_enter`'da bile gereksiz. sysfs'te her bölüm
+/// `/sys/block/<disk>/<disk><N>`, `…/start` dosyasıyla listelenir.
+fn disk_partition_count(disk: &str) -> usize {
+    let base = crate::steps::partition::base_disk_name(disk);
+    if base.is_empty() {
+        return 0;
+    }
+    let dir = format!("/sys/block/{}", base);
+    let Ok(rd) = std::fs::read_dir(&dir) else { return 0 };
+    rd.flatten().filter(|e| {
+        let name = e.file_name().to_string_lossy().to_string();
+        // Yalnızca "<base><rakam>" biçimindeki girdiler bölümdür.
+        name.strip_prefix(&base)
+            .map(|rest| !rest.is_empty() && rest.chars().all(|c| c.is_ascii_digit()))
+            .unwrap_or(false)
+    }).count()
+}
+
+/// Önyükleyici için varsayılan aygıtı seçer.
+///
+/// Kural: **KÖR diski seçme; zaten işletim sistemi kurulu olan diski
+/// seç.** Çünkü BIOS modunda `grub-install` seçilen diskin MBR'sine
+/// yazar ve MBR'yi okuyan aygıt firmware'in açılış sırasındaki ilk
+/// diski olmak ZORUNDA. Çift önyüklemeli bir makinede bu, mevcut
+/// işletim sisteminin diski — kökün kurulduğu disk DEĞİL.
+///
+/// Somut olarak: sda'da Windows, sdb'de PisiLinux kuruluyor. GRUB
+/// sdb'nin MBR'sine yazılırsa firmware sdb'yi açmaz, PisiLinux hiç
+/// görünmez. sda'nın MBR'sine yazılırsa firmware GRUB'a düşer, GRUB
+/// da ikisini de listeler.
+///
+/// "İşletim sistemi kurulu"nun en güvenilir ve en ucuz göstergesi:
+/// **kök diski dışında, hâlihazırda bölüm tablosu olan bir disk**
+/// (yani disk dolu değil, içinde tanım var).
+///
+/// Sıralama:
+/// 1. Çıkarılabilir aygıt (canlı ISO'nun USB'i) — ASLA hedef değil
+/// 2. Kök diski dışında bölümü olan ilk dahili disk → mevcut OS diski
+/// 3. Kök diski
+/// 4. Aktif düzenleme diski (`selected_disk`) — son çare
+///
+/// Tek diskli kurulumda 3. adım çalışır: başka disk yoktur, davranış
+/// kök diskiyle aynıdır.
+pub fn default_boot_device<R, F>(
+    root_disk: Option<&str>,
+    disks: &[crate::installer::DiskInfo],
+    is_removable: R,
+    has_partitions: F,
+) -> Option<String>
+where
+    R: Fn(&str) -> bool,
+    F: Fn(&str) -> bool,
+{
+    // (1) çıkarılabilir aygıtlar ve (2) kök diski ele
+    disks.iter()
+        .filter(|d| !is_removable(&d.name))
+        .filter(|d| Some(d.name.as_str()) != root_disk)
+        .find(|d| has_partitions(&d.name))
+        .map(|d| d.name.clone())
+        .or_else(|| root_disk.map(|s| s.to_string()))
+}
+
 #[derive(Default)]
 pub struct BootloaderStep {
     show_password: bool,
     timeout_str: String,
 }
 
+/// Seçili aygıt, "zaten işletim sistemi olan disk" kuralıyla mı
+/// belirlendi? Değilse (kullanıcı elle değiştirdiyse ya da tek disk
+/// varsa) `None` döner ve ipucu gösterilmez.
+fn boot_device_reason(state: &GlobalState, current: &str) -> Option<String> {
+    let root_disk = state
+        .custom_partitions
+        .iter()
+        .find(|p| p.mountpoint == "/" && !p.delete)
+        .map(|p| p.disk.clone())
+        .or_else(|| state.partition_plan.as_ref().map(|p| p.disk.clone()));
+
+    // Aynı kuralı bir kez daha çalıştırıp sonucun aygıtla örtüştüğünü
+    // doğruluyoruz. Kural tek kaynakta; burada yalnızca UI metni var.
+    let expected = default_boot_device(
+        root_disk.as_deref(),
+        &state.available_disks,
+        crate::steps::partition::is_removable,
+        |d| disk_partition_count(d) > 0,
+    )?;
+
+    if expected == current {
+        Some(t!("bootloader_device_why_existing").to_string())
+    } else {
+        None
+    }
+}
+
 impl InstallerStep for BootloaderStep {
     fn name(&self) -> String {
         t!("bootloader").to_string()
@@ -19,9 +111,33 @@ impl InstallerStep for BootloaderStep {
         if self.timeout_str.is_empty() {
             self.timeout_str = state.bootloader_timeout.to_string();
         }
+        // Varsayılan GRUB aygıtı: zaten işletim sistemi kurulu olan
+        // disk. Detaylı gerekçe `default_boot_device` yorumunda.
+        //
+        // Önceki davranışlar ve nedenleri:
+        //   - `selected_disk` → manuel modda "aktif düzenleme diski";
+        //     /home eklemek için sdb'ye geçince GRUB sessizce oraya
+        //     gidiyordu.
+        //   - yalnızca kök diski → çift önyüklemeli makinede firmware'in
+        //     açmadığı diske MBR yazılıyor, PisiLinux hiç görünmüyor.
         if state.bootloader_device.is_empty() {
-            if let Some(ref disk) = state.selected_disk {
-                state.bootloader_device = disk.clone();
+            let root_disk = state
+                .custom_partitions
+                .iter()
+                .find(|p| p.mountpoint == "/" && !p.delete)
+                .map(|p| p.disk.clone())
+                .or_else(|| state.partition_plan.as_ref().map(|p| p.disk.clone()));
+
+            let chosen = default_boot_device(
+                root_disk.as_deref(),
+                &state.available_disks,
+                crate::steps::partition::is_removable,
+                |d| disk_partition_count(d) > 0,
+            )
+            .or_else(|| state.selected_disk.clone());
+
+            if let Some(d) = chosen {
+                state.bootloader_device = d;
             }
         }
     }
@@ -48,9 +164,25 @@ impl InstallerStep for BootloaderStep {
                     // Hedef aygıt
                     form_label(ui, &t!("bootloader_device_label"));
                     ui.horizontal(|ui| {
+                        // ⚠️ ÇIKARILABİLİR AYGITLAR LİSTEDE YOK.
+                        //
+                        // Canlı ISO'yu boot ettiğiniz USB `available_disks`
+                        // içinde yer alıyordu. Seçilirse BIOS modunda
+                        // `grub-install --target=i386-pc <usb>` MBR'yi o
+                        // aygıta yazar, kurulum biter ama sistem AÇILMAZ.
+                        //
+                        // Liste dolduysa (tamamen çıkarılabilir aygıt
+                        // görünürse) mevcut değer yine de gösterilir ki
+                        // ComboBox boş kalmasın.
                         let mut device_list: Vec<String> = state.available_disks.iter()
+                            .filter(|d| !crate::steps::partition::is_removable(&d.name))
                             .map(|d| d.name.clone())
                             .collect();
+                        if device_list.is_empty() {
+                            device_list = state.available_disks.iter()
+                                .map(|d| d.name.clone())
+                                .collect();
+                        }
                         if device_list.is_empty() {
                             device_list.push(state.bootloader_device.clone());
                         }
@@ -65,6 +197,26 @@ impl InstallerStep for BootloaderStep {
                             }
                         });
                     });
+                    // Varsayılanın NEDEN bu aygıt olduğunu söyle. Sessiz
+                    // bir varsayılan sürpriz yaratmasın: kullanıcı
+                    // nedenini anlamazsa dual-boot'ta yanlış aygıtta
+                    // kalır ve açılışta Windows görünmez.
+                    if let Some(why) = boot_device_reason(&state, &state.bootloader_device) {
+                        ui.label(
+                            egui::RichText::new(why)
+                                .size(11.0)
+                                .color(theme::c_accent()),
+                        );
+                    }
+                    // Çift önyükleme ipucu — kullanıcı bu adımda en çok
+                    // zorlanan kuralı burada öğreniyor.
+                    if std::path::Path::new("/sys/firmware/efi").exists() {
+                        ui.label(
+                            egui::RichText::new(t!("bootloader_device_hint_dualboot"))
+                                .size(11.0)
+                                .color(theme::c_accent()),
+                        );
+                    }
                     ui.label(
                         egui::RichText::new(t!("bootloader_device_hint"))
                             .size(11.0)
@@ -107,3 +259,128 @@ impl InstallerStep for BootloaderStep {
         !state.bootloader_device.is_empty()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::default_boot_device;
+    use crate::installer::DiskInfo;
+
+    fn d(name: &str) -> DiskInfo {
+        DiskInfo {
+            name: name.to_string(),
+            vendor: String::new(),
+            model: "TEST".to_string(),
+            drive_type: String::new(),
+            size_gb: 100,
+            size_bytes: 100 * 1_073_741_824,
+        }
+    }
+
+    /// `has_partitions` verilen aygıtın bölümü var mı diye bakar
+    /// (test ortamında gerçek sysfs yok, bu yüzden dışarıdan verilir).
+    fn parts_on(disks_with_parts: &[&str]) -> impl Fn(&str) -> bool {
+        let v: Vec<String> = disks_with_parts.iter().map(|s| s.to_string()).collect();
+        move |name: &str| v.iter().any(|p| p == name)
+    }
+
+    /// Test ortamında HİÇBİR aygıt çıkarılabilir sayılır.
+    ///
+    /// ⚠️ Gerçek `is_removable` çağrılırsa testler ortama bağımlı
+    /// olur: bu geliştirme makinesinde `/sys/block/sda/removable == 1`
+    /// olduğu için "/dev/sda" kullanan testler çıkarılabilir sanılıp
+    /// kırılıyordu. Testler **şansa** geçiyordu.
+    fn never_removable(_name: &str) -> bool {
+        false
+    }
+
+    /// ⭐ Kullanıcının senaryosu: sda'da Windows, sdb'de PisiLinux
+    /// kuruluyor. GRUB sda'ya yazılmalı — çünkü firmware açılışta
+    /// sda'yı okuyor. Kök diski (sdb) seçilirse PisiLinux hiç görünmez.
+    #[test]
+    fn picks_the_disk_that_already_has_an_os() {
+        let disks = vec![d("/dev/sda"), d("/dev/sdb"), d("/dev/sdc")];
+        let got = default_boot_device(Some("/dev/sdb"), &disks, never_removable, parts_on(&["/dev/sda"]));
+        assert_eq!(
+            got.as_deref(),
+            Some("/dev/sda"),
+            "mevcut işletim sistemi olan disk seçilmeli"
+        );
+    }
+
+    /// Tek diskli kurulumda davranış KÖRK diskiyle aynıdır — başka
+    /// aday yoktur.
+    #[test]
+    fn single_disk_install_falls_back_to_the_root_disk() {
+        let disks = vec![d("/dev/sda")];
+        assert_eq!(
+            default_boot_device(Some("/dev/sda"), &disks, never_removable, parts_on(&["/dev/sda"])).as_deref(),
+            Some("/dev/sda")
+        );
+    }
+
+    /// Çok diskli ama HİÇBİRİ bölümlü değilse (tamamen boş makineler)
+    /// kök disk seçilir.
+    #[test]
+    fn no_existing_os_anywhere_falls_back_to_root() {
+        let disks = vec![d("/dev/sda"), d("/dev/sdb")];
+        assert_eq!(
+            default_boot_device(Some("/dev/sdb"), &disks, never_removable, parts_on(&[])).as_deref(),
+            Some("/dev/sdb")
+        );
+    }
+
+    /// Kök diskin kendisi bölümlü olsa bile "mevcut OS" sayılmaz —
+    /// kurulum oraya yapılıyor, oraya varsayılan yazmak eski davranış.
+    #[test]
+    fn root_disk_is_never_treated_as_the_existing_os() {
+        let disks = vec![d("/dev/sda"), d("/dev/sdb")];
+        // sda'da kurulum, sdb boş → sda
+        assert_eq!(
+            default_boot_device(Some("/dev/sda"), &disks, never_removable, parts_on(&["/dev/sda"])).as_deref(),
+            Some("/dev/sda")
+        );
+    }
+
+    /// Birden çok aday varsa SIRALAMA önemlidir: liste zaten
+    /// kararlı sıralıdır, ilki seçilir.
+    #[test]
+    fn first_candidate_in_sorted_order_wins() {
+        let disks = vec![d("/dev/sda"), d("/dev/sdb"), d("/dev/sdc")];
+        assert_eq!(
+            default_boot_device(Some("/dev/sdd"), &disks, never_removable, parts_on(&["/dev/sdb", "/dev/sdc"])).as_deref(),
+            Some("/dev/sdb"),
+            "sıralı listedeki ilk bölümlü disk seçilmeli"
+        );
+    }
+
+    /// Kök disk bilinmiyorsa (otomatik mod / henüz taranmamış) yine
+    /// bölümlü disk seçilir; hiçbiri yoksa `None`.
+    #[test]
+    fn unknown_root_disk_is_handled() {
+        let disks = vec![d("/dev/sda"), d("/dev/sdb")];
+        assert_eq!(
+            default_boot_device(None, &disks, never_removable, parts_on(&["/dev/sda"])).as_deref(),
+            Some("/dev/sda")
+        );
+        assert_eq!(default_boot_device(None, &disks, never_removable, parts_on(&[])), None);
+    }
+
+    /// Disk listesi boşken bile KÖRK disk biliniyorsa o kullanılır —
+    /// liste yalnızca "mevcut işletim sistemi olan disk" arayışı için
+    /// gerekiyordu, son çare kök disktir.
+    #[test]
+    fn empty_disk_list_still_uses_the_root_disk() {
+        assert_eq!(
+            default_boot_device(Some("/dev/sda"), &[], never_removable, parts_on(&["/dev/sda"])).as_deref(),
+            Some("/dev/sda"),
+            "liste boş olsa da bilinen kök disk kullanılmalı"
+        );
+    }
+
+    /// Ne disk ne de kök biliniyorsa `None` — `on_enter` bu durumda
+    /// `selected_disk`'e düşer, o da yoksa aygıt seçilemez.
+    #[test]
+    fn nothing_known_yields_none() {
+        assert_eq!(default_boot_device(None, &[], never_removable, parts_on(&[])), None);
+    }
+}

src/steps/execution.rs

@@ -16,6 +16,20 @@ use crate::jobs::{self, InstallMessage, UiSender};
 use crate::ui::{ErrorScreen, Slideshow};
 use crate::ui::theme;
 
+/// "Kurulum devam ediyor, lütfen bekleyin…" uyarısı gösterilmeli mi?
+///
+/// `copy_active` iken GÖSTERİLMEZ: çubuğun yanında yüzde ve kopyalanan
+/// dosyanın adı zaten yazılı, "bekleyin" demek yerine ne olduğunu
+/// söyleyen çok daha fazla bilgi var. Ek olarak bu etiket çubuğun
+/// altında ikinci kez görünüyordu.
+///
+/// Kopyalama bitince `copy_active` false olur ve uyarı geri gelir:
+/// fstab, GRUB, temizlik gibi adımlarda ilerleme çubuğu yoktur, orada
+/// kullanıcının beklemesi gerektiğini bilmesi doğrudur.
+fn show_wait_notice(running: bool, copy_active: bool) -> bool {
+    running && !copy_active
+}
+
 #[derive(Default)]
 pub struct ExecutionStep {
     rx:           Option<mpsc::Receiver<InstallMessage>>,
@@ -337,7 +351,7 @@ impl InstallerStep for ExecutionStep {
                 ui.add_space(8.0);
                 if self.finished {
                     theme::success_box(ui, &t!("install_done"));
-                } else if running {
+                } else if show_wait_notice(running, self.copy_active) {
                     ui.horizontal(|ui| {
                         ui.spinner();
                         ui.colored_label(theme::c_text_dim(), t!("install_in_progress"));
@@ -368,6 +382,10 @@ impl InstallerStep for ExecutionStep {
         }
     }
 
+    fn role(&self) -> crate::installer::StepRole {
+        crate::installer::StepRole::Execution
+    }
+
     fn is_complete(&self, _state: &GlobalState) -> bool {
         self.finished && self.error_screen.is_none()
     }
@@ -386,3 +404,37 @@ impl InstallerStep for ExecutionStep {
 //         egui::Color32::from_rgb(185, 185, 205)
 //     }
 // }
+
+#[cfg(test)]
+mod tests {
+    use super::show_wait_notice;
+
+    /// Kopyalama başlayınca "bekleyin" uyarısı KAYBOLMALI.
+    ///
+    /// Kullanıcı isteği: kopyalanan dosyalar gösterilmeye başladığında
+    /// uyarı gereksiz — çubuk zaten yüzde ve dosya adını gösteriyor.
+    #[test]
+    fn wait_notice_hidden_while_copying() {
+        assert!(
+            !show_wait_notice(true, true),
+            "kopyalama sırasında uyarı gösterilmemeli"
+        );
+    }
+
+    /// Çubuk olmayan adımlarda (fstab, GRUB, temizlik) uyarı kalmalı —
+    /// orada kullanıcının beklemesi gerektiğini bilmesi doğru.
+    #[test]
+    fn wait_notice_shown_after_copy_finishes() {
+        assert!(
+            show_wait_notice(true, false),
+            "kopyalama bitince uyarı geri gelmeli"
+        );
+    }
+
+    /// Kurulum başlamadan / bitince uyarı olmaz.
+    #[test]
+    fn wait_notice_absent_when_not_running() {
+        assert!(!show_wait_notice(false, false), "çalışmıyorken uyarı olmamalı");
+        assert!(!show_wait_notice(false, true), "çalışmıyorken uyarı olmamalı");
+    }
+}

src/steps/finish.rs

@@ -53,5 +53,9 @@ impl InstallerStep for FinishStep {
         });
     }
 
+    fn role(&self) -> crate::installer::StepRole {
+        crate::installer::StepRole::Finish
+    }
+
     fn is_complete(&self, _state: &GlobalState) -> bool { true }
 }

src/steps/license.rs

@@ -47,6 +47,9 @@ impl InstallerStep for LicenseStep {
     }
 
     fn is_complete(&self, state: &GlobalState) -> bool {
-        state.license_accepted
+        // Demo modu gerçek kurulum yapmadığı için kabul zorunlu değil;
+        // demo gezintisinin tıklanmadan ilerleyebilmesi gerekir
+        // (README'deki "--demo ... arayüz testi" amacı).
+        state.license_accepted || state.demo_mode
     }
 }

src/steps/location.rs

@@ -97,6 +97,31 @@ impl Default for LocationStep {
 }
 
 impl LocationStep {
+    /// Ülke kodundan dil koduna çevirir.
+    ///
+    /// YALIDIR: yalnızca `locales/` altında GERÇEKTEN bulunan diller
+    /// döndürür. Daha önce 8 ülke eşleniyordu (de/fr/it/es/ru/nl/pl) ama
+    /// projede yalnızca tr.toml ve en.toml var. `set_locale("de")`
+    /// çağrıldığında rust-i18n sessizce anahtarın kendisini döndürür —
+    /// yani Alman kullanıcı "location_title", "next", "partition" gibi
+    /// çıplak anahtarlarla dolu bir arayüz görüyordu.
+    fn language_for_country(country: &str) -> Option<&'static str> {
+        match country {
+            "TR" => Some("tr"),
+            // AB'nin İngilizce konuşulan bölümleri ve İngilizce resmî
+            // dili olan ülkeler. Bunlar en.toml'a düşer.
+            //
+            // Not: Güney Afrika (ZA) bilinçli olarak listede değil — 11
+            // resmî dili var ve İngilizce baskın değil. Benzer durumdaki
+            // ülkeler de (Kanada, İsviçre) yalnızca İngilizce resmî dile
+            // sahip oldukları için listede.
+            "GB" | "IE" | "MT" | "US" | "CA" | "AU" | "NZ" | "IN" | "SG" |
+            "NG" | "KE" | "GH" | "HK" | "JM" | "BS" | "BB" |
+            "BZ" | "GY" | "TT" | "BW" | "ZW" | "ZM" | "FJI" => Some("en"),
+            _ => None,
+        }
+    }
+
     fn geoip_lookup(state: &mut GlobalState) {
         let out = std::process::Command::new("curl")
             .args(["-s", "--connect-timeout", "3", "http://ip-api.com/json"])
@@ -111,16 +136,10 @@ impl LocationStep {
                     })
                 };
                 if let Some(country) = extract("countryCode") {
-                    match country.as_str() {
-                        "TR" => state.language = "tr".to_string(),
-                        "DE" => state.language = "de".to_string(),
-                        "FR" => state.language = "fr".to_string(),
-                        "IT" => state.language = "it".to_string(),
-                        "ES" => state.language = "es".to_string(),
-                        "RU" => state.language = "ru".to_string(),
-                        "NL" => state.language = "nl".to_string(),
-                        "PL" => state.language = "pl".to_string(),
-                        _ => {}
+                    // Mevcut locale dosyası olmayan bir dile geçilmezse
+                    // kullanıcının seçtiği dil korunur.
+                    if let Some(lang) = Self::language_for_country(&country) {
+                        state.language = lang.to_string();
                     }
                 }
                 if let Some(tz) = extract("timezone") {
@@ -347,3 +366,54 @@ impl InstallerStep for LocationStep {
         !state.timezone.is_empty()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn geoip_only_maps_to_locales_that_exist() {
+        // Regresyon: de/fr/it/es/ru/nl/pl eşleniyordu ama locales/ altında
+        // yalnızca tr.toml ve en.toml var. set_locale("de") sessizce
+        // kabul edildiği için Alman kullanıcı tüm arayüzü çıplak
+        // anahtar olarak görüyordu.
+        for code in ["DE", "FR", "IT", "ES", "RU", "NL", "PL"] {
+            let mapped = LocationStep::language_for_country(code);
+            if let Some(lang) = mapped {
+                assert!(
+                    crate::funct::AVAILABLE_LANGUAGES.contains(&lang),
+                    "{} -> {} eşlendi ama {} locale dosyası yok",
+                    code, lang, lang
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn turkey_maps_to_turkish() {
+        assert_eq!(LocationStep::language_for_country("TR"), Some("tr"));
+    }
+
+    #[test]
+    fn english_speaking_countries_map_to_english() {
+        for code in ["GB", "US", "IE", "AU", "CA", "NZ", "IN"] {
+            assert_eq!(
+                LocationStep::language_for_country(code),
+                Some("en"),
+                "{} İngilizce'ye eşlenmeli", code
+            );
+        }
+    }
+
+    #[test]
+    fn unknown_countries_leave_language_alone() {
+        // Eşleme yok → None → kullanıcının seçtiği dil korunur.
+        for code in ["JP", "CN", "BR", "ZA", "XX", ""] {
+            assert_eq!(
+                LocationStep::language_for_country(code),
+                None,
+                "{} eşlenmemeli", code
+            );
+        }
+    }
+}

src/steps/mod.rs

@@ -1,3 +1,17 @@
+//! Sihirbaz adımları.
+//!
+//! ## Aktif akış
+//!
+//! YALI, **KURULU SİSTEMİ squashfs'ten diske kopyalar** (`jobs::CopyFilesJob`
+//! rsync). Bunun temel sonucu: ISO'da hangi paketler, ekran yöneticisi ve
+//! masaüstü ortamı varsa, kurulum onları ZATEN içerir. Bu yüzden sihirbaz
+//! paket seçimi, ekran yöneticisi seçimi veya lisans kabulü sunmaz —
+//! sunduğu ayarları kopyalama zaten ezdiği için yanıltıcı olurdu.
+//!
+//! Aktif sıra (`main.rs::YaliApp::default`):
+//! Welcome → Location → Keyboard → Network → Partition → Users →
+//! Bootloader → Summary → Execution → Finish
+
 pub mod keyboard;
 pub mod users;
 pub mod summary;
@@ -7,8 +21,6 @@ pub mod partition;
 pub mod bootloader;
 pub mod network;
 pub mod rescue;
-//pub mod display_manager;
-pub mod netinstall;
 pub mod location;
 
 pub use keyboard::KeyboardStep;
@@ -21,3 +33,43 @@ pub use bootloader::BootloaderStep;
 pub use network::NetworkStep;
 pub use rescue::RescueStep;
 pub use location::LocationStep;
+
+// ─────────────────────────────────────────────
+// DORMANT ADIMLAR — squashfs akışının parçası DEĞİL
+//
+// Derleniyorlar ve hazırlar, ama sihirbaza BAĞLI DEĞİLLER. main.rs'deki
+// `steps` vektörüne eklenmedikleri için kullanıcıya hiç gösterilmezler.
+// Eklenmeleri gerektiğinde tek satır yeterlidir: `InstallerStep::role()`
+// varsayılan `Normal` döndüğü için konumsal bir güncelleme gerekmez.
+//
+// NOT — `#[allow(dead_code)]` yalnızca bu üç modüle, yalnızca aşağıdaki
+// kasıtlı uyku için konmuştur. 22de7d5 bu gerekçeyi vermeden genel
+// `#[allow(dead_code)]` serpiştirmiş ve 1804 satırlık bir silmeyi
+// "dead code temizliği" diye gizlemişti. Buradaki izin yalnızca bu
+// modüllere ve yalnızca aşağıdaki nedenle sınırlıdır; modül dışında
+// taze bir ölü kod yine uyarı üretir.
+// ─────────────────────────────────────────────
+
+/// Ekran yöneticisi / masaüstü ortamı seçimi.
+/// ISO'nun ekran yöneticisi squashfs'ten geldiği için seçim anlamsız —
+/// seçilen değer `ConfigureAutologinJob` tarafından ISO'dakini ezerdi.
+/// Etkinleştirmek için: main.rs'de Users ile Bootloader arasına
+/// `steps::display_manager::DisplayManagerStep` ekle.
+#[allow(dead_code)]
+pub mod display_manager;
+
+/// Ağdan ek paket kurma (netinstall).
+/// Squashfs kurulumuyla çelişir: paketler zaten görüntüde. Netinstall
+/// ayrı bir proje olarak başlatıldığında bu adım `main.rs`'de
+/// Bootloader ile Summary arasına
+/// `steps::netinstall::NetinstallStep` olarak eklenmeli,
+/// `JobQueueConfig::selected_package_groups` doldurulmalı ve
+/// `InstallExtraPackagesJob` kuyruğa alınmalı. `src/jobs/netinstall.rs`
+/// bu iş için hazır.
+#[allow(dead_code)]
+pub mod netinstall;
+
+/// GPL lisans metni ve kabul onayı.
+/// Bu kurulum akışında lisans kabulü bir koşul değil.
+#[allow(dead_code)]
+pub mod license;

src/steps/netinstall.rs

@@ -14,7 +14,6 @@ pub const PACKAGE_GROUPS: &[(&str, &str, &[&str])] = &[
 ];
 
 #[derive(Default)]
-#[allow(dead_code)]
 pub struct NetinstallStep;
 
 impl InstallerStep for NetinstallStep {

src/steps/network.rs

@@ -9,6 +9,9 @@ pub struct NetworkStep {
     scanning: bool,
     scan_done: bool,
     proxy_enabled: bool,
+    /// `nmcli dev status` çıktısı. Adıma girişte bir kez okunur —
+    /// show() içinde okunursa her karede alt süreç doğar.
+    status_text: Option<String>,
 }
 
 #[derive(Clone, Default)]
@@ -66,6 +69,15 @@ impl NetworkStep {
             Err(String::from_utf8_lossy(&out.stderr).trim().to_string())
         }
     }
+    /// `nmcli dev status` çıktısını tazeler. Adıma girişte ve Wi-Fi
+    /// bağlantı denemelerinden sonra çağrılır.
+    fn refresh_status(&mut self) {
+        self.status_text = std::process::Command::new("nmcli")
+            .args(["-t", "-f", "DEVICE,TYPE,STATE,CONNECTION", "dev", "status"])
+            .output()
+            .ok()
+            .map(|out| String::from_utf8_lossy(&out.stdout).into_owned());
+    }
 }
 
 impl InstallerStep for NetworkStep {
@@ -73,28 +85,41 @@ impl InstallerStep for NetworkStep {
         t!("network").to_string()
     }
 
+    fn on_enter(&mut self, _state: &mut GlobalState) {
+        self.refresh_status();
+    }
+
     fn show(&mut self, ui: &mut egui::Ui, state: &mut GlobalState) {
         ui.heading(t!("network_title"));
         ui.label(t!("network_description"));
         ui.add_space(12.0);
 
         // Mevcut bağlantı durumu
-        if let Ok(out) = std::process::Command::new("nmcli")
-            .args(["-t", "-f", "DEVICE,TYPE,STATE,CONNECTION", "dev", "status"])
-            .output()
-        {
-            let text = String::from_utf8_lossy(&out.stdout);
-            let connected: Vec<&str> = text.lines()
-                .filter(|l| l.contains(":connected:") || l.contains(":connecting:"))
-                .collect();
-            if !connected.is_empty() {
+        //
+        // `nmcli dev status` bir alt süreçtir ve ~50-100 ms sürer. Burada
+        // show() içinde, yani saniyede ~60 kez çağrılıyordu. Durum
+        // adımlara girişte bir kez okunur; bağlantı değişikliği
+        // `scan_wifi`/`connect` sonrası elle tazelenir.
+        match &self.status_text {
+            Some(text) => {
+                let connected: Vec<&str> = text.lines()
+                    .filter(|l| l.contains(":connected:") || l.contains(":connecting:"))
+                    .collect();
+                if !connected.is_empty() {
+                    ui.colored_label(
+                        egui::Color32::from_rgb(80, 170, 80),
+                        format!("{} {}", t!("network_connected"), connected.join(", ")),
+                    );
+                } else {
+                    ui.colored_label(
+                        egui::Color32::from_rgb(200, 140, 40),
+                        t!("network_disconnected"),
+                    );
+                }
+            }
+            None => {
                 ui.colored_label(
-                    egui::Color32::from_rgb(80, 170, 80),
-                    format!("{} {}", t!("network_connected"), connected.join(", ")),
-                );
-            } else {
-                ui.colored_label(
-                    egui::Color32::from_rgb(200, 140, 40),
+                    egui::Color32::from_rgb(120, 120, 140),
                     t!("network_disconnected"),
                 );
             }
@@ -128,6 +153,7 @@ impl InstallerStep for NetworkStep {
         if !self.scan_done {
             if ui.add(egui::Button::new(t!("network_scan"))).clicked() {
                 self.scan_wifi();
+                self.refresh_status();
             }
         } else {
             ui.horizontal(|ui| {
@@ -185,6 +211,9 @@ impl InstallerStep for NetworkStep {
                                                     Ok(msg) => {
                                                         state.install_log.push(format!("Wi-Fi: {} — {}", net.ssid, msg));
                                                         self.scan_done = false;
+                                                        // Bağlantı durumu değişti; üstteki
+                                                        // "bağlı/bağlı değil" satırı tazelensin.
+                                                        self.refresh_status();
                                                     }
                                                     Err(e) => {
                                                         state.install_log.push(format!("Wi-Fi error: {}", e));

src/steps/rescue.rs

@@ -126,11 +126,20 @@ impl RescueStep {
                 let op: u32 = op_str.parse().unwrap_or(0);
 
                 // Tarih: "[2024-03-15 12:00:01]"
-                let date = if let Some(start) = remainder.find('[') {
-                    if let Some(end) = remainder.find(']') {
-                        remainder[start+1..end].to_string()
-                    } else { String::new() }
-                } else { String::new() };
+                // `]` ve `[` bağımsız aranırsa, `]` önce gelen bir girdide
+                // `end < start` olur ve `remainder[start+1..end]` PANİK verir
+                // ("slice index starts at N but ends at M"). Kapanış
+                // parantez, açılıştan SONRA aranmalı.
+                let date = match remainder.find('[') {
+                    None => String::new(),
+                    Some(open) => {
+                        let inner = open + 1;
+                        match remainder[inner..].find(']') {
+                            Some(rel_close) => remainder[inner..inner + rel_close].to_string(),
+                            None => String::new(),
+                        }
+                    }
+                };
 
                 // Tür + özet: ": install [vim, curl]"
                 let (op_type, summary) = if let Some(colon) = remainder.rfind("]: ") {
@@ -372,11 +381,16 @@ impl RescueStep {
                             ui.colored_label(type_color, &entry.op_type);
 
                             // Özet — truncate
-                            let summary = if entry.summary.len() > 50 {
-                                format!("{}…", &entry.summary[..50])
-                            } else {
-                                entry.summary.clone()
-                            };
+                            // `len()` bayt sayar, `&s[..50]` ise bayt
+                            // sınırı ister. `pisi history` çıktısı paket
+                            // adlarından gelir ve Türkçe karakter içerir
+                            // ("İ", "ş", "ğ" 2 bayt): `[..50]` karakter
+                            // sınırının ortasına denk gelirse PANİK.
+                            // Karakter sayarak kırpmak gerekir.
+                            let mut summary: String = entry.summary.chars().take(50).collect();
+                            if entry.summary.chars().count() > 50 {
+                                summary.push('…');
+                            }
                             ui.label(egui::RichText::new(summary).size(11.0).color(theme::c_text_dim()));
                             ui.end_row();
                         }
@@ -510,3 +524,65 @@ impl InstallerStep for RescueStep {
         false // Rescue modu her zaman "tamamlanmamış" — normal kuruluma dönmek için rescue_mode=false
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Özet kırpma: Türkçe karakterler 2 bayt olduğu için bayt tabanlı
+    /// dilimleme karakter sınırının ortasına denk gelip panik verirdi.
+    fn truncate(s: &str, max: usize) -> String {
+        let mut out: String = s.chars().take(max).collect();
+        if s.chars().count() > max {
+            out.push('…');
+        }
+        out
+    }
+
+    #[test]
+    fn truncate_handles_multibyte_without_panicking() {
+        // "şğüöç" 5 karakter × 20 = 100 karakter, 200 bayt. 50 karakterlik
+        // kesme bayt sınırının tam ortasına denk gelirdi ve `&s[..50]`
+        // PANİK verirdi.
+        let s = "şğüöç".repeat(20);
+        assert_eq!(s.chars().count(), 100);
+        let t = truncate(&s, 50);
+        assert_eq!(t.chars().count(), 51, "50 karakter + '…'");
+        assert!(t.ends_with('…'));
+        assert!(t.chars().take(50).all(|c| "şğüöç".contains(c)));
+    }
+
+    #[test]
+    fn truncate_leaves_short_strings_untouched() {
+        assert_eq!(truncate("kısa", 50), "kısa");
+        assert_eq!(truncate("", 50), "");
+    }
+
+    #[test]
+    fn parse_history_handles_stray_close_bracket() {
+        // "] Operation ..." — ']' '[' tan önce geliyor. Eski kod
+        // remainder[start+1..end] ile PANİK verirdi.
+        let out = RescueStep::parse_pisi_history("Operation 5 ] bogus: install [vim]");
+        assert_eq!(out.len(), 1, "girdi hâlâ işlenmeli");
+        assert_eq!(out[0].op, 5);
+    }
+
+    #[test]
+    fn parse_history_reads_date_and_summary() {
+        let raw = "Operation 42 [2024-03-15 12:00:01]: install [vim, curl]";
+        let out = RescueStep::parse_pisi_history(raw);
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].op, 42);
+        assert_eq!(out[0].date, "2024-03-15 12:00:01");
+        assert_eq!(out[0].op_type, "install");
+        // Özet, "]: " sonrasındaki ilk boşluktan itibaren alınır; paket
+        // listesi köşeli parantezleriyle birlikte kalır (mevcut davranış).
+        assert_eq!(out[0].summary, "[vim, curl]");
+    }
+
+    #[test]
+    fn parse_history_tolerates_unterminated_bracket() {
+        let out = RescueStep::parse_pisi_history("Operation 7 [2024-03-15 12:00:01: install [x]");
+        assert_eq!(out.len(), 1, "panik vermemeli, kayıt üretmeli");
+    }
+}

src/steps/summary.rs

@@ -43,15 +43,51 @@ impl InstallerStep for SummaryStep {
                     };
                     summary_row(ui, t!("summary_keyboard"), &kb);
 
-                    let disk_str = match &state.selected_disk {
-                        Some(d) => {
-                            if state.erase_disk {
-                                format!("{} \u{EA6B} {}", d, t!("summary_erase_mode"))
-                            } else {
-                                format!("{} \u{EA6B} {}", d, t!("summary_manual_mode"))
+                    let disk_str = if state.erase_disk {
+                        match &state.selected_disk {
+                            Some(d) => format!("{} \u{EA6B} {}", d, t!("summary_erase_mode")),
+                            None => t!("summary_not_selected").to_string(),
+                        }
+                    } else if !state.custom_partitions.is_empty() {
+                        // Manuel modda tanım yapılan TÜM diskleri listele.
+                        // KÖKün olduğu disk işaretlenir: GRUB varsayılanı
+                        // ona kurulur ve kullanıcı hangi diske önyükleyici
+                        // yazılacağını buradan görebilmeli.
+                        let mut disks: Vec<&str> = Vec::new();
+                        for part in &state.custom_partitions {
+                            if !disks.contains(&part.disk.as_str()) {
+                                disks.push(&part.disk);
                             }
                         }
-                        None => t!("summary_not_selected").to_string(),
+                        let root_disk = state
+                            .custom_partitions
+                            .iter()
+                            .find(|p| p.mountpoint == "/" && !p.delete)
+                            .map(|p| p.disk.as_str());
+                        let listed: Vec<String> = disks
+                            .iter()
+                            .copied()
+                            .map(|d| {
+                                if Some(d) == root_disk {
+                                    // ⭐ gibi bir emoji kullanılmıyor:
+                                    // setup_fonts yalnızca sistem +
+                                    // remixicon yüklüyor, renkli emoji
+                                    // fontu yorum satırında — kutu (tofu)
+                                    // çıkar. Düz metin işaret hem her
+                                    // fontta var hem de çeviriyle uyumlu.
+                                    format!("{} [{}]", d, t!("summary_root_disk_tag"))
+                                } else {
+                                    d.to_string()
+                                }
+                            })
+                            .collect();
+                        format!("{} \u{EA6B} {}",
+                            listed.join(", "), t!("summary_manual_mode"))
+                    } else {
+                        match &state.selected_disk {
+                            Some(d) => format!("{} \u{EA6B} {}", d, t!("summary_manual_mode")),
+                            None => t!("summary_not_selected").to_string(),
+                        }
                     };
                     summary_row(ui, t!("summary_disk"), &disk_str);
 
@@ -73,15 +109,72 @@ impl InstallerStep for SummaryStep {
                         }
                     } else if !state.custom_partitions.is_empty() {
                         let mut plan_lines = Vec::new();
+                        // Bölümleri ait oldukları diske göre gruplu listele
+                        let mut seen_disks: Vec<&str> = Vec::new();
                         for part in &state.custom_partitions {
-                            let size_str = if part.size_mb == 0 {
-                                t!("mp_size_remaining").to_string()
-                            } else if part.size_mb >= 1024 {
-                                format!("{:.1} GB", part.size_mb as f64 / 1024.0)
+                            if !seen_disks.contains(&part.disk.as_str()) {
+                                seen_disks.push(&part.disk);
+                            }
+                        }
+                        for d in seen_disks {
+                            // Disk başlığı + kapasite. Çoklu disk
+                            // kurulumunda kullanıcının hangi bölümün
+                            // hangi diskte olduğunu tek ekranda görmesi
+                            // gerekiyor; yalnızca "/dev/sdb" yazması
+                            // yetersiz.
+                            let cap_mb = state.available_disks.iter()
+                                .find(|dk| dk.name == d)
+                                .map(|dk| dk.size_bytes / 1_048_576)
+                                .unwrap_or(0);
+                            let used_mb: u64 = state.custom_partitions.iter()
+                                .filter(|p| p.disk == d && !p.delete)
+                                .map(|p| p.size_mb)
+                                .sum();
+                            let hdr = if cap_mb >= 1024 {
+                                format!("\u{EDFB} {}  ({:.0} GB)", d, cap_mb as f64 / 1024.0)
                             } else {
-                                format!("{} MB", part.size_mb)
+                                format!("\u{EDFB} {}  ({} MB)", d, cap_mb)
                             };
-                            plan_lines.push(format!("{}  \u{EA6B}  {}  ({}, {})", part.device, part.mountpoint, part.fstype, size_str));
+                            plan_lines.push(hdr);
+                            for part in state.custom_partitions.iter().filter(|p| p.disk == d) {
+                                let size_str = if part.size_mb == 0 {
+                                    // Sembolik boyut: kalan kapasiteyi göster
+                                    let others: u64 = state.custom_partitions.iter()
+                                        .filter(|q| q.disk == part.disk && !q.delete && q.size_mb > 0)
+                                        .map(|q| q.size_mb)
+                                        .sum();
+                                    let cap = state.available_disks.iter()
+                                        .find(|dk| dk.name == part.disk)
+                                        .map(|dk| dk.size_bytes / 1_048_576)
+                                        .unwrap_or(0);
+                                    let rem = cap.saturating_sub(others);
+                                    if rem >= 1024 {
+                                        format!("{:.1} GB", rem as f64 / 1024.0)
+                                    } else {
+                                        format!("{} MB", rem)
+                                    }
+                                } else if part.size_mb >= 1024 {
+                                    format!("{:.1} GB", part.size_mb as f64 / 1024.0)
+                                } else {
+                                    format!("{} MB", part.size_mb)
+                                };
+                                if part.delete {
+                                    plan_lines.push(format!("{}  \u{EA6B}  {}  ({}, {}) \u{ECA1} {}",
+                                        part.device, "—", "—", size_str, t!("mp_will_delete")));
+                                } else {
+                                    plan_lines.push(format!("{}  \u{EA6B}  {}  ({}, {})",
+                                        part.device, part.mountpoint, part.fstype, size_str));
+                                }
+                            }
+                            // Diskin kullanılmayan boş alanı
+                            let free_mb = cap_mb.saturating_sub(used_mb);
+                            if free_mb > 0 {
+                                if free_mb >= 1024 {
+                                    plan_lines.push(format!("   — boş: {:.1} GB", free_mb as f64 / 1024.0));
+                                } else {
+                                    plan_lines.push(format!("   — boş: {} MB", free_mb));
+                                }
+                            }
                         }
                         summary_row(ui, t!("summary_custom_partitions"), &plan_lines.join("\n"));
                     }
@@ -97,18 +190,30 @@ impl InstallerStep for SummaryStep {
                     summary_row(ui, t!("summary_datetime"), &dt_str);
 
                     // Bootloader
-                    let bl_str = format!("{} ({}s timeout{})",
-                        state.bootloader_device,
-                        state.bootloader_timeout,
-                        if state.bootloader_password.is_empty() { "" } else { ", password protected" }
+                    let pw_suffix = if state.bootloader_password.is_empty() {
+                        String::new()
+                    } else {
+                        format!(", {}", t!("summary_bootloader_password"))
+                    };
+                    let bl_str = format!(
+                        "{} ({}s timeout{})",
+                        state.bootloader_device, state.bootloader_timeout, pw_suffix
                     );
                     summary_row(ui, t!("summary_bootloader"), &bl_str);
 
-                    // Display Manager
-                    let dm_str = format!("{} / {} ({})",
-                        state.display_manager,
-                        state.desktop_environment,
-                        if state.autologin { t!("summary_autologin") } else { std::borrow::Cow::Borrowed("manual login") }
+                    // Oturum yöneticisi ve masaüstü ortamı
+                    //
+                    // Kullanıcı bunları SEÇEMEZ: sistem squashfs'ten
+                    // kopyalandığı için ISO'nun kendi DM'i gelir ve
+                    // ConfigureAutologinJob kurulum anında tespit eder.
+                    // `state.display_manager` GlobalState'in sabit "sddm"
+                    // varsayılanıdır; burada göstermek yanlış bilgi olurdu.
+                    // Gösterilebilen tek şey, kullanıcının belirlediği
+                    // otomatik giriş tercihi.
+                    let dm_str = format!(
+                        "{} — {}",
+                        if state.autologin { t!("summary_autologin_on") } else { t!("summary_autologin_off") },
+                        t!("summary_desktop_from_image")
                     );
                     summary_row(ui, t!("summary_display_manager"), &dm_str);
 

src/steps/users.rs

@@ -66,7 +66,10 @@ fn derive_username(real_name: &str) -> String {
 /// Hata varsa hata mesajını döndürür, yoksa None döndürür.
 fn validate_username(s: &str) -> Option<String> {
     if s.is_empty() {
-        return None;
+        // Boş kullanıcı adı GEÇERLİ DEĞİLDİR. Daha önce burada `None`
+        // (hata yok) dönüyordu, bu yüzden geçerli bir hostname ile boş
+        // kullanıcı adı sihirbazı geçip `useradd ""` çalıştırıyordu.
+        return Some(t!("username_empty").to_string());
     }
     if s.len() > 32 {
         return Some(t!("username_too_long").to_string());
@@ -425,3 +428,83 @@ impl InstallerStep for UsersStep {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_username_is_rejected() {
+        // Regresyon: validate_username("") None (hata yok) dönüyordu, bu
+        // yüzden geçerli bir hostname ile boş kullanıcı adı sihirbazı
+        // geçip CreateUserJob'a ulaşıyordu.
+        assert!(
+            validate_username("").is_some(),
+            "boş kullanıcı adı hata dönmeli"
+        );
+        assert!(!is_valid_username(""), "boş kullanıcı adı geçerli olmamalı");
+    }
+
+    #[test]
+    fn valid_usernames_pass() {
+        for name in ["user", "ahmet", "a", "_root_", "user-1", "u_2026"] {
+            assert!(
+                validate_username(name).is_none(),
+                "{} geçerli olmalı", name
+            );
+        }
+    }
+
+    #[test]
+    fn system_usernames_are_forbidden() {
+        for name in ["root", "daemon", "nobody", "sshd", "www-data"] {
+            assert!(
+                validate_username(name).is_some(),
+                "{} yasaklı olmalı", name
+            );
+        }
+    }
+
+    #[test]
+    fn username_start_and_charset_rules() {
+        assert!(validate_username("1user").is_some(), "rakamla başlayamaz");
+        assert!(validate_username("Auser").is_some(), "büyük harfle başlayamaz");
+        assert!(validate_username("user name").is_some(), "boşluk olmaz");
+        assert!(validate_username(&"a".repeat(33)).is_some(), "32'den uzun olmaz");
+        assert!(validate_username(&"a".repeat(32)).is_none(), "32 kabul edilir");
+    }
+
+    #[test]
+    fn hostname_rules() {
+        assert!(is_valid_hostname("pisi-pc"));
+        assert!(is_valid_hostname("Pisi1"));
+        assert!(!is_valid_hostname(""), "boş olmaz");
+        assert!(!is_valid_hostname("-pisi"), "tire ile başlayamaz");
+        assert!(!is_valid_hostname("pisi-"), "tire ile bitemez");
+        assert!(!is_valid_hostname("pisi pc"), "boşluk olmaz");
+        assert!(!is_valid_hostname("pisi_pc"), "alt çizgi olmaz");
+        assert!(!is_valid_hostname(&"a".repeat(64)), "63'ten uzun olmaz");
+        assert!(is_valid_hostname(&"a".repeat(63)), "63 kabul edilir");
+    }
+
+    #[test]
+    fn derive_username_transliterates_turkish() {
+        assert_eq!(derive_username("Şükrü Çelik"), "sukru-celik");
+        assert_eq!(derive_username("Çağrı"), "cagri");
+        assert_eq!(derive_username("İpek"), "ipek");
+    }
+
+    #[test]
+    fn derive_username_never_returns_empty() {
+        // Yalnızca geçersiz karakterlerden oluşan isimde boş dönmemeli.
+        assert_eq!(derive_username("!!!"), "user");
+        assert_eq!(derive_username("   "), "user");
+        assert_eq!(derive_username(""), "user");
+    }
+
+    #[test]
+    fn derive_username_caps_length() {
+        let long = "a".repeat(50);
+        assert_eq!(derive_username(&long).len(), 32);
+    }
+}

src/ui/theme.rs

@@ -52,6 +52,7 @@ pub fn c_sidebar_text() -> Color32 { color_from_hex(SIDEBAR_TEXT.load(Ordering::
 pub fn c_footer_bg() -> Color32 { color_from_hex(BG_FOOTER.load(Ordering::Relaxed)) }
 pub fn c_root_bg() -> Color32 { color_from_hex(BG_ROOT.load(Ordering::Relaxed)) }
 pub fn c_keyboard_bg() -> Color32 { color_from_hex(KEYBOARD_BG.load(Ordering::Relaxed)) }
+pub fn select_disk_label() -> Color32 { color_from_hex(0xFFFFFF) }
 
 pub fn set_theme_mode(is_dark: bool) {
     if is_dark {
@@ -108,10 +109,85 @@ pub fn apply(ctx: &egui::Context, is_dark: bool) {
     ctx.set_visuals(build_visuals(is_dark));
 }
 
+// fn setup_fonts(ctx: &egui::Context) {
+//     let mut fonts = egui::FontDefinitions::default();
+
+//     // 1. ADIM: Sadece Metin (Text) Fontunu Bul ve Yükle
+//     let text_font_paths = [
+//         "/usr/share/fonts/TTF/OpenSans-Regular.ttf",
+//         "/usr/share/fonts/noto/NotoSans-Regular.ttf",
+//         "/usr/share/fonts/exo-1/Exo-Regular.otf",
+//         "/usr/share/fonts/exo-1/Exo2-Medium.ttf",
+//         "/usr/share/fonts/exo-1/Exo-Medium.otf",
+//     ];
+
+//     for path in text_font_paths {
+//         if let Ok(data) = std::fs::read(path) {
+//             fonts.font_data.insert(
+//                 "system_text_font".to_owned(),
+//                 egui::FontData::from_owned(data),
+//             );
+            
+//             // Metin fontunu en başa (0. indeks) koyuyoruz ki varsayılan olarak bu kullanılsın
+//             fonts
+//                 .families
+//                 .entry(egui::FontFamily::Proportional)
+//                 .or_default()
+//                 .insert(0, "system_text_font".to_owned());
+//             break;
+//         }
+//     }
+
+//     // 2. ADIM: Renkli Emoji Fontunu Ara ve "Fallback" (Yedek) Olarak Sona Ekle
+//     // ISO ortamlarında Noto Color Emoji genellikle bu yollardan birinde olur
+//     let emoji_font_paths = [
+//         "/usr/share/fonts/noto/NotoColorEmoji.ttf",
+//     ];
+
+//     for path in emoji_font_paths {
+//         if let Ok(data) = std::fs::read(path) {
+//             fonts.font_data.insert(
+//                 "system_emoji_font".to_owned(),
+//                 egui::FontData::from_owned(data),
+//             );
+
+//             // ÖNEMLİ: Emojiyi listenin SONUNA (push ile) ekliyoruz.
+//             // Böylece egui normal harfleri sistem fontuyla yazacak, 
+//             // harf sistem fontunda yoksa (yani emojiyse) gidip bu fonttan alacak.
+//             fonts
+//                 .families
+//                 .entry(egui::FontFamily::Proportional)
+//                 .or_default()
+//                 .push("system_emoji_font".to_owned());
+                
+//             fonts
+//                 .families
+//                 .entry(egui::FontFamily::Monospace)
+//                 .or_default()
+//                 .insert(0, "system_emoji_font".to_owned());
+//             break;
+//         }
+//     }
+
+//     // 3. ADIM: Remixicon ikon fontunu projeye göm (PUA bölgesindeki karakterler için fallback)
+//     let remixicon_data = include_bytes!("../../assets/remixicon.ttf");
+//     fonts.font_data.insert(
+//         "remixicon".to_owned(),
+//         egui::FontData::from_owned(remixicon_data.to_vec()),
+//     );
+//     fonts
+//         .families
+//         .entry(egui::FontFamily::Proportional)
+//         .or_default()
+//         .push("remixicon".to_owned());
+
+//     ctx.set_fonts(fonts);
+// }
+
 fn setup_fonts(ctx: &egui::Context) {
     let mut fonts = egui::FontDefinitions::default();
 
-    // 1. ADIM: Sadece Metin (Text) Fontunu Bul ve Yükle
+    // 1. ADIM: Metin ve Monospace için Sistem Fontu Yükleme
     let text_font_paths = [
         "/usr/share/fonts/TTF/OpenSans-Regular.ttf",
         "/usr/share/fonts/noto/NotoSans-Regular.ttf",
@@ -120,25 +196,59 @@ fn setup_fonts(ctx: &egui::Context) {
         "/usr/share/fonts/exo-1/Exo-Medium.otf",
     ];
 
+    let mut _text_font_loaded = false;
+
     for path in text_font_paths {
         if let Ok(data) = std::fs::read(path) {
             fonts.font_data.insert(
                 "system_text_font".to_owned(),
-                egui::FontData::from_owned(data),
+                egui::FontData::from_owned(data).into(), // Sürüme göre .into() veya std::sync::Arc::new(...)
             );
-            
-            // Metin fontunu en başa (0. indeks) koyuyoruz ki varsayılan olarak bu kullanılsın
+
+            // Proportional (Orantılı) fontun başına ekle
             fonts
                 .families
                 .entry(egui::FontFamily::Proportional)
                 .or_default()
                 .insert(0, "system_text_font".to_owned());
+
+            // Monospace için de bu fontu varsayılan olarak ekle (özel bir monospace bulunamadıysa)
+            fonts
+                .families
+                .entry(egui::FontFamily::Monospace)
+                .or_default()
+                .insert(0, "system_text_font".to_owned());
+
+            _text_font_loaded = true;
             break;
         }
     }
 
-    // 2. ADIM: Renkli Emoji Fontunu Ara ve "Fallback" (Yedek) Olarak Sona Ekle
-    // ISO ortamlarında Noto Color Emoji genellikle bu yollardan birinde olur
+    // Ek Güvence: Özel bir Monospace fontu varsa öncelikli olarak onu ara
+    let mono_font_paths = [
+        "/usr/share/fonts/TTF/Hack-Regular.ttf",
+        "/usr/share/fonts/TTF/DejaVuSansMono.ttf",
+        "/usr/share/fonts/noto/NotoSansMono-Regular.ttf",
+    ];
+
+    for path in mono_font_paths {
+        if let Ok(data) = std::fs::read(path) {
+            fonts.font_data.insert(
+                "system_mono_font".to_owned(),
+                egui::FontData::from_owned(data).into(),
+            );
+
+            // Monospace ailesinin 0. indeksine yerleştir
+            fonts
+                .families
+                .entry(egui::FontFamily::Monospace)
+                .or_default()
+                .insert(0, "system_mono_font".to_owned());
+            break;
+        }
+    }
+
+    // 2. ADIM: Color Emoji Fontunu Yedek (Fallback) Olarak EKLE
     let emoji_font_paths = [
         "/usr/share/fonts/noto/NotoColorEmoji.ttf",
     ];
@@ -147,39 +257,44 @@ fn setup_fonts(ctx: &egui::Context) {
         if let Ok(data) = std::fs::read(path) {
             fonts.font_data.insert(
                 "system_emoji_font".to_owned(),
-                egui::FontData::from_owned(data),
+                egui::FontData::from_owned(data).into(),
             );
 
-            // ÖNEMLİ: Emojiyi listenin SONUNA (push ile) ekliyoruz.
-            // Böylece egui normal harfleri sistem fontuyla yazacak, 
-            // harf sistem fontunda yoksa (yani emojiyse) gidip bu fonttan alacak.
+            // Her iki aileye de SONA (push) ekle, böylece metinler bozulmaz
             fonts
                 .families
                 .entry(egui::FontFamily::Proportional)
                 .or_default()
                 .push("system_emoji_font".to_owned());
-                
+
             fonts
                 .families
                 .entry(egui::FontFamily::Monospace)
                 .or_default()
-                .insert(0, "system_emoji_font".to_owned());
+                .push("system_emoji_font".to_owned()); // insert(0, ...) yerine push yapıldı!
             break;
         }
     }
 
-    // 3. ADIM: Remixicon ikon fontunu projeye göm (PUA bölgesindeki karakterler için fallback)
+    // 3. ADIM: Remixicon İkon Fontunu Göm (PUA)
     let remixicon_data = include_bytes!("../../assets/remixicon.ttf");
     fonts.font_data.insert(
         "remixicon".to_owned(),
-        egui::FontData::from_owned(remixicon_data.to_vec()),
+        egui::FontData::from_owned(remixicon_data.to_vec()).into(),
     );
+
     fonts
         .families
         .entry(egui::FontFamily::Proportional)
         .or_default()
         .push("remixicon".to_owned());
 
+    fonts
+        .families
+        .entry(egui::FontFamily::Monospace)
+        .or_default()
+        .push("remixicon".to_owned());
+
     ctx.set_fonts(fonts);
 }
 
@@ -187,7 +302,7 @@ fn setup_fonts(ctx: &egui::Context) {
 
 fn build_visuals(is_dark: bool) -> Visuals {
     let mut v = if is_dark { Visuals::dark() } else { Visuals::light() };
-
+    
     // Genel arka planlar
     v.window_fill        = c_bg_dark();
     v.panel_fill         = c_bg_panel();
@@ -243,13 +358,14 @@ fn build_visuals(is_dark: bool) -> Visuals {
 
 fn build_style() -> egui::Style {
     let mut style = egui::Style::default();
-
+    
     // Genel boşluk ve boyutlar
     style.spacing.item_spacing     = Vec2::new(8.0, 6.0);
     style.spacing.button_padding   = Vec2::new(12.0, 6.0);
     style.spacing.indent           = 16.0;
     style.spacing.scroll.bar_width = 14.0;
 
+
     // Metin boyutları
     style.text_styles = [
         (egui::TextStyle::Small,   FontId::proportional(11.0)),