# FikoYT Native MERKEZİ PARAMETRİK SİSTEM → fikatia-local (C++23/Vulkan/ImGui + OCCT) BLUEPRINT'İ

> **Amaç:** fikatia-local'e **CATIA Knowledge Advisor / Knowledgeware seviyesinde ve üstünde** bir merkezi parametrik omurga kurmak: **parametre + ifade motoru + bağıntılar (Formula/Rule/Check/Design Table) + kinematik law'lar**. Her sayısal alan (FeatureParam / CAM / sketch `Kisit.param` / PartOperasyon) f(x) formülü alabilir; tümü RecomputeMotor DAG'ında birinci-sınıf düğüm.
>
> **KURAL (kullanıcı düzeltmesi):** Web fikoyt-sistem'in parametre/knowledge sistemi **AMATÖRCE** — TABAN ALINMAZ. Yalnızca "ne yapmaya çalıştı + hangi alanlara bağlandı" anlaşılmak için incelendi. Native tasarım **ondan bağımsız, tam profesyonel**. §1 = web sistemin zayıflıkları + neden yeniden tasarlandı.
>
> **KRİTİK İLKELER (MEMORY):**
> - `fikatia-mimari-ilke-makro-plugin-olay`: Eklenen HER sistem doğduğu an **makro (Lua `fiko.parametre`) + plugin (DLL) + olay** erişilebilir. Merkezi Cekirdek registry'ye ekle → üçü bedavaya gelir. Yeni olay struct'ı `olay.hpp` enum **SONUNA**.
> - Parametreler ağacı **AYRI PENCERE DEĞİL** — ana Ürün Ağacına "Parametreler" + "Bağıntılar" düğümleri (kullanıcı kuralı).
> - `feedback_sunucu_yaklasim` değil ama `feedback_kritik_uyari`: mevcut kodu incele, kod doldurma, merkezi/OOP/minimal.
> - `main.cpp` KİLİDİ: `main.cpp` ~3762 satır, sık çakışır — dokunuş minimal, mümkünse yeni `.hpp/.cpp`'ye delege (bkz. §4, §7).
>
> **KARDEŞ BLUEPRINT'LER — TEKRAR ETME, REFERANS VER:** `docs/part_design_blueprint.md` (FeatureParam/FeatureTanim, feature yaşam döngüsü, RecomputeMotor DAG düğümü, undo Islem, per-op pencere), `docs/gsd_blueprint.md`, `docs/cam_blueprint.md` (per-op pencere + parametrik CAM felsefesi).

---

## 0. MİMARİ EŞLEME (özet — bu belge ne kuruyor)

| Katman | Native karşılığı (YENİ modül: `motor/parametre/`) | Durum |
|---|---|---|
| Birimli büyüklük tip sistemi | `fiko/parametre/buyukluk.hpp` — `Buyukluk<Boyut>` compile-time boyut kontrolü | YENİ |
| Merkezi parametre nesnesi | `Parametre : DokumanNesnesi` (görünür OLMAYAN kök) | YENİ |
| İfade motoru (recursive-descent) | `IfadeMotoru` — tokenizer + Pratt parser + AST + değerlendirici + AST cache | YENİ |
| Bağ yöneticisi (f(x) → hedef alan) | `BagYonetici` — `AlanKapisi` soyutlaması (FeatureParam/CAM/Kisit.param/PartOp) | YENİ |
| Bağıntılar (Relation) | `Formula`/`Kural`/`Kontrol`/`DesignTable` : `Bagintili : DokumanNesnesi` | YENİ |
| Parametre deposu + çözüm | `ParametreSistemi` (Cekirdek'e enjekte; DAG entegre) | YENİ |
| Feature DAG recompute | **MEVCUT** `motor/cekirdek/recompute.hpp` `RecomputeMotor` — parametre düğümleri katılır | MEVCUT |
| Olay yayını | **MEVCUT** `motor/cekirdek/olay.hpp` — `ParametreDegisti` VAR; yeni türler eklenir | MEVCUT (+genişletme) |
| Undo | **MEVCUT** `motor/cekirdek/islem.hpp` `Islem`/`KomutYigini` | MEVCUT |
| Özellikler paneli f(x) | **MEVCUT** `nesne.hpp` `Ozellik` + `main.cpp:2490` döngüsü — f(x) rozeti/kilit eklenir | MEVCUT (+genişletme) |
| Parametreler/Bağıntılar ağaç düğümü | **MEVCUT** `kayit.hpp` `AgacSaglayiciKaydi` — yeni sağlayıcı eklenir | MEVCUT (+sağlayıcı) |
| Kinematik | `motor/kinematik/` — `Joint`/`Mekanizma`/`Komut`/`Law` | YENİ (Dalga 3) |
| Lua makro API | `fiko.parametre.*` (mevcut makro motoruna kayıt) | YENİ (her dalgada) |

---

## 1. WEB SİSTEMİN ZAYIFLIKLARI + NEDEN YENİDEN TASARLANDI

İncelenen web dosyaları (fikoyt-sistem, `IFikoThreeJS/fiko-modelleme/`):
`knowledge/IFikoKnowledge.ts`, `FikoIfadeMotoru.ts` (155 sat), `FikoParametreDeposu.ts`, `FikoKnowledgeYonetici.ts`, `FikoBagimlilikGrafi.ts`, `FikoFeatureAlanHaritasi.ts`, `fiko-parametre-workbench/{fiko-parametre-workbench,fiko-fx-editor}.component.ts`; köprüler `FikoModellemeYonetici.ts` (`intrinsikSenkron` 7050, `parametreCozUygula` 7095, `parametreAgaciGuncelle` 293), `fiko-cam.yonetici.ts` (`camKnowledgeSenkron` 375).

**Ne yapmaya çalışıyor (doğru fikirler — korunacak niyet):** intrinsic feature alanlarını (`pad.param`, `hole.holeCap`, sketch ölçüleri, CAM `yanalHatve`) merkezi bir depoya "yayınla", tek bir bağımlılık grafiği ile formülleri çöz, değeri alana "write-through" geri yaz, `_sonYazilan` ile dış değişikliği ayırt et, ürün ağacında Parametreler grubu göster. Bağ noktaları (feature/ölçü/CAM alanları) doğru tespit edilmiş.

**Zayıflıklar / amatörlükler (bu yüzden taban alınmadı):**

| # | Web zayıflığı | Kanıt | Native profesyonel çözüm |
|---|---|---|---|
| Z1 | **Birim sistemi sahte** — birim salt string etiket; `mm/cm/deg` sadece tokenizer'da sayıya çarpan (`BIRIM[]`); tip ile birim ilişkisiz, boyut kontrolü YOK. `Uzunluk + Aci` toplanabilir. | `FikoIfadeMotoru.ts:11,41`; `birimEtiket()` UI'da tahmin | **Compile-time boyutlu `Buyukluk<Boyut>`** (§2.1): Length+Angle toplaması derlenmez; birim dönüşümü tipli. |
| Z2 | **DAG her çözümde SIFIRDAN kurulur** — `cozumle()` her çağrıda TÜM parametrelerin referanslarını yeniden parse eder + yeni `FikoBagimlilikGrafi` alloc eder; `tetikle()` bir kez daha kurar. O(N·formül_uzunluğu) her düzenlemede. | `FikoKnowledgeYonetici.ts:61-63, 107-109` | **AST cache + kalıcı DAG** (§2.4): parse bir kez; RecomputeMotor'un mevcut kirli-yayılımı kullanılır; yalnız etkilenen alt-ağaç. |
| Z3 | **RecomputeMotor'a bağlı DEĞİL** — kendi ayrı `FikoBagimlilikGrafi`'si var; feature DAG (rebuild zinciri) ile parametre DAG'ı AYRI iki sistem; senkron `minIdx` hack'i ile köprüleniyor (`featIndexCoz` → en erken index). | `FikoKnowledgeYonetici.ts:104-113` | **TEK DAG**: Parametre bir `DokumanNesnesi`; `bagimliliklar()` döndürür; feature+parametre aynı `RecomputeMotor`'da topolojik (§2.4, §3.4). |
| Z4 | **Formül string alan adına gömülü** — parametre adı değişince tüm formül string'leri regex ile rename ediliyor (`adDegistir`), backtick kaçış cambazlığı. Kırılgan; ad çakışması riski. | `FikoParametreDeposu.ts:24-39` | **AST kimlik-referanslı** (§2.3): formül AST'si parametre **kimliğine** (Varlik) referans; ad yalnız görüntüleme. Rename = O(1). |
| Z5 | **Bağıntı türü eksik** — yalnız Formula (`formul` alanı) + basit Check (`kontroller`) + Config snapshot var. **Rule (koşul→aksiyon) YOK, gerçek Design Table (CSV/satır seçim + filtre) YOK.** "Konfig" sadece formülsüz değer snapshot'ı. | `FikoKnowledgeYonetici.ts:31-57` | **4 birinci-sınıf bağıntı** (§2.5): Formula/Kural/Kontrol/DesignTable, hepsi `DokumanNesnesi`, ağaçta görünür, undo'lu, olay yayınlar. |
| Z6 | **Undo YOK** — `parametreGuncelle` doğrudan mutasyon; `KomutYigini` benzeri yok. Formül değişikliği geri alınamaz. | `FikoKnowledgeYonetici.ts:86-95` | Tüm mutasyon `Islem` (§2.6). Ctrl+Z formül/değer/bağ değişikliğini geri alır. |
| Z7 | **Hata konumu yok** — `FikoIfadeHata` sadece mesaj; token/karakter konumu taşımıyor. | `FikoIfadeMotoru.ts:1-3` | `IfadeHata { mesaj; konum; uzunluk }` — editörde altı-kırmızı işaretleme (§2.3). |
| Z8 | **Referans yalnız parametre adı** — ölçü/geometri referansı YOK; formül sadece adlandırılmış parametreye bakar. CATIA'da `Sketch.1\Radius.2` gibi nesne-yol referansı temel. | `FikoIfadeMotoru.ts` id çözümü flat | **Yol-referans çözücü** (§2.3): `Pad.1\Uzunluk`, `Sketch.1\Yaricap.2`, ölçü/OCCT ölçüm sonucu (`uzaklik(A,B)`, `alan(Yuz.3)`) — genişletilebilir çözücü. |
| Z9 | **Döngü tespiti kaba** — `donguVarMi()` = topo sıra uzunluğu < düğüm; hangi parametrelerin döngüde olduğunu tam işaretlemez, konum vermez. | `FikoBagimlilikGrafi.ts:28-31` | RecomputeMotor DFS-renk döngü tespiti zaten var; döngü üyeleri işaretlenir + Türkçe uyarı (§2.4, §5). |
| Z10 | **write-through kırılgan** — `_sonYazilan` sentinel ile dış/iç değişiklik ayrımı; float eşitlik karşılaştırması (`deger !== _sonYazilan`) → epsilon sorunları; kim otorite belirsiz. | `FikoParametreDeposu.ts:43-45`, `cam.yonetici:397` | **AlanKapisi** (§2.4): her alan tek yönlü kapı (oku/yaz); parametre bağlıysa alan **kilitli** (kullanıcı yazamaz) → sentinel gereksiz. |
| Z11 | Kinematik/law **YOK** — sistem tamamen statik feature parametrelerine bağlı; zaman-güdümlü komut kavramı yok. | — | `motor/kinematik/` law = parametre f(t) (§3). |

**Sonuç:** Web'in bağ-nokta haritası (hangi alanlar parametrik olmalı) referans alındı; kod mimarisi **tamamen yeniden** — boyutlu tipler, kimlik-referanslı AST, tek DAG, birinci-sınıf bağıntılar, undo, kinematik.

---

## 2. NATIVE MİMARİ — `motor/parametre/` MODÜLÜ

Dizin (kardeş modüllerle aynı düzen — `motor/parca/`, `motor/cam/`):
```
motor/parametre/
  CMakeLists.txt
  include/fiko/parametre/
    buyukluk.hpp          # boyutlu büyüklük tip sistemi (§2.1)
    parametre.hpp         # Parametre : DokumanNesnesi (§2.2)
    ifade.hpp             # AST düğümleri + IfadeHata (§2.3)
    ifade_motoru.hpp      # tokenizer + parser + değerlendirici + cache (§2.3)
    alan_kapisi.hpp       # AlanKapisi soyutlaması (§2.4)
    bagintili.hpp         # Formula/Kural/Kontrol/DesignTable (§2.5)
    parametre_sistemi.hpp # ParametreSistemi (depo + çözüm + DAG köprü) (§2.4)
    parametre_islemleri.hpp # Islem alt sınıfları (§2.6)
  src/  (aynı .cpp'ler)
  test/ (buyukluk_test, ifade_test, bagintili_test, dag_test)
```

### 2.1. Birimli büyüklük tip sistemi — `buyukluk.hpp`

CATIA'nın "magnitude" kavramı ama **derleme-anı boyut kontrolüyle** (CATIA runtime kontrol eder — bu native iyileştirme).

```cpp
namespace fiko::parametre {

// Boyut vektörü: (uzunluk, açı, kütle, zaman) üsleri. constexpr → derleme-anı.
struct Boyut { i8 uzun=0, aci=0, kutle=0, zaman=0;
  constexpr bool operator==(const Boyut&) const = default; };

// Standart boyutlar (SI iç birim: mm, radyan, kg, s).
namespace boyut {
  inline constexpr Boyut SKALER{};                 // Reel/oransız
  inline constexpr Boyut UZUNLUK{.uzun=1};
  inline constexpr Boyut ACI{.aci=1};
  inline constexpr Boyut ALAN{.uzun=2};
  inline constexpr Boyut HACIM{.uzun=3};
  inline constexpr Boyut KUTLE{.kutle=1};
  inline constexpr Boyut ZAMAN{.zaman=1};
  inline constexpr Boyut HIZ{.uzun=1,.zaman=-1};   // mm/s (ilerleme, law türevi)
}

// İç değer HER ZAMAN SI (mm/rad/kg/s). Görüntüleme birimi ayrı.
template <Boyut B>
struct Buyukluk {
  f64 si = 0.0;               // iç kanonik değer
  static constexpr Boyut boyut = B;
  // Aynı boyut toplanır/çıkarılır; farklı boyut DERLENMEZ.
  constexpr Buyukluk operator+(Buyukluk o) const { return {si + o.si}; }
  constexpr Buyukluk operator-(Buyukluk o) const { return {si - o.si}; }
  constexpr Buyukluk operator*(f64 k) const { return {si * k}; }
};
// Çarpım boyut toplar (Uzunluk*Uzunluk = Alan) — compile-time.
template <Boyut A, Boyut C>
constexpr Buyukluk<A+C> operator*(Buyukluk<A> a, Buyukluk<C> b){ return {a.si*b.si}; }
}
```
> **Not:** Derleme-anı `Buyukluk<B>` **native motor iç API'sinde** kullanılır (feature hesap kodu güven kazanır). Çalışma-anı `Parametre` (§2.2) `ParamTip` enum + `Boyut` alanı taşır (kullanıcı formülleri runtime; boyut runtime doğrulanır). İkisi ayrı — biri derleyici için, biri kullanıcı için.

**Birim tablosu** (görüntüleme ↔ SI, runtime; `Boyut`'a göre filtreli):
| Boyut | Birimler (etiket → SI çarpan) | Varsayılan gösterim |
|---|---|---|
| UZUNLUK | mm=1, cm=10, m=1000, in=25.4, ft=304.8 | mm |
| ACI | rad=1, deg=π/180, grad=π/200 | deg |
| KUTLE | kg=1, g=0.001, t=1000, lb=0.4536 | kg |
| ZAMAN | s=1, ms=0.001, min=60, h=3600 | s |
| ALAN | mm2=1, cm2=100, m2=1e6 | mm² |
| HACIM | mm3=1, cm3=1000, m3=1e9 | mm³ |
| SKALER | (birimsiz) | — |

`ParamTip` (kullanıcı-görür) → `Boyut` eşlemesi: `Uzunluk→UZUNLUK, Aci→ACI, Kutle→KUTLE, Sure→ZAMAN, Reel→SKALER, Tamsayi→SKALER(int), Boolean→(mantıksal), Metin→(metin)`.

### 2.2. `Parametre : DokumanNesnesi` — `parametre.hpp`

Görünür OLMAYAN kök (nesne.hpp kuralı: parametrenin `GorunumSaglayici`'sı YOK → "görünür değil" türden okunur). Kimlik = `Varlik` → sparse-set ECS, olaylar, undo, DAG **bedava**.

```cpp
enum class ParamTip : u8 { Uzunluk, Aci, Kutle, Sure, Reel, Tamsayi, Boolean, Metin };
enum class ParamKaynak : u8 {
  Kullanici,   // serbest — kullanıcı ekledi
  Intrinsic,   // feature/CAM/sketch alanının yayınlanmış temsili (backref dolu)
};

struct Deger {                    // etiketli birlik (variant yerine düz POD)
  f64 sayi = 0.0;                 // Uzunluk/Aci/Kutle/Sure/Reel/Tamsayi/Boolean(0-1) → SI
  std::string metin;             // Metin tipinde
};

// Intrinsic backref: parametrenin bir motor-alanına köprüsü (bkz. AlanKapisi §2.4).
struct AlanRef { u32 sahip = 0; std::string alan; };  // sahip = feature/op/sketch Varlik

class Parametre : public DokumanNesnesi {
public:
  Parametre(Varlik k, std::string ad, ParamTip tip)
    : DokumanNesnesi(k), ad_(std::move(ad)), tip_(tip) {}

  const char* turAdi() const override { return "Parametre"; }
  std::string ad() const override { return ad_; }
  void adAyarla(const std::string& a) override { ad_ = a; }   // AST kimlik-ref → rename O(1)

  // DAG kenarı: formül AST'sindeki parametre KİMLİKLERİ (ad değil — Z4).
  std::vector<Varlik> bagimliliklar() const override { return refKimlikler_; }
  // RecomputeMotor çağırır: formülü değerlendir → deger_ güncelle. (§2.4 sistem üstünden.)
  void hesapla(Dunya&, OlayGunlugu&) override;   // sistem geri-kancası ile

  OzellikSeti ozellikler(Dunya&) override;       // Özellikler paneline değer/formül/rozet

  ParamTip tip() const { return tip_; }
  Boyut boyut() const;                            // tip_ → Boyut
  const Deger& deger() const { return deger_; }
  bool formulluMu() const { return formulKok_ != nullptr; }
  const std::string& formulMetin() const { return formulMetin_; }
  ParamKaynak kaynak() const { return kaynak_; }
  const std::optional<AlanRef>& intrinsic() const { return backref_; }
  const std::string& hata() const { return hata_; }

private:
  friend class ParametreSistemi;
  std::string ad_;
  ParamTip tip_;
  Deger deger_;
  std::string birim_;                  // görüntüleme birimi (boş → boyut varsayılanı)
  std::string aciklama_;
  ParamKaynak kaynak_ = ParamKaynak::Kullanici;
  std::optional<AlanRef> backref_;     // Intrinsic ise dolu
  bool kilitli_ = false;               // salt-okunur (kullanıcı)
  Varlik grup_ = VARLIK_YOK;           // ait olduğu Parametre grubu (ağaç düzeni)
  // Formül (kimlik-referanslı AST — Z4):
  std::string formulMetin_;            // kullanıcı metni (görüntüleme + yeniden-parse)
  std::shared_ptr<Ifade> formulKok_;   // parse edilmiş AST (cache — Z2)
  std::vector<Varlik> refKimlikler_;   // AST'nin referans verdiği param kimlikleri (DAG)
  std::string hata_;                   // son çözüm hatası (Türkçe, konumlu → §2.3)
};
```

### 2.3. İfade motoru — `ifade.hpp` + `ifade_motoru.hpp`

**Profesyonel recursive-descent (Pratt/öncelik-tırmanması) parser.** Web'in tokenizer/parser yapısı FİKİR olarak makul ama kimlik-referans, hata konumu, yol-referans, boyut-doğrulama eklenir.

```cpp
// ---- AST ----
struct Ifade { enum K { Sayi, ParamRef, YolRef, Fonk, Tekli, Ikili } k;
  f64 sayi; Boyut boyut;                          // Sayi: değer + boyut (birim ekli literal)
  Varlik paramRef;                                // ParamRef: çözülmüş kimlik
  std::string yol;                                // YolRef: "Pad.1\Uzunluk" (geç-bağlama)
  std::string fonk;                               // Fonk adı ("sin","if","uzaklik")
  char op;                                         // Tekli/Ikili operatör
  std::vector<std::shared_ptr<Ifade>> cocuk; };

struct IfadeHata { std::string mesaj; u32 konum=0; u32 uzunluk=1; };  // konumlu (Z7)
```

**Dil özellikleri:**
- **Sayı + birim literali:** `10mm`, `45deg`, `2.5kg`, `1.5m` → iç SI'ye çevrilir, `Boyut` ekli.
- **Operatörler (öncelik):** `|| < && < ==,!= < <,<=,>,>= < +,- < *,/,% < ^ (sağ) < tekli -,!`. (Web önceliği doğru — korunur.)
- **Fonksiyon kütüphanesi:** `sin cos tan asin acos atan atan2` (derece), `sqrt abs sign min max pow round floor ceil log log10 exp`, `if(kosul,a,b)`, `clamp(x,alt,ust)`, `lerp(a,b,t)`. **Türkçe alias'lar (İYİLEŞTİRME §5):** `kok=sqrt, mutlak=abs, yuvarla=round, taban=floor, tavan=ceil, enk=min, enb=max, eger=if, kis=clamp`.
- **Sabitler:** `PI E`. Türkçe: `PI` yeterli.
- **Parametre referansı:** basit ad (`en`, `etKalinlik`) → çözümde **kimliğe** bağlanır (`ParamRef.paramRef`). Özel karakterli ad tırnakla: `` `Pad.1\Uzunluk` `` (CATIA yol sözdizimi).
- **Yol referansı (Z8):** `Nesne.N\Alan` → `YolRef`; çözücü (`ReferansCozucu`, aşağıda) feature/sketch/CAM alanına bağlar. Ölçüm fonksiyonları: `uzaklik(N1,N2)`, `uzunluk(Kenar.k)`, `alan(Yuz.f)`, `yaricap(Kenar.k)` — OCCT'den anlık okunur (GSD/olcum sistemine köprü).
- **Boyut doğrulama:** `+`/`-`/karşılaştırma → iki tarafın boyutu **eşit** olmalı (Uzunluk+Aci hatası). `*`/`/`/`^` boyut toplar/çıkarır. Fonk argümanları boyut-tipli (`sin` → arg ACI, sonuç SKALER; `sqrt(alan)` → UZUNLUK). Uyumsuzluk → konumlu Türkçe hata.

```cpp
class IfadeMotoru {
public:
  // Referans çözücü: ad/yol → Varlik. ParametreSistemi enjekte eder.
  struct Cozucu {
    std::function<Varlik(std::string_view ad)> adCoz;          // "en" → param Varlik
    std::function<f64(std::string_view yol, Boyut&)> yolCoz;   // "Pad.1\Uzunluk" → SI + boyut
    std::function<f64(Varlik)> degerOku;                       // param Varlik → SI değer
  };
  // Parse (bir kez → AST cache): metin → AST + referans kimlik listesi + hata.
  static std::shared_ptr<Ifade> parcala(std::string_view metin, const Cozucu&,
                                         std::vector<Varlik>& refOut, IfadeHata& hataOut);
  // Değerlendir (her recompute): AST + cozucu → SI değer + boyut.
  static f64 degerlendir(const Ifade&, const Cozucu&, Boyut& boyutOut);
  // Yalnız önizleme (fx editör canlı doğrulama).
  static bool dogrula(std::string_view metin, const Cozucu&, std::string& mesajOut,
                      f64& deger, Boyut& boyut);
};
```
> **AST cache (Z2):** `Parametre::formulKok_` parse'ı saklar; metin değişmedikçe yeniden parse YOK. `refKimlikler_` DAG için tutulur. Çözüm sıcak-yolunda yalnız `degerlendir()` (tahsissiz ağaç gezme).

### 2.4. `AlanKapisi` + `ParametreSistemi` — bağ + DAG entegrasyonu

**AlanKapisi (Z10 çözümü):** Her parametrik motor-alanı için tek yönlü kapı. Web'in `_sonYazilan` sentinel hack'i yerine **açık oku/yaz + kilit** semantiği.

```cpp
struct AlanKapisi {
  ParamTip tip;
  std::function<f64()> oku;          // alanın anlık SI değeri
  std::function<void(f64)> yaz;      // formül sonucu geri yazılır (write-through)
  // Kilit: parametre bağlıyken alan kullanıcı düzenlemesine kapalı (UI'da).
};

// Bir motor alt-sistemi kendi alanlarını yayınlar (feature/CAM/sketch/PartOp).
class AlanSaglayici {
public:
  virtual ~AlanSaglayici() = default;
  // (sahip Varlik, alan) → AlanKapisi. Yoksa nullopt.
  virtual std::optional<AlanKapisi> kapi(u32 sahip, const std::string& alan) = 0;
  // Yayınlanacak (sahip, alan, etiket, tip) listesi — intrinsic parametre üretimi için.
  virtual void alanlariListele(std::vector<struct AlanKaydi>&) = 0;
};
struct AlanKaydi { u32 sahip; std::string alan, etiket; ParamTip tip; std::string grupAd; };
```

**Sağlayıcılar (her alt-sistem KENDİ dosyasında kaydeder — merkez şişmez):**
| Sağlayıcı | Alanlar (web haritası referans, ama BOYUTLU) | Kaynak dosya |
|---|---|---|
| `FeatureAlanSaglayici` | `Feature::parametreler()` map (`uzunluk`,`derinlik`,`holeCap`,`aci`…) → `FeatureTanim.parametreler` şemasından tip/boyut | `motor/parca/` |
| `SketchAlanSaglayici` | boyutsal `Kisit` (`Mesafe/Yaricap/Cap/Aci`, `suru==true`) — **`Kisit.param` MEVCUT hook** (`kisit.hpp:41`) parametre kimliği taşır | `motor/sketch/` |
| `CamAlanSaglayici` | `CamIslem`/`CamGeometri`/`CamOp` (`zHatve`,`yanalHatveOran`,`altZ`,`devir`,`ilerleme`…) | `motor/cam/` |
| `PartOpAlanSaglayici` | `PartOperasyon` (güvenlik düzlemi ofset, tolerans…) | `motor/cam/part_operasyon.hpp` |
| `KinematikAlanSaglayici` | `Komut` değeri (revolute açı / prismatic mesafe) — law bağı (§3) | `motor/kinematik/` |

**ParametreSistemi (merkez — Cekirdek'e enjekte, `cekirdek.parametreler()`):**
```cpp
class ParametreSistemi {
public:
  // Depo (Parametre'ler DokumanNesnesi olarak Dunya'da; sistem indeks tutar).
  Parametre* param(Varlik); Parametre* adIle(std::string_view);
  Parametre* intrinsicBul(u32 sahip, const std::string& alan);

  // Kullanıcı parametresi ekle/sil (Islem üzerinden → undo).
  Varlik ekle(std::string ad, ParamTip, Deger, OlayGunlugu&);
  void sil(Varlik, OlayGunlugu&);

  // Formül ata/kaldır (Islem). Parse → AST cache → refKimlikler → DAG kenarı.
  void formulAta(Varlik, std::string metin, OlayGunlugu&);

  // Alan sağlayıcı kaydı (her alt-sistem kur()'da çağırır).
  void saglayiciEkle(std::string ad, std::shared_ptr<AlanSaglayici>);

  // Intrinsic senkron: sağlayıcılardan alanları topla → eksik parametre üret,
  // ölü olanı kaldır. (RecomputeMotor öncesi bir kez; web intrinsikSenkron eşleniği
  // ama BOYUTLU + kimlik-referanslı + ölü-tespiti sağlayıcı listesinden.)
  void intrinsikSenkron(OlayGunlugu&);

  // Çözüm: RecomputeMotor DAG'ına DELEGE (Z2/Z3 — kendi grafiği YOK).
  // Parametre düğümleri feature düğümleriyle AYNI topolojik sırada hesaplanır.
  // Parametre.hesapla() → formulKok_ değerlendir → deger_ yaz → bağlı AlanKapisi.yaz().

  // Referans çözücü üret (IfadeMotoru::Cozucu) — ad/yol/değer kancaları.
  IfadeMotoru::Cozucu cozucu();
private:
  std::unordered_map<std::string, std::shared_ptr<AlanSaglayici>> saglayicilar_;
  // ad → Varlik indeks (rename'de güncellenir), sahip+alan → Varlik indeks.
};
```

**DAG entegrasyonu (Z3 — kritik):**
- `Parametre` bir `DokumanNesnesi`; `bagimliliklar()` = formülün referans kimlikleri **+ intrinsic ise sahip feature** (feature değişince intrinsic değeri tazelensin, formül değişince feature recompute olsun — çift yön AlanKapisi ile).
- Kullanıcı bir değeri/formülü değiştirince → `ParametreDegisti{varlik}` yayınla → **mevcut** `main.cpp:722` kancası `recompute().kirlet(varlik)` çağırır → `RecomputeMotor::hesapla()` topolojik sırada Parametre.hesapla()'ları + etkilenen Feature.hesapla()'ları **tek geçişte** çalıştırır. Yalnız etkilenen alt-ağaç (Z2 — mevcut kirli yayılımı).
- Döngü: `RecomputeMotor` DFS-renk döngü tespiti **zaten var** (recompute.hpp:22-24); döngü üyesi parametreye `hata_="Döngüsel bağımlılık"` işaretlenir (§5, Z9).

### 2.5. Bağıntılar (Relations) — `bagintili.hpp`

CATIA'nın **Relations** düğümü: 4 tür, hepsi `DokumanNesnesi` (ağaçta görünür, undo'lu, olay yayınlar). Web'de yalnız Formula+zayıf Check vardı (Z5).

```cpp
class Bagintili : public DokumanNesnesi {   // ortak taban
public: enum class Tur { Formula, Kural, Kontrol, DesignTable };
  virtual Tur bagTuru() const = 0;
  virtual void degerlendir(ParametreSistemi&, OlayGunlugu&) = 0;
  const std::string& durum() const { return durum_; }  // Türkçe sonuç/uyarı
protected: std::string durum_; };
```

| Tür | Semantik | Alanlar | DAG davranışı |
|---|---|---|---|
| **Formula** | `hedefParam = ifade` — tek hedefe f(x). (Aslında Parametre.formul'ün nesne-yüzü; hem inline formül hem bağımsız Formula nesnesi.) | `Varlik hedef; std::string ifade` | Hedef parametrenin `hesapla()`'sı; refler DAG kenarı. |
| **Kural (Rule)** | `if kosul then param=X; param2=Y` — **çok hedefli koşullu atama** (CATIA Rule). Basit imperatif alt-dil: `eger/degilse`, atama, `uyar("...")`. | `std::string govde` (parse → deyim listesi) | Kuralın okuduğu paramlar girdi, yazdığı paramlar çıktı kenarı. |
| **Kontrol (Check)** | `kosul` — boolean; ihlal → durum (Bilgi/Uyarı/Hata seviyeli). Tasarım doğrulama. | `std::string ifade; Seviye seviye` | Yalnız girdi kenarı (yazma yok); recompute sonrası değerlendirilir. |
| **DesignTable** | CSV dosyası; satır = konfigürasyon; sütun ↔ parametre eşleme + **filtre ifadesi** (CATIA'daki gibi) → aktif satır seçilir → değerler parametrelere yazılır. | `std::string csvYol; std::vector<std::pair<std::string,Varlik>> eslesme; std::string filtre; u32 aktifSatir` | Filtre girdi paramları okur; eşlenen paramlara yazar (kilitli — DT sürüyor). |

**DesignTable (gerçek — Z5):**
- CSV parse (ilk satır başlık = sütun adları; birim ekli hücre `12mm` desteklenir).
- Associations: sütun adı → hedef parametre (CATIA "Associations" sekmesi).
- Filtre: `en > 20 && malzeme == "celik"` → uyan ilk/seçili satır. Filtre boşsa kullanıcı satır seçer (Combo).
- Aktif satır değişince → eşlenen parametreler kilitlenir + değer yazılır → recompute.
- **İYİLEŞTİRME:** CSV canlı-izleme (dosya değişince otomatik yeniden yükle — CATIA'da manuel synchronize).

### 2.6. Undo — `parametre_islemleri.hpp` (Z6)

Tüm mutasyon `Islem` (mevcut `islem.hpp` kalıbı; her biri uygun olay yayınlar):
| Islem | uygula / geriAl |
|---|---|
| `ParametreEkleIslem` | Parametre nesnesi oluştur/yok et; `ParametreEklendi`/`ParametreSilindi` |
| `ParametreSilIslem` | ters |
| `FormulAtaIslem` | eski↔yeni `formulMetin_`+AST; `FormulDegisti` + `ParametreDegisti`(→recompute) |
| `DegerDuzenleIslem` | eski↔yeni `deger_`; `ParametreDegisti` |
| `BagintiEkleIslem`/`BagintiSilIslem` | Formula/Kural/Kontrol/DesignTable ekle/sil |
| `DesignTableSatirIslem` | aktif satır değişimi; `DesignTableDegisti` |
| `ParamAdIslem` | rename (O(1) — AST kimlik-ref); yayın ile ağaç tazelenir |

### 2.7. Yeni olaylar (olay.hpp enum SONUNA — MEMORY kuralı)

`ParametreDegisti` + `HesaplamaBitti` **zaten var**. Enum sonuna eklenecekler:
```
ParametreEklendi, ParametreSilindi, FormulDegisti, BagintiEklendi, BagintiSilindi,
DesignTableDegisti, KontrolIhlali, KinematikGuncellendi   // (§3)
```
Her biri POD struct + `static tur()` (mevcut kalıp). `KontrolIhlali` disk-kalıcı (denetim); `KinematikGuncellendi` yüksek-frekans → diske yazılmaz (`kaliciAyarla(false)`).

### 2.8. Lua makro API (doğuştan — MEMORY `fikatia-mimari-ilke-makro-plugin-olay`)

Mevcut Lua makro motoruna kayıt (`fiko.sahne`/`fiko.olay` kalıbı):
```lua
fiko.parametre.ekle(ad, tip, deger)      -- Varlik döner
fiko.parametre.formul(ad, "en / 4")      -- formül ata (undo'lu)
fiko.parametre.oku(ad)                    -- SI değer
fiko.parametre.ayarla(ad, deger)          -- değer yaz (undo'lu)
fiko.parametre.bagla(nesne, alan, ad)     -- intrinsic alana parametre bağla
fiko.baginti.kural(ad, govde)             -- Rule ekle
fiko.baginti.kontrol(ad, "en < boy")      -- Check ekle
fiko.olay.dinle("ParametreDegisti", fn)   -- MEVCUT olay dinleme ile
```
Tümü `Islem` üzerinden → makro değişikliği de undo'lu (MEMORY: makrolar undo-uyumlu).

---

## 3. KİNEMATİK ENTEGRASYONU — `motor/kinematik/` (Dalga 3)

CATIA **DMU Kinematics**: mekanizma = joint zinciri; komut = tek DOF sürücü; law = komut(zaman) formülü. Parametre sistemi üzerine oturur (komut değeri = bir Parametre; law = o parametreye f(t) formülü).

### 3.1. Veri modeli
```cpp
namespace fiko::kinematik {

enum class JointTip : u8 {
  Rigid,        // 0 DOF — iki parça sabit
  Revolute,     // 1 DOF — dönme (eksen)
  Prismatic,    // 1 DOF — kayma (yön)
  Cylindrical,  // 2 DOF — dönme + kayma (tek eksen)
  Screw,        // 1 DOF — vida (dönme↔kayma bağlı, adım)
  Gear,         // 1 DOF — iki revolute, oran = r1/r2 (formülle)
  Kufeli,       // Rack (kremayer) — revolute↔prismatic
  Kuresel,      // Spherical (3 DOF)
  Duzlemsel,    // Planar (3 DOF)
};

struct Joint : DokumanNesnesi {
  JointTip tip;
  Varlik parcaA, parcaB;          // bağlı iki gövde (sahne düğümü)
  Vec3f eksenNoktasi, eksenYon;   // eksen tanımı (A'nın yerel çerçevesinde)
  f64 vidaAdimi = 1.0;            // Screw
  f64 disOrani = 1.0;            // Gear (formülle: yaricap(A)/yaricap(B))
  Varlik komut = VARLIK_YOK;     // sürücü ise: bağlı Komut
  const char* turAdi() const override { return "Kinematik Joint"; }
};

// Komut = tek DOF sürücü değeri. Değeri bir PARAMETRE (§2) → law = o parametreye formül.
struct Komut : DokumanNesnesi {
  Varlik joint;
  Varlik deger;                  // Parametre Varlik (Aci ya da Uzunluk boyutlu)
  f64 alt = 0, ust = 360;        // sınırlar (slider aralığı)
  const char* turAdi() const override { return "Kinematik Komut"; }
};

// Mekanizma = joint + komut kümesi + DOF hesabı.
struct Mekanizma : DokumanNesnesi {
  std::vector<Varlik> jointler, komutlar;
  Varlik sabitParca;             // fixed part (referans)
  int dof() const;               // Σjoint DOF − kısıtlar (Grübler)
  const char* turAdi() const override { return "Mekanizma"; }
};
}
```

### 3.2. Komut = parametre; Law = parametre formülü (parametre sistemine köprü)
- `Komut::deger` bir **Parametre** (Aci/Uzunluk boyutlu). `KinematikAlanSaglayici` bunu AlanKapisi olarak yayınlar.
- **Statik konumlandırma:** kullanıcı slider ile komut Parametre değerini değiştirir → recompute → joint dönüşümü → sahne.
- **Law (zaman-güdümlü, CATIA driven command):** komut Parametre'sine `command = f(zaman)` formülü atanır; `zaman` özel bir Parametre (Sure boyutlu, simülasyon saatinden beslenir). Örn `command = 360deg * zaman / 4s` (4 sn'de tam tur). Simülasyonda `zaman` ilerletilir → recompute → animasyon. **Law = parametre formülü** olduğu için ifade motoru bedavaya gelir (min/max/if ile karmaşık profil: hızlanma/yavaşlama).

### 3.3. Dönüşüm zinciri uygulaması
- Mekanizma bir DAG: sabit parça kökten başlayıp joint'lerle çocuk parçalara dönüşüm yayılır.
- `Joint::hesapla()`: komut değeri → yerel `Donusumd` (Revolute→rotasyon, Prismatic→öteleme, Screw→ikisi adımla bağlı, Gear→disOrani×komut). Zincir boyunca `parcaB.donusum = parcaA.donusum ∘ jointDonusum(komut)`.
- Sahne `DonusumBilesen`'e yazılır → `DonusumDegisti` olayı → render günceller.

### 3.4. Sketch 2D solver ile 3D kinematik ayrımı/köprüsü
| | Sketch 2D Solver (`motor/sketch/`) | 3D Kinematik (`motor/kinematik/`) |
|---|---|---|
| Amaç | Profil kısıt çözümü (LM, Jacobian) | Mekanizma konum/animasyon |
| Değişken | 2D nokta parametreleri (`p_` vektör) | Joint DOF (komut değeri) |
| Çözüm | İteratif nümerik (Levenberg-Marquardt) | Kapalı-form dönüşüm zinciri (joint başına) |
| Parametre bağı | `Kisit.param` → boyutsal kısıt = Parametre | `Komut::deger` = Parametre |
| Köprü | İkisi de `ParametreSistemi`'nden değer alır; ölçü/komut aynı ifade motoru | ortak |

**Köprü:** Bir mekanizma parçasının şekli bir sketch'ten türeyebilir; sketch boyutu bir parametreye, o parametre bir law'a bağlıysa animasyon boyunca parça şekli de değişebilir (CATIA'da nadir; native'de ifade motoru tekliği sayesinde doğal).

### 3.5. Çakışma kontrolü kancası
- Her simülasyon adımında (opsiyonel) OCCT `BRepExtrema_DistShapeShape` / AABB ön-eleme ile parça-çifti mesafesi. Mesafe < 0 (girişim) → `KinematikGuncellendi{cakisma=true}` + ağaçta kırmızı uyarı. (CATIA "Clash/Clearance".) Ağır → arka plan `GorevSistemi`'ne (mevcut) atılır.

---

## 4. UI ENTEGRASYONU (ImGui — AYRI PENCERE DEĞİL kuralı)

### 4.1. Parametreler + Bağıntılar ağaç düğümü (ana Ürün Ağacına)
**MEVCUT** `AgacSaglayiciKaydi` (`kayit.hpp:76`) — `main.cpp:469` `cekirdek.agac().ekle(urunAgaciTopla)` kalıbı. Yeni sağlayıcı (`motor/parametre/` `kur()`'da kaydeder — main.cpp'ye dokunmaz):
```
Ürün Ağacı
├─ Parça Gövdesi
│  ├─ Sketch.1
│  ├─ Pad.1   (intrinsic paramları alt-çip)
│  └─ ...
├─ 📐 Parametreler                    ← YENİ sağlayıcı
│  ├─ [Kullanıcı grupları = klasör]
│  │   ├─ en = 40 mm
│  │   └─ boy = f(x) 120 mm    🔒     ← formüllü: kilit + f(x) rozeti
│  └─ [Feature grupları: Pad.1\Uzunluk …]
└─ 🔗 Bağıntılar                       ← YENİ sağlayıcı
   ├─ Formül.1: boy = en*3
   ├─ Kural.1: eger(en>50) …
   ├─ Kontrol.1: en < boy   ✓/✗
   └─ TasarımTablosu.1 (satır 2/8)
```
Ağaç düğümüne çift-tık → ilgili düzenleyici (parametre satırı inline; bağıntı → küçük editör popup). Düğüm `Varlik` taşır → mevcut seçim/özellik akışı bedava.

### 4.2. Her sayısal alanda sağ-tık → "ƒ(x) Formül"
**Kanca noktası:** `feature_penceresi.cpp:40` `paramAlanlari()` `DragScalar/DragInt` döngüsü + `main.cpp:2490` Özellikler `DragFloat` döngüsü. Ortak yardımcı (yeni `uygulama/fikocad/fx_alan.hpp` — main.cpp şişmez):
```cpp
// Sayısal alanı çiz + sağ-tık f(x) menüsü + formüllü ise kilit+rozet.
// Alan (sahip, alan) intrinsic parametreye bağlıysa: DragScalar DEVRE DIŞI (turuncu),
// değer parametreden okunur; sağ-tık → "ƒ(x) Formül" / "Formülü Kaldır".
bool fxAlan(ParametreSistemi&, u32 sahip, const char* alan, const char* etiket,
            ParamTip, f64& deger, f32 adim, const char* birim);
```
- Formülsüz alan: normal `DragScalar` (mevcut davranış) + sağ-tık "ƒ(x) Formül…" → editör popup açar (o alanın intrinsic parametresine formül atar).
- Formüllü alan: **kilitli** (turuncu arka plan, `ImGuiInputTextFlags_ReadOnly`), yanında `ƒ(x)` rozeti; hover → formül metni tooltip; sağ-tık → "Düzenle" / "Formülü Kaldır (sabit değere dön)".

### 4.3. f(x) formül editör popup (ImGui)
Web `fiko-fx-editor.component.ts` FİKRİ (canlı önizleme + öneri) — ImGui'de yeniden:
```
┌─ ƒ(x) Formül: Pad.1\Uzunluk ─────────┐
│ [ en / 4 + etKalinlik            ]   │  ← InputText, canlı
│ = 22.5 mm  ✓                          │  ← canlı önizleme (dogrula()); hata → kırmızı+konum
│ Parametreler: en  boy  etKalinlik  … │  ← tıkla-ekle (autocomplete, son token filtre)
│ Fonksiyonlar: sin cos min max if …   │
│ [✔ Tamam]  [İptal]  [Formülü Kaldır] │
└──────────────────────────────────────┘
```
- Canlı doğrulama `IfadeMotoru::dogrula()` → sonuç+boyut ya da konumlu Türkçe hata (altı kırmızı).
- Öneri listesi: mevcut parametre adları + fonksiyonlar; son yazılan token'a göre filtre (web mantığı, native).
- Tamam → `FormulAtaIslem` (undo'lu).

### 4.4. Design Table penceresi (ayrı — veri tablosu tam ekran gerektirir)
> İstisna not: Design Table **kendi penceresi** olabilir (tablo görünümü) — bu "parametre ağacı ayrı pencere değil" kuralına aykırı değil; ağaç düğümü var, düzenleyici tablo. Per-op pencere kalıbı (`###dt_<id>` + `ustteTutSinif/ustteTutDugmesi`, `pencere_util.hpp`).
- CSV yükle/gözat, sütun↔parametre eşleme grid'i, filtre ifade satırı, satır seçici (aktif satır vurgulu), "Uygula" → parametrelere yaz.

### 4.5. Kinematik simülasyon penceresi (Dalga 3)
Per-mekanizma pencere (`###kin_<id>`):
- Komut başına **slider** (alt–üst; `Komut::deger` parametresini sürer → recompute → canlı hareket).
- **Play/Pause/Stop + zaman slider** (law modu: `zaman` parametresini ilerletir; FPS bağımsız `dt`).
- DOF göstergesi (mekanizma tam-tanımlı mı: `dof()==0` yeşil, >0 sarı).
- Çakışma rozeti (§3.5).

### 4.6. Ekran-içi ölçüden parametre türetme
Mevcut ölçüm sistemi (MEMORY `fikatia-olcum-sistemi`, kumpas/cetvel) sonucundan sağ-tık → "Parametre Oluştur" → seçili ölçüm bir `YolRef` kaynaklı parametreye (`uzaklik(N1,N2)`) dönüşür (associatif — geometri değişince güncellenir). CATIA "measure → parameter" eşleniği.

---

## 5. İYİLEŞTİRMELER (CATIA'yı AŞAN)

| İyileştirme | Açıklama | Nerede |
|---|---|---|
| **Compile-time boyut kontrolü** | CATIA runtime; native `Buyukluk<Boyut>` motor kodunda derleme-anı. `Uzunluk+Aci` derlenmez. | §2.1 |
| **Türkçe fonksiyon/birim** | `kok/mutlak/yuvarla/eger/enk/enb`, birim etiketleri; hata mesajları **konumlu Türkçe** | §2.3, §5 |
| **Canlı formül önizleme + konumlu hata** | editörde her tuşta değerlendir; hatalı token altı kırmızı (Z7) | §4.3 |
| **Döngü tespiti bedava** | RecomputeMotor DFS-renk zaten döngü bulur; üye parametreler işaretli + Türkçe | §2.4 (Z9) |
| **Performans: yalnız etkilenen alt-ağaç** | mevcut kirli-yayılımı; AST cache; tahsissiz değerlendirme (Z2) | §2.3-2.4 |
| **Kimlik-referanslı formül → O(1) rename** | AST param KİMLİĞİNE bağlı; ad değişimi formül string dokunmaz (Z4) | §2.2 |
| **Tek DAG (feature+parametre+kinematik)** | üç alt-sistem tek RecomputeMotor'da; tutarlı tek geçiş (Z3) | §2.4, §3.4 |
| **Law = parametre formülü** | kinematik komut(zaman) tam ifade dili (hızlanma profili, if) — CATIA law tipi kısıtlı | §3.2 |
| **DesignTable canlı CSV izleme** | dosya değişince otomatik yeniden yükle | §2.5 |
| **Ölçüden associatif parametre** | ölçüm → `YolRef` parametre; geometri değişince güncel | §4.6 |
| **Kontrol seviyeleri (Bilgi/Uyarı/Hata)** | denetim disk-günlüğüne (`KontrolIhlali` kalıcı) | §2.5, §2.7 |

---

## 6. UYGULAMA DALGALARI

> **main.cpp kilidi:** her dalga main.cpp'ye YALNIZ modül-kaydı + gerekirse `fxAlan` yardımcı include ekler. Asıl mantık `motor/parametre/` + yeni `uygulama/fikocad/*.hpp/cpp`'de. Tüm feature/CAM/sketch bağı sağlayıcı-tarafında (o modüller kendi `kur()`'unda `saglayiciEkle`).

### DALGA 1 — Çekirdek parametre + ifade motoru + temel bağ + f(x) UI
**Kur:** `motor/parametre/` modülü (`buyukluk.hpp`, `parametre.hpp`, `ifade.hpp`, `ifade_motoru.hpp`, `alan_kapisi.hpp`, `parametre_sistemi.hpp`, `parametre_islemleri.hpp`).
- Birimli tip sistemi (§2.1) + `Parametre : DokumanNesnesi` (§2.2).
- İfade motoru: tokenizer + Pratt parser + değerlendirici + AST cache + boyut doğrulama + konumlu hata (§2.3). Ad-referans (kimlik); YolRef **iskeleti** (çözücü stub, tam bağ Dalga 2).
- `ParametreSistemi` + `RecomputeMotor` DAG entegrasyonu (§2.4); `FeatureAlanSaglayici` (Part Design) + `SketchAlanSaglayici` (`Kisit.param` MEVCUT hook).
- `FormulAtaIslem`/`DegerDuzenleIslem`/`ParametreEkle/Sil` undo (§2.6).
- UI: `fx_alan.hpp` yardımcı → `feature_penceresi.cpp` + Özellikler paneli f(x) sağ-tık + kilit/rozet (§4.2); f(x) editör popup (§4.3).
- Olaylar: `ParametreEklendi/Silindi`, `FormulDegisti` (enum sonuna).
- Lua: `fiko.parametre.{ekle,formul,oku,ayarla,bagla}`.
- **Dokunulan mevcut:** `olay.hpp` (enum+struct), `feature_penceresi.cpp` (fxAlan çağrısı), `main.cpp` (modül kaydı + fx_alan include; ~5 satır), `motor/parca/` + `motor/sketch/` (`kur()`'da `saglayiciEkle`), `kisit.hpp` `Kisit.param` kullanımı.
- **Test:** `test_ifade` (parse/öncelik/boyut/hata konumu/döngü), `test_dag` (parametre+feature tek geçiş).

### DALGA 2 — Ağaç düğümleri + Design Table + Rule/Check + YolRef + CAM/PartOp bağı
- `AgacSaglayiciKaydi` "Parametreler" + "Bağıntılar" düğümleri (§4.1) — grup/klasör düzeni.
- `bagintili.hpp`: `Formula`/`Kural`/`Kontrol`/`DesignTable` (§2.5) + `BagintiEkle/Sil`, `DesignTableSatir` undo.
- Design Table penceresi (§4.4) — CSV parse/eşleme/filtre/satır.
- YolRef çözücü tam (`Pad.1\Uzunluk`, ölçüm fonksiyonları `uzaklik/alan/yaricap` → olcum+OCCT köprü); ölçüden parametre türetme (§4.6).
- `CamAlanSaglayici` + `PartOpAlanSaglayici` (`motor/cam/`) — parametrik CAM (web `camKnowledgeSenkron` eşleniği ama boyutlu/undo'lu).
- Kontrol denetimi + `KontrolIhlali` (disk-kalıcı), Kontroller panel/rozet.
- Olaylar: `BagintiEklendi/Silindi`, `DesignTableDegisti`, `KontrolIhlali`.
- Lua: `fiko.baginti.{formul,kural,kontrol,tablo}`.
- **Dokunulan mevcut:** `motor/cam/` (`kur()` saglayici), olcum sistemi (parametre türetme sağ-tık).

### DALGA 3 — Kinematik joint + mekanizma + simülasyon penceresi
- `motor/kinematik/` modülü (§3): `Joint`/`Komut`/`Mekanizma`, joint tipleri (Rigid/Revolute/Prismatic/Cylindrical/Screw/Gear + Küresel/Düzlemsel), DOF (Grübler).
- `KinematikAlanSaglayici` → komut değeri = Parametre (§3.2); dönüşüm zinciri (§3.3); çakışma kancası (§3.5).
- Simülasyon penceresi: komut slider + DOF göstergesi + çakışma rozeti (§4.5).
- Olay: `KinematikGuncellendi` (yüksek-frekans, diske yazılmaz).
- Lua: `fiko.kinematik.{joint,mekanizma,komut,konumAyarla}`.
- **Dokunulan mevcut:** `main.cpp` (kinematik workbench/menü kaydı), sahne `DonusumBilesen` yazımı.

### DALGA 4 — Law / animasyon / sinematik
- Law modu: komut Parametre'sine `command = f(zaman)` (§3.2); `zaman` özel Parametre simülasyon saatinden beslenir; Play/Pause/Stop + zaman slider (§4.5).
- Animasyon kaydı (keyframe → law otomatik türetme), oynatım hızı, çevrim (loop/ping-pong).
- Hız/ivme türev grafiği (law'ın d/dt — ifade motoru sayısal türev), sensör (parça hızı/mesafe zaman-serisi).
- Video/GIF dışa aktarım (mevcut render köprüsü).
- **Dokunulan mevcut:** `GorevSistemi` (arka plan simülasyon/render), zaman besleme (`olaylar().zamanAyarla` kalıbı).

---

## 7. ÖZET — MEVCUT ALTYAPININ NE KADARI HAZIR

| İhtiyaç | Durum |
|---|---|
| DAG recompute motoru | ✅ `RecomputeMotor` (kirli-yayılım + döngü tespiti) — parametre düğümleri direkt katılır |
| `ParametreDegisti` olayı + kirlet kancası | ✅ `olay.hpp` + `main.cpp:722` |
| Undo altyapısı | ✅ `Islem`/`KomutYigini` |
| Görünür-olmayan kök (parametre için) | ✅ `DokumanNesnesi` (GorunumSaglayici yok = görünmez) |
| Özellikler paneli (f(x) alanı için) | ✅ `Ozellik`/`OzellikSeti` + `main.cpp:2490` döngü — genişletilir |
| Ürün ağacı sağlayıcı (Parametreler/Bağıntılar) | ✅ `AgacSaglayiciKaydi` |
| Sketch boyutsal kısıt → parametre | ✅ `Kisit.param` hook (`kisit.hpp:41`) bekliyor |
| Feature parametre alanları | ✅ `Feature::parametreler()` map + `FeatureTanim.parametreler` şema |
| CAM parametrik alanlar | ✅ `CamIslem`/`CamGeometri` sayısal alanlar |
| Per-op pencere kalıbı (DT/kinematik) | ✅ `pencere_util.hpp` (`###id` + pin) |
| Makro/plugin/olay doğuştan | ✅ merkezi registry kalıbı |
| **Birim/boyut tip sistemi** | ❌ YOK → `buyukluk.hpp` YENİ (native iyileştirme) |
| **İfade motoru** | ❌ YOK → `ifade_motoru.hpp` YENİ |
| **Bağıntı nesneleri** | ❌ YOK → `bagintili.hpp` YENİ |
| **Kinematik** | ❌ YOK → `motor/kinematik/` YENİ (Dalga 3-4) |

**En kritik tasarım kararı:** Parametre = `DokumanNesnesi` → tek DAG'a girer; web'in iki-ayrı-grafik + minIdx hack'i (Z3) ortadan kalkar. İkinci: formül AST **kimlik-referanslı** (Z4) → rename O(1), tek otorite `AlanKapisi` kilidi (Z10) → sentinel yok. Üçüncü: law = parametre formülü → kinematik ifade motorunu bedavaya kullanır.

---
*Kaynaklar (CATIA referans): [Knowledge Advisor / Knowledgeware Infrastructure](http://catiadoc.free.fr/online/cfyugkwr_C2/cfyugkwr3002.htm), [Automation - Knowledge Advisor Overview](https://www.maruf.ca/files/caadoc/CAAScdKniTechArticles/CAAKniAutomationPrinciples.htm), [DMU Kinematics joint types / Gear ratio formula](https://cadexperience.blogspot.com/2015/12/catia-v5-6r2015-dmu-kinematics.html).*