@appaflytech/zeyrek-ai-mcp 0.0.4 → 0.0.6

package/dist/resources/guides/page.md

@@ -78,9 +78,30 @@ mümkündür ama doğrulama duvarı ve canlı canvas yalnız `page_schema_patch`
   her turda çözümlenmiş metinle EZER — anahtar yalnız `ref`'te yaşar, `data`'ya yazıp
   güvenme (`code` prop'uyla aynı davranış). Tam şekil, fallback zinciri ve `translation_*`
   tool'ları için `platform_guide('translation')`.
+- **Kurulmuş bir düğümün prop TİPİNİ `set_prop_type` micro-op'u değiştirir.**
+  `{ op: 'set_prop_type', target: '<elementId>', prop: 'content', propType: 'translation', ref: 'dashboard.kpi.total' }`
+  bir `static` prop'u çeviriye, `propType: 'code'` + `ref: '<ifade>'` koda, `propType: 'static'` +
+  `data: <değer>` sabite bağlar. Bu bir **gateway emülasyonudur**: `replace_prop` gönderilen ham
+  değeri her zaman `static` Prop'una sarar ve sarmalanmış Prop nesnesini reddeder, yani prop tipini
+  yazamaz. Op olmadan tek yol düğümü `remove_component` + `add_component` ile yeniden kurmaktı;
+  2026-09-06 koşusunda on bir etiket bu yolla kuruldu ve onlara yazan **dokuz setter iteratee'si**
+  platform tarafından sessizce silindi (üç KPI kartı boş kaldı). Taşıyıcı alan tipe göre değişir —
+  `static` değeri `data`'da, `code` ve `translation` `ref`'te taşır; eksik taşıyıcı istek
+  gönderilmeden reddedilir ve `page_schema_validate` aynı kararı verir.
+
 - **`blocks[].size`, komponentin `component_get`'teki `maxSize`'ını aşamaz.** Dikkat: katalog
   varsayılanı aşabiliyor (`page-header` default `h:8`, `maxSize` `h:4`) — varsayılanı körü körüne
   kopyalama, doğrulayıcı `"Height of 'page-header' must be between 1 and 4."` ile reddeder.
+- **Kurulmuş bir düğümün boyutunu `resize_component` micro-op'u değiştirir.**
+  `{ op: 'resize_component', target: '<elementId>', size: { w, h } }` ızgara boyutunu,
+  `{ …, appearance: { heightType: 'fixed', heightString: '340px' } }` flex ölçüsünü yazar; ikisi
+  aynı op'ta verilebilir, `breakpoint` varsayılanı 1024'tür. Bu bir **gateway emülasyonudur**:
+  platformun micro-op sözlüğünde boyut yoktur ve `move_component` gövdesine konan `size` 200 dönüp
+  SESSİZCE düşer (bu yüzden gateway artık onu reddeder ve buraya yönlendirir). Op şemayı okuyup
+  sayfayı tam gövdeyle geri yazar. Ebeveynin düzeni yazdığın alanı etkisiz kılıyorsa (flex kabın
+  içine `size`, ızgaranın içine `appearance`) yanıt `PAGE-019` uyarısı taşır — istek yine geçer.
+  **Düğümü silip yeniden kurmayın:** o yol ona yazan akış setter'larını sessizce öldürür
+  (`FLOW-018`, aşağıda Kural 2).
 - **Aynı ızgara hücrelerini iki komponente veremezsin.** Studio'da komponent tuvale bırakıldığında
   çakışan kardeşleri aşağı itme işini studio-api'nin sayfa kurma servisi yapar
   (`SchemaHelper.reorderComponents` → `draggableElement.moveItem`); komple şema yazan `page_create`
@@ -189,14 +210,15 @@ Adım gövdesi `StepManagementSchema`: `{ stepId, name, type, kind, args, branch
 **`branches[].nextStepId` bir GUID değil, hedef adımın `stepId` STRING'idir**
 (`allSteps.TryGetValue(b.NextStepId)`).
 
-Bu adımda platformun sessizce yuttuğu beş tuzak var — hepsi isteği 200 döndürür, akış yine de
+Bu adımda platformun sessizce yuttuğu altı tuzak var — hepsi isteği 200 döndürür, akış yine de
 ölü ya da yarım çalışır. Gateway hepsini yakalar (FLOW-004…012), ama şekli baştan doğru yazın:
 
 **1. Dal adı motorun anahtarıdır, etiket değil.** Runtime dal kimliğini `branch.name`'den üretir
 (`Runtime.svelte:329`) ve her adım `engine.next('always')` çağırır. Ad `always` değilse motor
 dalı bulamaz ve akışı **sessizce durdurur** (`flow-engine.ts:79`); Studio da zinciri
 `sourceBranch === 'always'` ile çizdiği için panelde **Start kartından sonrası boş görünür**.
-İstisnalar: `condition` → dal adı rule id'sidir, `confirm` → `yes|no|always`, `microservice` →
+İstisnalar: `condition` → dal adı rule id'sidir (ve o id bir **GUID**'dir — aşağıdaki tuzak 6),
+`confirm` → `yes|no|always`, `microservice` →
 `always` (eski akışlarda `success` de çalışır).
 
 **2. `iteratees[].type` yalnız `change` | `fill`.** `setter.ts` başka değerde hiçbir dala
@@ -226,6 +248,37 @@ key'ini düz anahtar ver, iç içe yolu `ref`'e yaz: `"parent_name": { "type": "
 anahtar her satırda taşınır. `type` sözlüğü: `item` (kaynak alanı), `code` (satır başına JS,
 satır `Row` değişkenindedir), diğerleri sabit.
 
+**6. `condition` adımının gövdesi `args.rules`'tur — backend workflow'unun `rule.items` şekli
+DEĞİL.** Sayfa akışını başka bir motor koşar (`ng-apps-flow/tasks/condition/condition.ts`) ve o
+motor yalnız şu sözleşmeyi tanır. Workflow şekli yazılırsa istek 200 döner, adım kaydedilir,
+Studio çizer ve **kural hiç değerlendirilmez** — akış dalsız kalır. Gateway `FLOW-020` ile
+yakalar.
+
+```jsonc
+{ "stepId": "guard", "name": "Token var mı", "type": "condition", "kind": "normal",
+  "args": { "rules": [
+      { "id": "0198e2a1-4c31-7a10-9b44-1f0c5d2e6a01", "expression": "!!Steps.signIn.data.token", "type": "if" },
+      { "id": "0198e2a1-4c31-7a10-9b44-1f0c5d2e6a02", "expression": "",                          "type": "else" } ] },
+  "branches": [ { "id": "<GUID>", "name": "0198e2a1-4c31-7a10-9b44-1f0c5d2e6a01", "nextStepId": "go_home" },
+                { "id": "<GUID>", "name": "0198e2a1-4c31-7a10-9b44-1f0c5d2e6a02", "nextStepId": "show_error" },
+                { "id": "<GUID>", "name": "always",                               "nextStepId": "hide_spinner" } ] }
+```
+
+> Dal adları okunabilir değil, **kuralın GUID'inin kendisi** — `branches[].name === rules[].id`.
+> Okunabilir ad iki uçta birden tutmaz (aşağıdaki tabloda ilk satır).
+
+| Kural | Neden | Kaynak |
+|---|---|---|
+| **`rules[].id` GERÇEK bir GUID olmalı** | Backend alanı `Guid`'e çevirir; `"ok"` gibi okunabilir bir ad isteği `The JSON value could not be converted to System.Guid. Path: $.flow.steps[N].args.rules[0].id` ile reddeder. Dal adı da aynı GUID olduğu için iki yerde birden okunabilir ad kullanamazsınız | `StepManagementSchema.cs` `StepManagementRule.Id` |
+| **`id`'yi hiç vermemek dalı sessizce ÖLDÜRÜR** | Alan boşsa backend `Guid.CreateVersion7()` ile kendi GUID'ini üretir; yazdığınız `branches[].name` ona asla eşleşmez, istek 200 döner ve dal hiç koşmaz. Her kural için taze GUID üretip iki yere de aynısını yazın | `StepManagementSchema.cs:549` varsayılan değer |
+| **İlk kural `type:'if'` olmak ZORUNDA** | Motor zinciri yalnız `rules[0].type === 'if'` iken başlatır; değilse adım hiçbir dala girmez ve akış sessizce biter | `condition.ts` son blok |
+| **Dal adı kuralın `id`'sidir** | `engine.next(rule.id)` → `Runtime.svelte:330` `branch.name`'i `branch.id`'ye çevirir → `flow-engine.ts:93` dalı adıyla arar. Her `rules[].id` için aynı adlı bir `branches[]` girdisi olmalı | `condition.ts` |
+| **`else` yalnız `expression` BOŞKEN fallback'tir** | Koşul `!rule.expression && rule.type === 'else'`; dolu `else` normal karşılaştırmaya döner ve hiçbir kural tutmazsa akış dalsız biter | `condition.ts` |
+| **Zincir dizi SIRASIYLA yürür** | Tutmayan kural `rules[index + 1]`'e geçer — `else-if` sırası diziden gelir, `order` alanından değil | `condition.ts` `process()` |
+| `type` kümesi `if` · `else-if` · `else` | `ConditionArgumentRuleType` | `condition.types.ts` |
+| **`always` YALNIZ bir dal eşleştiğinde koşar** | Motor `always`'i eşleşen dalın `completed`'ından çağırır (boş ifadeli `else` dalında ayrıca `stopped`'ta da). `rules` boşsa, `rules[0].type !== 'if'` ise ya da hiçbir ifade tutmayıp fallback `else` yoksa `engine.next('always')` **hiç çağrılmaz** — ayrıntı ve tuzağı için aşağıdaki §"Condition adımı `always` dalını…" | `condition.ts:55-61` |
+| `branches` nesne biçimini de kabul eder | Dizi yerine `{ "<dal adı>": "<nextStepId>" }` yazılabilir; motor ikisini de aynı `{ id, nextStepId }` şekline eşler. Dizi biçimini tercih edin — `branches[].id` alanını orada verebiliyorsunuz | `Runtime.svelte` `mapStepBranches` |
+
 ```jsonc
 // akışı başlatan adım — dal adı 'always' olmak zorunda
 { "stepId": "start", "name": "Start", "type": "start", "kind": "normal", "args": {},
@@ -259,6 +312,16 @@ satır `Row` değişkenindedir), diğerleri sabit.
 > göndermeden reddeder. `element` değerini `page_schema_get` çıktısındaki `elementId` ile doğrula,
 > uydurma.
 
+> **DOLU ama var olmayan `element` FLOW-017'nin KAPSAMI DIŞINDADIR — onu FLOW-024 söyler.**
+> FLOW-017 yalnız alanın boş olduğunu görür; henüz kurulmamış bir düğümün id'sini yazarsan alan
+> dolu görünür, kural susar ve platform `element`i **null** kaydeder — sonuç aynıdır: adım koşar,
+> hiçbir şey yazmaz (ölçüm: 2026-09-09 koşusu `S-14`, `search_hint` düğümü akıştan sonra
+> kurulmuştu). Gateway `flow_create`/`flow_update`/`flow_patch` sırasında barındırıcının şemasını
+> okuyup hedefi arar ve bulamazsa **FLOW-024 (uyarı)** düşürür; yazmayı durdurmaz, çünkü "önce
+> akışı kur, sonra düğümü" meşru bir sıradır. Doğru sıra: düğümü `page_schema_patch add_component`
+> ile kur, sonra akışı `flow_update` ile **aynı gövdeyle** yeniden kaydet — kaydedilen `element`
+> null olduğu için `flow_patch`'in `[element=…]` seçicisi onu bulamaz.
+
 Satır eşlemeli tablo yüklemesinin tam şekli (yükleniyor bayrağı → uç → satırlar + toplam kayıt)
 `ngapps://examples/flow-load-table`'dadır; setter'ın kritik iki iteratee'si şöyle görünür:
 
@@ -279,7 +342,67 @@ Satır eşlemeli tablo yüklemesinin tam şekli (yükleniyor bayrağı → uç
 
 `errorSteps` verirsen (start dışında en az bir adım) hata anında `engine.onError` true döner ve
 **ana akışın kalan adımları hiç çalışmaz** — yükleniyor bayrağını kapatmak, hata mesajını
-göstermek error flow'un işidir (`alert` adımı: `args: { message, alertType: 'error' }`).
+göstermek error flow'un işidir.
+
+> **4xx de hatadır ve `always` dalı seni KURTARMAZ.** `microservice.ts` `.catch` bloğu
+> reddedilen her istekte koşar — 401/403/404/422 dâhil. Sonrası iki yoldan biridir ve ikisi de
+> "ekranda hiçbir şey olmadı" ile biter:
+>
+> 1. **Hata yolu VARSA** `engine.onError` true döner ve `.finally` `return` eder —
+>    `engine.next('always')` **hiç çağrılmaz**. Yani `always` ile `errorSteps` birbirini dışlar;
+>    ikisini birden kuramazsın, hata yolu ana akışın devamını devralır.
+> 2. **Hata yolu YOKSA** `always` koşar, ama storage artık `{ error, data }`'dır ve
+>    `Steps.<ad>.data` başarı gövdesi değil **hata gövdesidir**. Sıradaki `condition`
+>    `!!Steps.signIn.data.token` gibi bir ifadeyi `undefined` üzerinden değerlendirir, sessizce
+>    diğer dala düşer ve `else` dalı bağlı değilse akış orada biter.
+>
+> **`errorSteps` yalnız `start` taşıyorsa hata yolu YOKTUR:** `hasErrorFlow`
+> `errorTasks.some(t => t.type !== 'start')` arar. Start'ın ardına en az bir adım bağla —
+> gateway `FLOW-021` ile uyarır.
+>
+> **Mobilde `errorSteps` diye bir şey YOK.** `ScreenRuntime.tsx` `mapFlowsToMachine` yalnız
+> `tasks` üretir (web `Runtime.svelte` ayrıca `errorTasks` verir), yani mobil uygulamada
+> `hasErrorFlow` her zaman false: hata yolu hiç koşmaz ve akış yukarıdaki 2. yoldan —
+> `always` + hata gövdeli storage — devam eder. Mobil sayfada hata yolunu `condition
+> Steps.<adımAdı>.error` ile kur.
+
+> **Hata metni ÜÇ ayrı yerde durur ve ikisi kullanıcıya gösterilecek metin DEĞİLDİR.**
+> `onError` hata akışını koşturmadan önce `machine.setStorage('error', errorInfo)` yapar
+> (`flow-engine.ts`), yani hata akışının adımları `Steps.error`'ı okuyabilir:
+>
+> | İfade | Ne taşır | Kaynak |
+> |---|---|---|
+> | **`Steps.error.message`** | **Ucun kendi mesajı** — `err.response.data.message`; boşsa HTTP durum metnine düşer. **Kullanıcıya gösterilecek metin budur.** Yanında `Steps.error.code` · `Steps.error.step.name` (patlayan adım) · `Steps.error.step.data` (ucun gövdesi) gelir | `microservice.ts` `err.reason \|\| HttpStatusText[err.code]` → `flow-engine.ts` `onError` |
+> | `Steps.<adımAdı>.error` | Yalnız HTTP **durum metni** — 401 için `'Unauthorized'`. Hata OLDUĞUNU anlamaya yarar, göstermeye değil | `microservice.ts` `.catch` `HttpStatusText[err.code]` |
+> | `Steps.<adımAdı>.data` | Ucun **hata gövdesi** (`err.response.data`) — başarı gövdesi değil. `.message` alanı burada da vardır | `microservice.ts` `.catch` |
+>
+> **`alert` adımının `message`'ı DÜZ METİNDİR — ifade yazarsan ekranda o ifade görünür.**
+> `alert.ts` `task.argument.message`'ı doğrudan `toast.error()`'a geçirir ve `args` hiçbir yerde
+> değerlendirilmez (`Runtime.svelte` `argument: step.args`): `{ "type": "alert", "args": {
+> "message": "Steps.error.message", "alertType": "error" } }` kullanıcıya harfi harfine
+> `Steps.error.message` gösterir. Sabit bir uyarı yetiyorsa `alert` en ucuz adımdır; **ucun ne
+> dediğini göstereceksen bir `setter` (ya da `code`) adımı zorunludur** — `value.type: 'code'`
+> ifadeyi orada gerçekten çalıştırır:
+>
+> ```jsonc
+> // errorSteps: start → bu setter. Metni bir notification/text komponentine yazar.
+> { "stepId": "show_error", "name": "Hatayı göster", "type": "setter", "kind": "normal",
+>   "args": { "iteratees": [
+>       { "type": "change", "element": "error_note", "property": "content", "source": "component",
+>         "mapping": { "source": "", "mappings": {} },
+>         "value": { "type": "code", "ref": "Steps.error?.message ?? 'İşlem başarısız'" } }] },
+>   "branches": [{ "id": "<GUID>", "name": "always", "nextStepId": null }] }
+> ```
+
+> **Hangi yolu seçeceksin — `errorSteps` mi, ana akışta `condition` mı?** İkisi birden
+> kurulamaz (yukarıdaki 1. madde), yani bu bir tercih değil bir karar:
+>
+> | | `errorSteps` | ana akışta `condition Steps.<adımAdı>.error` |
+> |---|---|---|
+> | Ana akışın kalanı | **koşmaz** — hata akışı devralır | koşar, dalı sen seçersin |
+> | Yükleniyor bayrağı · modal kapatma · tablo tazeleme | hata akışında **yeniden kurmak zorundasın**; kurmazsan bayrak açık kalır | zaten ana akışta duruyor |
+> | Hata metni | `Steps.error.message` (yukarıdaki tablo) | `Steps.<adımAdı>.data.message`, hata olduğunu `Steps.<adımAdı>.error` söyler |
+> | Ne zaman doğru | hata anında akış **tamamen başka bir yola** sapacaksa (başarısız giriş, yetkisiz sayfa) | kalan adımların çoğu hata hâlinde de koşacaksa — **form gönderimlerinin varsayılanı budur** (Kural 7) |
 
 Zorunlu filtresi olan uçlarda (`patient-*`, `doctor-appointments` gibi `isRequired: true`
 filtreli microservice'ler) parametreyi adımda ver, yoksa uç `MissingParameterException` atar:
@@ -319,11 +442,81 @@ Tarif: `platform_guide('middleware')`.
 - Adım hedef akışı **bekler** (`await engine.run`), sonra `always` dalından devam eder.
 - Gateway boş/yarım `args`'ı **FLOW-014** ile yakalar.
 
+> **`code` adımının gövdesi `args.value` alanındadır — düz JS metni olarak.** Runtime onu
+> `(async () => { <value> })()` içinde koşturur (`code.ts:18`), yani `await` serbesttir ve dönüş
+> değeri akışa taşınmaz; etkiyi `Page`/`state`/komponent yazarak üretirsin. **Alan boşsa adım
+> hata vermeden NO-OP olur** ve akış hiçbir şey yapmadan devam eder.
+>
+> ```jsonc
+> { "stepId": "sync_filters", "name": "sync_filters", "type": "code", "kind": "normal",
+>   "args": { "value": "state.page.month = flt_month.value" },
+>   "branches": [{ "id": "<GUID>", "name": "always", "nextStepId": "reload" }] }
+> ```
+>
+> `args.expression` / `args.script` gibi uydurma anahtarlar `StepManagementArgument` sözleşmesinde
+> YOKTUR ve platform onları **sessizce düşürür**: 2026-09-05 koşusunda akış koştu, filtre hiçbir
+> şey yapmadı ve teşhis ~10 dakika sürdü. Gateway artık ikisini birden yakalar — **FLOW-019**
+> gövdesiz `code` adımını istek gitmeden reddeder, akış yazmasından sonra da gövdeyi geri okuyup
+> farkı `silentlyDropped` ile bildirir.
+>
+> **Çoğu zaman `code` adımına hiç gerek yok:** filtre değerini sayfa değişkenine yazmak yerine
+> değeri doğrudan komponent prop'undan okuyun (`value: { type: 'property', ref: { source:
+> 'component', element: 'flt_month', property: 'value' } }`, ya da bir `code` ifadesinde
+> `flt_month.value`) ve olayı doğrudan yükleme akışına bağlayın — ara adım kırılgan bir katman ekler.
+
+> **Tek bir ifadeyi düzeltmek için tüm gövdeyi yeniden göndermeyin: `flow_patch` var.** Dizi
+> öğelerinde indeks yerine seçici kullanın —
+> `/steps[stepId=paint]/args/iteratees[element=tbl_funnel]/mapping/mappings/share/ref`. Adım ve
+> iteratee sırası platformda değişebilir; indeksle yazılan patch yanlış öğeye dokunur.
+
+> **`states` bir prop DEĞİL düğüm alanıdır** (`isWrapper`, `isScrollable`, `isSticky`,
+> `isDroppable`, `isFloating`, `isQuickStack`): `replace_prop` onu yazamaz. Kurulmuş bir düğümde
+> değiştirmek için `resize_component`'e `states` verin —
+> `{ op: 'resize_component', target: 'row_kpi', states: { isWrapper: false } }`. Eskiden tek yol
+> düğümü silip yeniden kurmaktı ve 09-05 koşusunda bunun bedeli 20 setter'ın kopmasıydı.
+> **`isWrapper: true` olan her kapsayıcıya runtime `min-height: 80vh` veriyor** — dokuz düğüm
+> sayfaya ~1600px ölü boşluk eklemişti; `style` ile ezilemez, gerekmiyorsa `false` bırakın.
+
 **Sözlükler** (`StepType.cs`, `StepParameterValueType.cs` — hepsi küçük harf):
 `start · microservice · setter · setcookie · validation · condition · redirect · alert ·
 confirm · flow-trigger · storage · navigate · code · download · end`
 değer tipleri: `static · page · property · storage · variable · code · item · state`
 
+> **Sözlükte olmak KOŞACAĞI anlamına gelmez — koşan tipler barındırıcıdan gelir.** Motor yedi
+> tip register eder, gerisini uygulama ekler. Bir sayfa TEK bir uygulamaya aittir
+> (`Page.ApplicationId`) ve uygulamanın tipi `web` ya da `mobile`'dır (`ApplicationType.cs`), yani
+> sayfanın barındırıcısı bellidir — matris "hangi tip sende çalışır"ı söyler, iki barındırıcıda
+> birden koşmayı değil (web `Runtime.svelte`, mobil `ScreenRuntime.tsx`):
+>
+> | Adım tipi | Web | Mobil | Nerede register ediliyor |
+> |---|---|---|---|
+> | `start` · `setter` · `code` · `condition` · `microservice` · `validation` · `flow-trigger` | ✅ | ✅ | `flow-engine.ts` — motorun kendisi |
+> | `alert` · `redirect` · `setcookie` · `storage` | ✅ | ✅ | uygulama; mobilde `redirect` navigate, `setcookie` storage uygulamasına eşlenir |
+> | `confirm` · `download` | ✅ | ❌ | yalnız `Runtime.svelte` |
+> | `navigate` | ❌ | ✅ | yalnız `ScreenRuntime.tsx` — web'deki karşılığı `redirect` |
+> | `end` · `query` | ❌ | ❌ | hiçbir yerde — üstelik `query` backend sözlüğünde de yok (`StepType.cs` onu saymaz), yalnız frontend enum'unda duruyor |
+>
+> **Register edilmemiş bir tipe gelen akış SESSİZCE durur.** `flow-engine.ts` `process()`
+> callback bulamazsa hiçbir şey yapmaz: `next()` yok, `completed`/`stopped` yok, hata yok, log
+> yok. Akışın kalanı ölür — üstelik `run()`'ın promise'i hiç çözülmediği için
+> `flowRunFinished()` koşmaz: `__ngAppsFlowActivity.running` sıfıra inmez ve
+> `page_screenshot`'ın hazır bekleyişi her eylemde bütçesini sonuna kadar yakar.
+>
+> Gateway iki hâli **kendisi düzeltir** ve `gatewayNormalized` ile söyler: `navigate` → `redirect`
+> (argüman şekli aynı, `redirect` iki barındırıcıda da koşar) ve ölü `end` adımı gövdeden düşer
+> (ona işaret eden dal `nextStepId: null` olur). `FLOW-023` bunların arkasındaki emniyet kemeridir:
+> `end`/`query` kalırsa **bloklar**, iki barındırıcıya birden özel tip taşıyan gövdeyi uyarır. Tek
+> barındırıcıya özel bir tipi (`confirm`/`download`) tek başına kullanmak kusur değildir — gateway
+> sayfanın hangi uygulamada olduğunu bilmez, doğru tipi bu matristen SEN seçersin.
+>
+> **`end` adımı bir tuzaktır.** Studio kataloğunda bir tip olarak duruyor
+> (`event-actions.constants.ts` `FlowTaskType.End`; ekleme menüsü onu eler) ve eski akışlar bu
+> düğümü taşıyabiliyor (`event-actions.mappers.ts`) — ama Studio'nun varsayılan şeması End
+> düğümü YARATMAZ (`DEFAULT_SCHEMA` `endId`'yi üretir ve kullanmaz) ve motor onu register etmez. Düğümün VARLIĞI zararsızdır; zararlı olan **bir dalın oraya işaret
+> etmesidir** — akış o adıma girer ve çıkamaz. Akış, son adımın dalına `nextStepId: null`
+> verilerek bitirilir. İronik olan şu: var olmayan bir `stepId`'ye işaret etmek daha güvenlidir,
+> çünkü motor hedefi bulamayınca `completed`/`stopped`'ı düzgün çağırır.
+
 > `code` adımının içinde ve `value.type:'code'` ifadelerinde kullanılabilen bağlam
 > (`Page.*`, komponentlere adıyla erişim, `state.page/app`, `Steps`, `self`/`item`/`event`,
 > `cookie.get/set`, `await`) ve `value.type` çözümleme tablosu için
@@ -355,6 +548,10 @@ Toplam kayıt sayısı `Total-Count` header'ından gelir (`TableMicroserviceExec
 `isSingle: false` olduğu sürece) — `totalRows`'u yukarıdaki guard'lı ifadeyle yaz. Gateway
 parametreleri geçmeyi unutursan `FLOW-013` ile uyarır.
 
+Ucun gerçekten `Total-Count` döndüğünü sayfayı kurmadan **önce** doğrula:
+`microservice_execute(...)` yanıtındaki `headers['total-count']` dolu olmalı; boşsa `sort`/`limit`
+verilmemiş bir tablo kaynağı vardır ve sayfa göstergesi `NaN / N` olur (ölçüm: İK koşusu M-8/E-4).
+
 > **`replace_prop` Prop sarmalı DEĞİL ham değer alır** — `PageSchemaMicroOpApplier.cs:77`
 > `new Prop(PropValueType.Static) { Data = op.Value }` kurar. `{ "type": "static", "data": true }`
 > gönderirsen sarmalın kendisi `Data`'ya yazılır ve platform onu `Dictionary<string, Prop>` diye
@@ -394,8 +591,9 @@ Türkçe başlık `props.title` / `props.text` / `props.label` / `props.pageTitl
 > Aynı sebeple akış ifadelerinde komponente **`name` ile** erişilir (`tbl_mng.selectedRow`);
 > `elementId` ile eşit tutmazsan `element:` alanı çalışır ama ifadedeki değişken `undefined` kalır.
 >
-> Gateway bunu **PAGE-009** ile `add_component`, `page_update(schema)` ve `layout_update(views)`
-> yollarında istek gitmeden reddeder.
+> Gateway bunu **PAGE-009** ile HER sayfa ve layout yazma yolunda istek gitmeden reddeder:
+> `page_create`, `page_update(schema)`, `add_component`, `layout_create`, `layout_update(views)`
+> ve `layout_patch`.
 
 ## Kural 1d — Sayfa iskeleti: `page_container` ve boyutlandırma
 
@@ -633,13 +831,18 @@ aynı prop grubunu o da alır. Grup katalogda tanımlıdır, yani şemadan kurul
 
 | Prop | Değerler (varsayılan **kalın**) | Ne yapar |
 |---|---|---|
-| `layout` | **`flex`** · `grid` | `flex`: akış düzeni. `grid`: 12 kolonluk ızgara (Kural 1f). |
+| `layout` | **`flex`** · `grid` | `flex`: akış düzeni. `grid`: 12 kolonluk mutlak ızgara (Kural 1f). Grubu taşıyan kaplar: `container`/`page_container` · `form` (2026-09-01'den) · `box`/`aibox` · `layout` ve `widget-area` (2026-09-03) — hepsinde değer kümesi `flex·grid`; yalnız `box-section` tek değerlidir (`flex`). `box`/`aibox`'ın eski üçüncü değeri `cssgrid` (akan gerçek `display:grid`) 2026-09-02'de seçenek olmaktan çıktı: yeni yazımda `invalid-enum-value` verir, o değerle kayıtlı düğümler çizilmeye devam eder. |
 | `direction` | **`row`** · `column` | `flex-direction`; hangi hizalamanın ANA eksen olduğunu belirler. |
 | `horizontalAlign` | **`left`** · `center` · `right` · `stretch` | `row`'da ana eksen (`justify-content`), `column`'da çapraz eksen (`align-items`). |
 | `verticalAlign` | **`top`** · `middle` · `bottom` · `stretch` | `row`'da çapraz eksen, `column`'da ana eksen (rolleri `horizontalAlign` ile takas). |
 | `size` | **`shrink`** · `grow` | Çocuklara `flex: 0 1 auto` / `1 1 auto`. |
-| `gap` | `none` · `small` · **`medium`** · `large` | 0 / 8 / 16 / 32px. |
-| `wrap` | **kapalı** · açık | `flex-wrap`; kapalıyken taşan çocuklar sıkışır, alta inmez. |
+| `gap` | `none` · `small` · **`medium`** · `large` **ya da ham CSS** | Preset'ler tema değişkenidir: 0 / `var(--ng-spacing-sm)` / `--ng-spacing-md` / `--ng-spacing-lg` (varsayılan temada 8/16/32px). Alan `allowCustom`'dır: `"18px"` ya da `"var(--ng-spacing-xl)"` gibi ham değer de geçer. `box-section`/`aibox`'taki sayısal `gapCustom` doluysa preset'i ezer. |
+| `wrap` | kapalı · **açık** | `flex-wrap`. **Varsayılan 2026-09-01'de açık oldu:** `row` + `w:12` çocuklar artık alt satıra sararak dikey akar. Kapatırsan taşan çocuklar tek satıra sıkışır. |
+
+**`form` da bu grubun tamamını taşır (2026-09-01):** varsayılanları container ile aynı
+(`flex` · `row` · `left` · `top` · `shrink` · `medium` · `wrap` açık). "Form'a layout yazılmaz"
+eski bilgidir. (Platform kataloğu güncel şemayı `component_get`'te göstermiyorsa kayıt
+yenilenmemiştir — ARC-024.)
 
 `stretch` iki eksende farklı anlama gelir: **ana** eksende `space-between` (çocukları uçlara
 dağıtır), **çapraz** eksende gerçekten doldurur.
@@ -654,27 +857,37 @@ prop'una bakar (`isFlexLayout`). İki sonucu var:
   ızgara alırsın — Studio'dan sürüklenen kardeş kapsayıcı flex gelirken seninki grid kalır.
 
 Gateway'in kendi eklediği kök kapsayıcı (`page_create`'te şemada `page_container` yoksa) bu yüzden
-seti açıkça taşır: `flex` · `row` · `left` · `top` · `shrink` · `medium`. **`row` + `wrap` kapalı
-demek, alt alta düşünülmüş `w: 12` çocukların TEK SATIRA sıkışması demek** — dikey akan bir sayfa
-istiyorsan kapsayıcıya `direction: 'column'` yaz (ya da `layout: 'grid'`e dön).
+seti açıkça taşır: `flex` · `row` · `left` · `top` · `shrink` · `medium` · `wrap` açık.
+`row` + `wrap` açık + `w: 12` çocuklar alt satıra sararak dikey akar; net bir dikey akış
+istiyorsan yine de `direction: 'column'` yazmak daha okunur (ya da `layout: 'grid'`e dön).
+**`wrap`'i kapatırsan** alt alta düşünülmüş `w: 12` çocuklar TEK SATIRA sıkışır.
 
 **Ne zaman flex?** Yan yana buton/aksiyon grubu, toolbar, rozet dizisi, ortalanmış giriş kartı,
 "kalanı doldursun" yerleşimleri. Alt alta akan form alanları için ızgara da doğrudur — orada flex
 istiyorsan `direction: 'column'` şart, `row` ile alanlar tek satıra sıkışır.
 
-Dört şeyi bilmeden flex kurma:
-
-1. **Genişlik yine 12 kolondur — içerik genişliği DEĞİL.** Çocuğun `blocks[].size.w`'si
-   `row`'da `flex-basis: w/12`, `column`'da `width: w/12` olur (`gap` payı formülden düşülür,
-   böylece `w` toplamı 12 olan satır tam kapanır). Bu bilinçli bir tercih: ızgara ↔ flex geçişi
-   kayıpsızdır ve genişlik şemadan ifade edilebilir kalır. `column` + `horizontalAlign: 'stretch'`
-   tek istisnadır — orada çocuk tam genişlik olur.
+Beş şeyi bilmeden flex kurma:
+
+1. **Çocuğun genişliği `appearance.widthType`'tan gelir (2026-09-01); 12 kolon yalnız
+   FALLBACK'tir.** Dört cevap, öncelik sırasıyla:
+   - `widthType: 'fill'` — kabın tüm genişliği (satırda `flex:1 1 100%`, sütunda
+     `align-self:stretch`); string taşımaz, taşırsa bile ezer.
+   - `widthType: 'fixed'` + `widthString` — sabit ölçü, serbest CSS uzunluğu (`"240px"`,
+     `"50%"`, `"10vw"`, `calc(...)`). Geçersiz string sessizce düşer ve span'a dönülür.
+   - `widthType: 'auto'` — içerik kadar (`flex: 0 1 auto`).
+   - `widthType` YOK (eski kayıtlar) — `blocks[].size.w` payı: `row`'da `flex-basis: w/12`,
+     `column`'da `width: w/12` (`gap` payı düşülür; `column` + `horizontalAlign:'stretch'`
+     istisna — tam genişlik). Izgara ↔ flex geçişi bu fallback sayesinde kayıpsızdır.
+   Şemayı sen kuruyorsan çocuğa `widthType`'ı AÇIKÇA yaz. Studio'nun kendi bırakma kuralı:
+   kapsayıcı türü kaplar (`container`/`box`/`form`) `'fixed'` + `"50%"`, diğer her şey `'auto'`.
 2. **`position.y` artık yalnız SIRADIR.** Flex çocuklar `y`, sonra `x` sırasına göre dizilir;
    aradaki boşluklar çizilmez. Yine de bitişik ver (0,1,2…): kapsayıcı ileride `grid`'e
    döndürülürse şema geçerli kalsın. Gateway bu yüzden **flex kapsayıcının İÇİNDE PAGE-010
    boşluk uyarısı üretmez** (ızgarada üretmeye devam eder).
 3. **Flex kapsayıcının yüksekliği içeriğine oturur.** `verticalAlign`'ın dağıtacak boşluğu
-   olması için `appearance.heightType: 'fixed'` + `size.h` vermelisin. **İstisna
+   olması için `appearance.heightType: 'fixed'` vermelisin — ölçü `heightString`'den
+   (serbest CSS uzunluğu, ör. `"30vh"`), o yoksa `size.h × 10px`'ten gelir. `heightString`
+   yalnız `heightType:'fixed'` iken okunur; tek başına yazmak hiçbir şey yapmaz. **İstisna
    `page_container`**: `states.isWrapper: true` olduğu için zaten `min-height: 80vh` alır
    (Kural 1f), dolayısıyla dikey hizalama onda kutu boyu vermeden de çalışır. Üçüncü yol
    `heightType: 'fill'` (2026-08-28): çocuk kabın bıraktığı yeri alır — sütunda `flex: 1 1 auto`,
@@ -684,6 +897,10 @@ Dört şeyi bilmeden flex kurma:
 4. **`layout: 'grid'` iken diğer altı prop ÖLÜDÜR.** Katalogda tanımlı oldukları için
    doğrulama duvarı susar, renderer da okumaz: ızgara kapsayıcıya `direction: 'column'` yazmak
    sessizce hiçbir şey yapmaz. Gateway bunu **PAGE-015 (uyarı)** ile söyler.
+5. **Flex düzeni kırılım BİLMEZ.** `direction`/`gap`/hizalama masaüstü ve mobilde AYNIDIR;
+   sıra ve span'lar Desktop (1024) bloğundandır — Studio, mobil kırılım düzenlenirken flex
+   bölgeyi salt-okunur kilitler. Kırılım bilen yalnız `blocks[]` ve `appearance.hideOn`'dur;
+   mobilde farklı davranış gereken satır için `layout: 'grid'` kullan (Kural 1f mobil notu).
 
 ```jsonc
 // Ortalanmış giriş kartı — style ile CSS hack'i YOK, kabın kendi düzeni
@@ -701,6 +918,33 @@ Dört şeyi bilmeden flex kurma:
 { "op": "replace_prop", "target": "row_actions", "prop": "gap",             "value": "small" }
 ```
 
+**Mini tarif — sıkı dizilim (küçük bileşenleri dip dibe getirmek).** Buton/rozet/ikon dizisi
+gibi bitişik duracak elemanlar için ÜÇ şart birden gerekir; biri eksikse arada boşluk kalır:
+
+1. Her çocuğa **`appearance.widthType: 'auto'`** — içerik kadar yer kaplar (`flex: 0 1 auto`).
+   Yazılmazsa eski 12 kolon payı geçerlidir ve çocuk kolonunu doldurur, bitişemez.
+2. Kaba **`gap: 'none'`** (ya da ham ince değer: `"2px"`, `"4px"` — alan `allowCustom`).
+3. Her çocuğa **`appearance.marginType: 'none'`** — en çok atlanan şart: `marginType`
+   yazılmamış düğüm `normal` sayılır ve her kenara 4px basar (`spacing.ts`
+   `CANVAS_NORMAL_MARGIN`), yani `gap:'none'` olsa bile komşular arasında 8px kalır.
+
+```jsonc
+// Bitişik rozet dizisi: kap + iki çocuktan biri (diğeri aynı desen)
+{ "elementId": "badge_row", "type": "container", "kind": "component",
+  "props": { "layout": { "type": "static", "data": "flex" },
+             "direction": { "type": "static", "data": "row" },
+             "gap": { "type": "static", "data": "none" } },
+  "children": [
+    { "elementId": "badge_1", "type": "button", "kind": "component",
+      "appearance": { "widthType": "auto", "marginType": "none", "heightType": "auto" },
+      "blocks": [{ "breakpoint": 1024, "size": { "w": 2, "h": 4 }, "position": { "x": 0, "y": 0 } }] }
+  ] }
+```
+
+"Şu ikisi bitişik, şu uzak" gibi eşit olmayan aralıklar için `gap` yetmez (kapta tekildir) —
+bitişik elemanları `gap:'none'` bir İÇ kapsayıcıda gruplayıp grupları dış kapta normal
+`gap` ile diz.
+
 > Düzen işi `style` prop'una AİT DEĞİL. Kural 1h'deki `style` reçeteleri tema/görsellik içindir;
 > `display:flex` gibi düzen kurallarını oraya yazmak kabın kendi düzeniyle çakışır (PAGE-014'teki
 > ölçüm: string style ile kart 66px'e çöktü). Yerleşim bu prop grubuyla, tema `style` ile kurulur.
@@ -776,8 +1020,10 @@ UYGULAMAZ** — koordinatları aynen kaydeder (aşağı itme yalnız `page_creat
 > - Ekranda sürekli `Expression error: Cannot read properties of null (reading '0')` toast'ı çıkıyor
 >   (iç repeater bir kez `item` olmadan da değerlendiriliyor).
 >
-> **Gateway bunu `PAGE-013` ile istek gitmeden reddediyor** (`page_create` / `page_update(schema)` ve
-> `page_schema_patch`'te op'lar UYGULANDIKTAN SONRAKİ ağaca bakarak).
+> **Gateway bunu `PAGE-013` ile istek gitmeden reddediyor** — `page_create` / `page_update(schema)` /
+> `layout_create` / `layout_update(views)` / `layout_patch` gönderilen ağaca, `page_schema_patch` hem
+> eklenen alt ağaca hem op'lar UYGULANDIKTAN SONRAKİ ağaca bakarak. Layout'ta da geçerlidir: kırılma
+> `_repeaterValues` geri yazmasındadır, barındıranın sayfa mı layout mu olduğuna bakmaz.
 >
 > **Yapılacak:** satır içi listeyi tek bir `textarea`'da **satır başına bir öğe** olarak topla
 > (`options_text`), kaydederken `split('\n')`'le böl. Ölçülmüş çalışan sürüm: anket editörü
@@ -805,6 +1051,14 @@ yapmanın yolu budur — ölçülmüş kurallar (anket-doldur, 2026-08-19):
 > Bu kural TEMA/GÖRSELLİK içindir. Çocukların dizilimi (ortalama, yaslama, aralık, "kalanı
 > doldur") `style` ile değil kapsayıcının kendi `layout` prop grubuyla kurulur — Kural 1f-2.
 
+> **Stil anahtarları camelCase'dir: `minHeight`, `fontSize`, `letterSpacing`.** Kebab-case anahtar
+> (`min-height`) platform tarafından KABUL EDİLİR, `page_schema_get` ile aynen geri okunur ve
+> runtime onu HİÇ UYGULAMAZ; tek işaret tarayıcı konsolundaki tek satırdır ve `page_screenshot`
+> konsolu döndürmez. 2026-09-05 koşusunun en pahalı yanlış teşhisi buydu (~15 dk) ve yanlış teşhis
+> düğümleri silip yeniden kurmaya, o da 20 setter'ın sessizce kopmasına yol açtı. Gateway artık
+> kebab-case anahtarı camelCase'e çevirir ve `gatewayNormalized` ile bildirir; seçici anahtarlara
+> (`&__body`, `:hover`, `--ng-*`) dokunmaz.
+
 **1. Temayı tek yerden çevir: `page_container.style` içinde `--ng-*` değişkenlerini ez.**
 Runtime bütün renk/tipografi/form tokenlarını CSS değişkeni olarak basar
 (`Theme.svelte`: `--ng-accent-primary`, `--ng-accent-hover`, `--ng-background-surface`,
@@ -991,7 +1245,7 @@ budur — bir preset ya da `componentStyles` sizin değerinizi eziyorsa `styleLa
 | Değişiklik | Tool | Neden |
 |---|---|---|
 | Komponent ekle/sil/taşı, prop, binding, event | `page_schema_patch` | Doğrulama duvarı + açık Studio canvas'ına SignalR canlı yayını + eşzamanlı yazar kilidi yalnız bu yolda çalışır |
-| Ad, slug, browserTitle, layout, roller, middleware | `page_update` | Üstbilgi alanları micro-op sözlüğünde yok |
+| Ad, slug, browserTitle, `browserTitleKey`, layout, roller, middleware | `page_update` | Üstbilgi alanları micro-op sözlüğünde yok. `browserTitleKey` sekme başlığını çeviri anahtarına bağlar: verilirse başlık sözlükten çözülür, boşsa `browserTitle` kullanılır. Başlık sayfa yüklenirken çözülür ve canlı dil değişimini izlemez (`platform_guide('translation')`) |
 
 Platformun `PUT /pages/...` ucu **replace**'tir: gönderilmeyen `schema`/`events`/`roleIds`
 alanları silinir. Gateway bu yüzden `page_update`'te sayfayı önce okur, yalnız verdiğin
@@ -1018,6 +1272,17 @@ Yanıt üç alan döner: `applied` (uygulanan op sayısı), **`appliedPatch`** (
 olarak hangi JSON Pointer'a ne yaptığı — RFC 6902 biçiminde; "gerçekten yalnız o komponente mi
 dokunuldu" sorusunun kanıtı) ve **`newVersion`** (`UpdatedAt.Ticks`).
 
+> **`appliedPatch` gövdesi VARSAYILAN OLARAK iskelettir.** Girdi `{ op, path }` döner; eklenen
+> düğüm `component` altında yalnız `id`/`elementId`/`name`/`type`/`children` taşır. Kanıt zaten
+> path'tedir — `value` senin aynı turda gönderdiğin gövdenin yankısıdır ve tek bir `set_event`
+> yaması bile düğümün bütün prop'larını geri getiriyordu. Aynı kural `page_create` yanıtındaki
+> `schema` için de geçerlidir (çözülmüş layout düğümleri dâhil). Tam gövde: `view: 'full'`.
+>
+> **"Kaydedildi mi" sorusunu `appliedPatch` zaten cevaplamıyor** (aşağıdaki `silentlyDropped`
+> bölümü): yama 200 döner ve pointer'ı gösterir, ama alanın kayda geçtiğini söylemez. Onu gateway
+> yamadan sonra şemayı okuyup gönderdiğinle karşılaştırarak söyler. Kırpma bu yüzden kanıt kaybı
+> değildir; `view: 'full'`e yalnız gerçekten platformun ham gövdesini incelerken düş.
+
 **Sürüm kontrolü platformda var ama gateway bugün KULLANMIYOR.** Platform gövdede `baseVersion`
 (long tick) kabul eder ve tutmazsa 409 verir; `page_state.baseVersion` bu değeri döner.
 `page_schema_patch` bu alanı geçirmez — bayat plan koruması gateway tarafında
@@ -1204,9 +1469,21 @@ altın örneklerde** — şemayı ve akışları oradan kopyalayıp uyarla:
 | Detay / profil | `ngapps://examples/page-detail-profile` |
 | Dinamik form (alanlar veriden) | `ngapps://examples/page-dynamic-form` (Kural 1g + 1h) |
 
-> Gateway iki yarım kurulumu yakalar: **FORM-001** (`form` eklendi, `submit` bağlanmadı) ve
+> Gateway üç yarım kurulumu yakalar: **FORM-001** (`form` eklendi, `submit` bağlanmadı),
 > **FORM-002** (akışta POST/PUT adımı var ama hiç `source:'body'` parametresi yok → gövde boş
-> gider). `project_overview` ayrıca proje düzeyi boşlukları döndürür (`coverageGaps`): kimlik
+> gider) ve **FORM-003** (formun `submit`'i bağlı ama içindeki butonun `click`'i bağlı değil).
+>
+> **FORM-003 neden var:** `button` varsayılan olarak `type="button"` çizilir; form içinde bile
+> HTML form submit'i HİÇ doğmaz — butona tıklamak da alanda Enter da uca istek göndermez ve
+> **hiçbir hata çıkmaz**. `ngapps://examples/page-sign-in`'i harfiyen izleyen bir giriş sayfası bu
+> yüzden tıklanamaz kalıyordu (ölçüldü 2026-09-05); teşhis yalnız gerçek tıklamayla mümkün oldu
+> (`page_screenshot` `actions`). İki çözümden biri yeter:
+>
+> 1. Butona **`props.type = 'submit'`** ver — katalogdaki `type` prop'u bu değeri destekliyor ve
+>    idiomatik yol budur.
+> 2. Ya da AYNI akışı butonun `click` olayına da bağla.
+>
+> `submit` olayını forma bağlamak tek başına yetmez; gateway ikisi de yoksa uyarır. `project_overview` ayrıca proje düzeyi boşlukları döndürür (`coverageGaps`): kimlik
 > middleware'i var ama giriş sayfası yok, yazma ucu var ama sayfa yok.
 
 **Adlandırma:** çoğul = liste sayfası, tekil = form sayfası (`Departmanlar` / `Departman`).
@@ -1235,6 +1512,17 @@ maxLength/pattern — sözlük `component_get`'te) orada listelenir.
 ] }
 ```
 
+**Mesajı çeviriye bağlamak: `t:` öneki.** `message` düz bir metindir ve translation prop'u ALMAZ;
+çeviri anahtarı mesajın kendisine önek olarak yazılır:
+
+```jsonc
+{ "type": "required", "message": "t:form.emailRequired", "value": true, "isActive": true }
+```
+
+Runtime `t:` ile başlayan mesajı anahtar sayar ve normal fallback zincirinden çözer (aktif dil →
+varsayılan dil → anahtarın kendisi); önek yoksa metin olduğu gibi gösterilir. Çözüm çalışma
+anında olduğu için şema varsayılanlarına dokunmak gerekmez.
+
 Geçerli `type` değerleri: `required` · `email` · `regex` · `max-length` · `min-length` ·
 `max-value` · `min-value` · `value-options`. Üç tuzak ölçüldü (crm koşumu B-9):
 
@@ -1268,18 +1556,29 @@ start → [setter] page_container.isLoading = true
           └─ else → [setter] CREATE etiketleri
 ```
 
-> **Condition adımı `always` dalını kural dallarıyla BİRLİKTE taşır.** `always` her hâlükârda koşar
-> (yükleniyor bayrağını kapatmanın yolu budur), kural dalları (`branch.name` = **rule id**) eşleşene
-> göre. `rules`: `{ id, expression, type:'if' }` + `{ id, expression:'', type:'else' }`.
+> **Condition adımı `always` dalını kural dallarıyla BİRLİKTE taşır** — ama `always` her hâlükârda
+> KOŞMAZ. Motor onu yalnız **eşleşen dalın** bitişinden çağırır:
+>
+> ```ts
+> // condition.ts — always'in TEK çıkışı eşleşen dalın callback'idir
+> engine.next(rule.id, { ...definition, completed: () => engine.next('always', definition) })
+> ```
+>
+> Yani şu üç hâlde `always` **hiç** koşmaz: `rules` boş · `rules[0].type !== 'if'` · hiçbir ifade
+> tutmuyor ve boş ifadeli bir `else` yok. **Yükleniyor bayrağını `always` ile kapatıyorsan
+> zinciri boş ifadeli `else` ile kapatmak ZORUNDASIN** — yukarıdaki iskelette `else` dalı tam da
+> bu yüzden var. `else`'siz bir zincirde ifade tutmazsa bayrak açık kalır ve sayfa sonsuza kadar
+> yükleniyor görünür. Gateway `FLOW-020` bunu uyarıyla söyler.
 >
-> **`rules[].id` GERÇEK bir GUID olmalı** — okunabilir bir ad (`"rule_ok"`) verirsen istek
-> `The JSON value could not be converted to System.Guid. Path: $.flow.steps[N].args.rules[0].id`
-> ile reddedilir. Dal adı da o GUID'in kendisidir (`branch.name === rule.id`), yani iki yerde de
-> okunabilir ad kullanamazsın.
+> Sözleşmenin tamamı (GUID id zorunluluğu, dal adı = rule id, `else` fallback kuralı, zincir
+> sırası) aşağıdaki tuzak 6'da.
 >
-> **Kural ifadesi patlarsa akış hata vermez, kuralı EŞLEŞMEMİŞ sayar** ve sessizce `else`'e
-> gider. Bu yüzden condition ifadeleri guard'lı yazılır — özellikle `Page.user` okuyanlar
-> (Kural 8).
+> **Kural ifadesi patlarsa kural EŞLEŞMEMİŞ sayılır** — `runCode` `undefined` döner,
+> `Boolean(undefined)` false'tur — ve zincir bir sonraki kurala, oradan `else`'e geçer. Ama bu
+> tamamen sessiz değildir: hata işaretlenir ve sıradaki `engine.next` onu tüketip **hata yolu
+> varsa akışı oraya saptırır** (`flow-engine.ts` `consumeExpressionError`), yani beklediğin dal
+> yerine `errorSteps` koşar. Bu yüzden condition ifadeleri guard'lı yazılır — özellikle
+> `Page.user` okuyanlar (Kural 8).
 
 **İki ayrı ucun sonucunu tek tabloya yazmak:** `mapping` tek kaynak alır, o yüzden birleştirmeyi
 `value.type: 'code'` ile yap — ilgisiz kayıtları da orada süz:
@@ -1337,20 +1636,24 @@ start → [setter] btn_save.isLoading = true
 
 - **Upsert deseni:** tek POST ucu hem create hem update yapar — `id` query-string'den, alanlar
   `source:'body'`'den. Entity başına iki uç yazmaya gerek yok.
-- **Hata yolunu `errorSteps` ile kurma**, `condition Steps.<adımAdı>.error` ile kur: `errorSteps`
-  ana akışın kalanını hiç çalıştırmaz, yükleniyor bayrağı açık kalır.
+- **Form akışında hata yolunu `condition Steps.<adımAdı>.error` ile kur**, `errorSteps` ile
+  değil: `errorSteps` ana akışın kalanını devralır, yani yükleniyor bayrağını kapatma · modal'ı
+  kapatma · tabloyu tazeleme adımlarını hata akışında yeniden kurman gerekir — kurmazsan bayrak
+  açık kalır. İki yolun karşılaştırması ve hata metninin nerede durduğu Kural 1c'nin §hata yolu
+  bloğunda.
 - Geri bildirim `notification` komponentiyle verilir (`kind` · `header` · `content` · `timeout` ·
   `showCloseButton` · `style`), `alert` adımıyla değil.
 
 > **`isHidden`: ŞEMAYA yazmak ile SETTER ile yazmak AYRI yollardır.** Runtime tarafı ortak:
 > `RenderComponent` her düğümü `{#if !props.isHidden}` ile çizer, yani akıştaki setter
-> `isHidden` yazınca komponent katalogda o prop'u tanımlamasa bile gizlenir. **Şema yolu ise
-> katalogla sınırlıdır:** `props.isHidden`'ı düğüme yazmak, komponent onu tanımlamıyorsa
-> `unknown-prop` ile REDDEDİLİR (81 kaydın 36'sı tanımlar; ölçüm 2026-08-25). Tanımlamayanlar
-> arasında sık kullanılanlar: **`text` · `table` · `datatable` · `dropdown` · `multi-select` ·
-> `tag-input` · `tabs` · `checkbox` · `switch` · `switcher` · `card` · `modal` · `drawer` ·
-> `repeater` · `notification` · `toast` · `datepicker` ailesi · `breadcrumb-title`.**
-> Tek doğru kaynak `component_get` + `page_schema_validate` kuru koşusudur.
+> `isHidden` yazınca komponent katalogda o prop'u tanımlamasa bile gizlenir. **Şema yolu
+> katalogla sınırlıdır** ama artık neredeyse her komponent tanımlıyor: **101 kaydın 99'u**
+> (ölçüm 2026-09-08; 2026-08-26'daki toplu ekleme öncesi 81'de 37 idi). Tanımlamayan yalnız
+> iki kap var: **`slot` · `widget-area`** — onların içindekini gizlemek için sarmalayıcı
+> kullan. Eskiden tanımlamayan `text` · `table` · `datatable` · `dropdown` · `multi-select` ·
+> `tag-input` · `tabs` · `notification` · `toast` · `datepicker` ailesi gibi komponentlere
+> artık doğrudan `props.isHidden` yazılabilir; sırf gizlemek için `container`'a sarmak
+> GEREKMEZ. Tek doğru kaynak `component_get` + `page_schema_validate` kuru koşusudur.
 >
 > **`appearance.isHidden` bir kaçış yolu DEĞİLDİR:** kaydedilir ama runtime hiçbir yerde okumaz
 > (renderer yalnız `props.isHidden`'a bakar) — komponent görünmeye devam eder. Başlangıçta gizli
@@ -1540,6 +1843,21 @@ hiçbiri** bağlı değildi; üç portalın da rol menüsü boş çıkıyor, pan
 > `Host: <org>.<suffix>` + `X-Environment` başlıklarıyla. Ham `curl` yerine tool'u kullanmak
 > yeterlidir.
 >
+> **Yerleşimi görüntüsüz ölçmek.** Taşma/çakışma şüphesinde `page_screenshot(layoutReport: true)`:
+> `layoutSummary.overflowing` boş değilse içeriğine sığmayan kutu, `outsideViewport` boş değilse
+> hiç görünmeyen düğüm var; `zeroSized` çizilmemiş komponenti gösterir. Runtime düğümleri
+> `data-element-id` basmıyorsa yanıt `layoutReportUnavailable` der — tool tahmin üretmez.
+>
+> **Üye kimliğiyle doğrulama (`asUser`).** Kapının kapalı olduğunu görmek yarısıdır; açık
+> olduğunu görmek diğer yarısı. `page_runtime_get` ve `page_screenshot` aynı `asUser` alanını
+> alır: uygulamanın kendi giriş ucundan (`microservice_execute`) aldığın üye jetonunu verirsin,
+> gateway o jetonu **hem `Authorization` başlığında hem `NG_AccessToken` çerezinde** taşır.
+> Çerez okuyan bir middleware ile başlık okuyan bir middleware aynı çağrıdan geçer — iki tool da
+> aynı kimlik kanalını kullanır. `page_screenshot` ayrıca `cookies: {ad: değer}` ile uygulamanın
+> kendi oturum çerezlerini enjekte eder. `asUser`/`cookies` ile `anonymous` birlikte verilemez;
+> gateway'in servis jetonu (varsayılan kimlik) uygulamanın `users` tablosuna çözülmeyebilir —
+> korumalı sayfada boş panel görüyorsan önce `identity` alanına bak, sonra `asUser` ile tekrarla.
+>
 > `page.roleIds` bu dalla birlikte de kapı değildir: rol ayrımını sayfa değil **uç** yapar.
 
 > **Rol okurken dizi bekleme.** `set-user` DTO'su `roles` dizisini çoğu kurulumda düşürür
@@ -1603,6 +1921,24 @@ micro-op hattına dönün.
 > setter'ı sessizce hiçbir şey yazmadı — sayfa boş liste ile açıldı, konsolda hata yok.
 > `flow_update` ile aynı gövdeyi yeniden kaydetmek düzeltti. Kural: **şemadan bir düğüm sildiysen,
 > o düğümü hedefleyen her flow'u yeniden kaydet.**
+>
+> **Akış silen yama artık istek gönderilmeden REDDEDİLİR.** Platform referanssız kalan akışı
+> KALICI siler; uyarı yamadan sonra geldiğinde "önce yedekle" tavsiyesi uygulanamıyordu (09-05
+> koşusunda sekiz adımlı giriş akışı sıfırdan yeniden yazıldı). Aynı kontrol `set_event` ve
+> `remove_event` için de çalışır — bir olayın bağını değiştirmek de akış öldürür ve o yolda hiç
+> uyarı yoktu. Silinmesini bilerek istiyorsanız çağrıyı `allowFlowDeletion: true` ile tekrarlayın;
+> yanıt `deletedFlows` ile hangi akışların gittiğini listeler.
+>
+> **FLOW-018 artık silinen düğümün ALT AĞACINI da görüyor.** Eskiden yalnız op'un kendi
+> `target`'ına bakılıyordu: bir kapsayıcı silinince ÇOCUĞUNA yazan setter sessizce kopuyor ve
+> uyarı hiç çıkmıyordu (09-05, `sign_in_form` → `btn_sign_in`).
+>
+> **Gateway artık bunu söylüyor (FLOW-018).** `remove_component` içeren bir yamada gateway sayfanın
+> akışlarını okur ve silinen düğümü hedefleyen setter adımlarını uyarı olarak listeler: hangi akış,
+> hangi adım, hangi hedef. Uyarıyı gördüğünde yapılacak tek şey `flow_update` ile aynı gövdeyi
+> yeniden kaydetmektir. Ters yönü (`silinen düğümün referans verdiği` akışların platformca kalıcı
+> silinmesi) ayrı bir uyarı kapsar; ikisi birlikte çıkabilir. Ölçüm 2026-09-04 (benchmark 4. koşu):
+> uyarı yokken aynı tuzak ~8 dakika teşhis aldı ve yalnız ekran görüntüsüyle görüldü.
 
 ## Bilinen sınırlar
 
@@ -1667,10 +2003,11 @@ micro-op hattına dönün.
   `isHidden` prop'u yok (Kural 1g'deki sarmalayıcı çözümü). Bir prop'u kullanmadan önce
   `component_get`'e bak; eksikse ürün sahibine katalog güncellemesi olarak bildir.
 
-- **`container.title` `states.isWrapper: true` iken başlık ÇİZMEZ.** Wrapper kaplar salt düzen
+- **`container.title` varsayılanı boştur ve `states.isWrapper: true` iken başlık ÇİZMEZ.** Başlıksız
+  normal container da `__header` bloğu üretmez; bant istiyorsan `title` değerini açıkça yaz.
+  Wrapper kaplar salt düzen
   elemanıdır; başlığı da `__header` bloğunu da render etmez (klinik ölçümü: `__header` sayısı 0).
-  `isWrapper: false` olan kapta başlık normal çizilir (İK ölçümü: başlık verilmeyen kapta
-  varsayılan "Container title" göründü). Kart başlığını garantiye almak istiyorsan kabın
+  `isWrapper: false` olan ve başlığı açıkça verilen kapta başlık normal çizilir. Kart başlığını garantiye almak istiyorsan kabın
   `title`'ına güvenme, **içine bir `text` komponenti** koy.
 - **Kod prop'unun ifadesi `ref`'te ve `{{ }}` sarılı olmalı.** `{type:'code', ref:"'' + Row.value"}`
   (süssüz) ekrana ifadenin **kendisini** basar; ifade yalnız `data`'da olursa prop **boş**