@appaflytech/zeyrek-ai-mcp 0.0.1

package/dist/resources/guides/page.md

@@ -0,0 +1,1574 @@
+# Sayfa Tasarımı Rehberi (page, layout, component, flow)
+
+Studio'nun tuval tarafı. Buradaki kurallar controller + komut kodundan doğrulandı
+(`zeyrek-mcp/docs/13-faz2-envanter.md` §4); veri/mantık tarafı için
+`platform_guide('entity')`, `('microservice')`, `('workflow')`.
+
+## Kuruluş sırası
+
+```
+1. layout_list / layout_create   (layout isteğe bağlı; sayfalar layoutId ile bağlanır)
+2. role_list                     (roleIds'i buradan oku — rol id'si TAHMİN EDİLMEZ)
+3. component_list / component_get (konulacak tipin prop sözlüğü + boyut sınırları)
+4. page_create                   (şemasız aç; şema micro-op hattından kurulur)
+5. page_state                    (değişkenler, komponentler, layout slotları, ms imzaları)
+6. page_schema_patch             (bütün add_component'ler — tek çağrıda)
+7. page_schema_patch             (tema + stil: page_container.style'da --ng-* ve komponent
+                                  style'ları; ifadeye bağlı prop'lar için set_binding)
+8. flow_create × N               (BÜTÜN akışlar — bağlı akış varken yenisi eklenemez, Kural 3)
+9. page_schema_patch             (bütün set_event'ler tek çağrıda)
+10. page_get + page_runtime_get  (doğrulama: bağlar doğru mu, son hâl nasıl çiziliyor)
+```
+
+**Ekranın tipi hangi kuralı okuyacağını belirler:** alanları tasarım anında bilinen klasik form
+→ Kural 7a; **alan sayısı/tipi veriden geliyorsa** (anket, dinamik başvuru) → **Kural 1g**
+(`repeater`, `html`'e gerek yok); görsel kalite ve marka teması → **Kural 1h** (hazır stil
+blokları 1h-3'te).
+
+## Kural 1 — Komponent gövdesinin şekli (`DesignComponentManagementSchema`)
+
+Sayfa şeması **micro-op hattından** kurulur; `page_create`'e satır içi `schema` vermek de
+mümkündür ama doğrulama duvarı ve canlı canvas yalnız `page_schema_patch`'te çalışır.
+
+```jsonc
+{ "elementId": "page_header_1", "kind": "component", "type": "<component_list slug'ı>",
+  "name": "Page header",
+  "props":  { "pageTitle": { "type": "static", "data": "Branşlar" } },
+  "states": { "isSticky": false, "isDroppable": false, "isScrollable": false, "isWrapper": false },
+  "blocks": [{ "breakpoint": 1024, "size": { "h": 4, "w": 12 }, "position": { "x": 0, "y": 0 } }],
+  "children": [], "events": [], "validations": [], "stateBindings": [] }
+```
+
+- **`props` düz sözlük DEĞİL:** her değer bir `Prop` nesnesidir ve alanları `type` / `ref` /
+  `data`'dır — **`value` diye bir alan yoktur.** Static prop için `{ "type": "static", "data": … }`
+  yaz; `{ "value": … }` yazarsan platform sessizce boş prop kaydeder
+  (`DesignComponentProperty.SetRef` static'te `value.Data` okur).
+- **Prop'un içi de Prop'tur (özyinelemeli).** Bir Prop'un `data`'sı nesne ya da dizi ise
+  platform içini **her seviyede** `Dictionary<string, Prop>` olarak çözer
+  (`CreateProp` object/array dalları) — düz bırakılan iç değer `JsonException … could not be
+  converted to Prop` verir. Skaler dizi (`[1,2,3]`) hiçbir biçimde desteklenmez. Doğru şekil
+  (header `navigation` örneği — iç `icon` nesnesinin İÇİ de sarılı):
+
+  ```jsonc
+  "navigation": { "type": "static", "data": [
+    { "title": { "type": "static", "data": "Kitaplar" },
+      "href":  { "type": "static", "data": "/kitaplar" },
+      "icon":  { "type": "static", "data": {
+        "name":  { "type": "static", "data": "book" },
+        "color": { "type": "static", "data": "#0052CC" } } } }
+  ] }
+  ```
+
+  **Gateway eksik sarımı kendisi tamamlıyor** (`gatewayNormalized`: "iç değerler Prop'a
+  sarıldı") — düz `{name, color}` yazsan da düzeltilir; ama ham HTTP kullanıyorsan bu kural sana ait.
+  Sarım `add_component` / `replace_prop` op'larında, `page_create`/`page_update` ve `layout_*`
+  gövdelerinde ve artık `page_schema_validate` KURU KOŞUSUNDA da uygulanır (crm koşumu B-11'de
+  kuru koşu ile yazma farklı davranıyordu; ikisi eşitlendi). Platformun kendisi sarmıyor:
+  `columns` · `colorMap` · `actions` · `options` gibi **dizi prop'larının her yaprağı**
+  `{ type:'static', data: … }` olmak zorunda, aksi hâlde `to-domain: The JSON value could not be
+  converted to … Prop. Path: $.name` alırsın (hata komponenti/prop'u söylemez).
+- **Enum'lar küçük harf** (`StringEnumConverter` + `[Description]`): `kind` → `component` |
+  `widget`, prop `type` → `static` | `file` | `flow` | `widget` | `element` | `page` | `code`.
+- **Sayfaya bağlanan prop'larda (link/yönlendirme) URL yazma, `type: 'page'` + `ref: <pageId>`
+  kullan.** Platform slug'ı kendisi çözer (`Prop(PropValueType.Page)` → `Ref = RedirectPageId`,
+  `Data = RedirectPage.Slug`). Sabit `'/hastalar'` yazarsan sayfa slug'ı değişince bağlantı
+  sessizce kırılır; `pageId` referansı değişiklikten etkilenmez. Aynısı `flow` prop'u için
+  `type: 'flow'` + `ref: <flowId>`, dosya için `type: 'file'` + `ref: <fileId>`.
+- **`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.
+- **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`
+  / `page_update` o servisten geçmez, yani verdiğin koordinatlar olduğu gibi kayda girer ve tuvalde
+  komponentler üst üste biner. **Gateway aynı algoritmayı şemanın tamamına uyguluyor** (kök dizi +
+  her `children`, yalnız desktop `blocks[]` girdisi; `x`/`w`/`h` ve dizi sırası korunur, çakışanın
+  `position.y`'si aşağı kayar) ve yanıtta `gatewayNormalized: "çakışan komponentler ızgarada aşağı
+  kaydırıldı (…)"` ile bildiriyor. Kökteki `modal`/`drawer` katmanları sayfa akışında durmadığı için
+  hariç. Aynı hücreyi paylaşan komponentlerden hangisinin üstte kalacağı garanti değil — konumu sen
+  doğru ver, düzeltme yalnız emniyet kemeri.
+- **Zorunlu alanlar:** `states` her yolda, `events` / `validations` / `stateBindings` ise
+  **micro-op yolunda** (`page_schema_patch`). `states` için sebep açık:
+  `DesignComponentManagementSchema.ToDomain:47` guard'sız okur, `Appearance`'ın varsayılanı var
+  `States`'in yok. Diğer üçünü `page_create` (POST /pages) tolere ediyor ama `PATCH …/schema`
+  etmiyor — canlı deneyde üçü **birlikte** verilince geçti, her biri **tek başına** verilince
+  `NullReferenceException` aldı. **Gateway hepsini senin yerine dolduruyor**
+  (`page_create`/`page_update`/`page_schema_patch`, `layout_create/update`,
+  `component_create/update`) ve yanıtta `gatewayNormalized` ile bildiriyor; yani elle yazman
+  gerekmiyor, ama ham HTTP kullanıyorsan bu farkı bilmen gerekir.
+
+> **`page_schema_validate`'e tek başına güvenme.** `ValidatePageSchemaQuery` yalnız micro-op'ları
+> uygulayıp şema kurallarını denetler, `ToDomain`'e hiç girmez — eksik `states`'li bir gövdeye
+> `{"valid":true}` der, yazma yolu ise patlar. Gövde tamamlandığında ise doğrulayıcı işini
+> düzgün yapar (boyut/hedef hatalarını açık mesajla verir).
+
+## Kural 1b — `page_build` YOK
+
+Entity'den otomatik sayfa üreten `page_build` tool'u **kaldırıldı**. Platformun
+`POST /pages/{app}/build/{page}` ucu üretimi `PageBuilderApiOptions:Url` adresindeki **ayrı bir
+servise** delege ediyor (`PageBuilderApiClient`); dev'de `localhost:4000`, prod'da `studio-api…`.
+O servis bu ürünün parçası değil ve ayakta olmayabilir. Sayfa/komponent şemasının tam karşılığı
+platformda zaten var → doğru yol yukarıdaki micro-op hattıdır.
+
+## Kural 1c — Komponente VERİ bağlama: `mount` olayı + flow (setter adımı)
+
+Tablonun/listenin satırları şemaya "dataSource" yazarak değil, **flow ile** doldurulur. Desen:
+
+```
+1. component_get  → komponentin EVENT listesini oku (event'ler komponente özeldir, tahmin edilmez)
+2. flow_create    → start → microservice → setter → end
+3. page_schema_patch set_event → akışı ilgili olaya bağla
+```
+
+**Event'ler komponent tipine göre değişir; `component_get`'in `events` alanından okunur.**
+Sayfa açılışında veri çekmek için `mount` kullanılır ama tek seçenek o değil — örneğin `table`
+8 olay yayar:
+
+`mount · pagination · filter · sort · select · selectionChange · doubleClick · rowChange`
+
+Yani "satırı seçince detay getir" (`select`), "kolondan süzünce sunucudan yeniden çek"
+(`filter`), "sayfa değişince yeni sayfayı çek" (`pagination`), "satıra çift tıklayınca formu aç"
+(`doubleClick`) akışları da aynı `set_event` mekanizmasıyla kurulur. Buna karşılık `page-header`
+ve `datatable` yalnız `mount` yayar (`datatable`'ınki bilinçli — Kural 1e).
+
+**Olay adları `on` ÖNEKİ ALMAZ** (`button` → `click`, `form` → `submit`), tek istisna katalogda
+`texteditor`'dur (`onMount`/`onChange`). **Komponentin desteklemediği bir olay adı verirsen bağ
+sessizce ölü kalır** — önce `component_get`. Gateway `set_event`'i katalogla karşılaştırır ve
+uymayan adı **PAGE-008** ile istek gitmeden reddeder.
+
+**Olay KALDIRMAK için `remove_event` kullan.** Platformun `set_event` micro-op'u olay silemez:
+`eventValue: null` verildiğinde kayıt `{ name: 'click' }` olarak (değersiz) kalır, diziden
+çıkmaz — şemada ölü bağ artığı bırakır. `{ "op": "remove_event", "target": "<elementId>",
+"event": "click" }` gateway emülasyonudur: şemayı okur, olayı diziden çıkarır ve sayfayı tam
+gövdeyle geri yazar (yanıtta `removedEvents`). Sayfa düzeyi olaylar için `target: "page"`.
+
+**Olay YÜKÜ komponente özeldir ve `component_get` onu da veriyor** (`events[].payload`, gerekirse
+`events[].reads`) — **ama yük akışa `event.data` ile GELMEZ.** Motor emit'in `data`'sını önce
+komponentin KENDİ prop'una yazar (`FlowMachine.onEmit` → `setNode`), akışı ise emit'in
+`params`'ıyla başlatır; ifade kapsamındaki `event.data` `params.data`'dır ve komponent
+olaylarında **boştur** (ölçüm 2026-08-25, kaynak okuması: `flow-machine.ts:299-318` +
+`flow-execution.functions.ts:236`; `Table.svelte:292` kendi yorumunda aynı şeyi söylüyor).
+
+Pratik kural: **`payload` anahtarları aynı zamanda prop adlarıdır; akışta `self.<anahtar>` ile
+oku** (ya da `value { type:'property', ref:{ source:'component', element, property } }` ile).
+`event.data` yalnız `params` ile gelen olaylarda dolar — pratikte `html` komponentinin
+`fireEvent` aksiyonları (`platform_guide('html')`). Sessiz hata örneği: sayfalama akışını
+`event.data.limit`'e bağlarsan sorgu `LIMIT null OFFSET null` ile koşar ve **tüm satırları**
+döndürür; hata yok, sayfalama yok.
+
+| Komponent · olay | Yük (aynı zamanda prop adları) | Akışta nereden okunur |
+|---|---|---|
+| `table.sort` | `{ sortField, sortType, offset }` | `self.sortField` · `self.sortType` · `self.offset` |
+| `table.filter` | `{ filters, offset }` | `self.filters` · `self.offset` |
+| `table.pagination` | `{ offset, limit }` | `self.offset` · `self.limit` |
+| `table.select` · `doubleClick` | — | `self.selectedRow` |
+| `table.selectionChange` | — | `self.selectedRows` |
+| `datatable.mount` | — | `self.filters` · `self.sortField` · `self.sortType` · `self.offset` |
+| `pagination.change` | `{ offset, limit }` | `self.offset` · `self.limit` |
+| `textinput/textarea/password.change` | `{ value }` | `self.value` |
+| `dropdown.change` · `multi-select.change` | `{ value }` | `self.value` |
+| `dropdown.search` · `multi-select.search` | `{ searchText }` | `self.searchText` |
+| `tabs.tab` | `{ selected }` | `self.selected` |
+| `chart.dataPointClick` | `{ name, seriesName, value, dataIndex, row }` | `self.row` (kaynak satırın tamamı) |
+| `repeater.change` | `{ selectedIndex }` | `item` / `Row` satır bağlamı |
+| `html` aksiyonu (`fireEvent`) | ikinci argüman | **`event.data`** (tek istisna) |
+
+Adım gövdesi `StepManagementSchema`: `{ stepId, name, type, kind, args, branches }`.
+**`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
+ö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` →
+`always` (eski akışlarda `success` de çalışır).
+
+**2. `iteratees[].type` yalnız `change` | `fill`.** `setter.ts` başka değerde hiçbir dala
+girmez — adım çalışır, hiçbir şey yapmaz. `change` tek prop'a değer yazar, `fill` diziyi
+`mapping` ile eşleyerek yazar.
+
+**3. Storage anahtarı adımın ADIdır, `stepId` değil.** Sonuç `setStorage(task.name, …)` ile
+yazılır; `isRaw: false` iken sarmal `{ data, headers, error }` olduğu için ref
+`"<adım adı>.data"` olur. Adım adında **nokta kullanmayın** (okuma dot-prop ile yapılır).
+Kod ifadesinden okuma biçimi `Steps["<adım adı>"].data`'dır; `value.type: "code"` + ref olarak
+düz `stepId` yazmak tanımsız değişken hatası verir. **Anahtarı iki yerden verebilirsin ve
+öncelik `mapping.source`'tadır:** doluysa `value.ref`'e hiç bakılmaz (`setter.ts:161`) — satır
+eşlemeli tablo yazımında Studio'nun ürettiği şekil de budur (`mapping.source: "<ad>.data"`,
+`value.ref: ""`). İkisini birden doldurma.
+
+**4. Hata yolunda storage sarmalında `headers` YOKTUR.** Başarıda `{ data, headers, error }`,
+hatada `{ error, data }` yazılır (`microservice.ts:132`). Bu yüzden toplam kayıt sayısını
+guard'sız okumak (`Number(Steps.get_service.headers["total-count"])`) istek patladığı anda
+TypeError verir: prop'a `NaN` yazılır, ifade hatası toast'ı düşer ve akış `onError`'a düşebilir.
+Doğrusu `Number(Steps.get_service?.headers?.["total-count"] ?? 0)`. Header adı backend'de
+`Total-Count`'tur, axios anahtarları küçük harfe indirir → `"total-count"`.
+
+**5. `mapping.mappings` anahtarı satıra DÜZ yazılır.** `object[key] = …` (`setter.ts:83-104`) —
+`"parent.name"` anahtarı `row["parent.name"]` üretir, `row.parent.name` üretmez. Kolonun kendi
+key'ini düz anahtar ver, iç içe yolu `ref`'e yaz: `"parent_name": { "type": "item", "ref":
+"parent_title.name" }`. Anahtar kümesini tablonun gerçek kolonlarıyla sınırlı tut; her fazladan
+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.
+
+```jsonc
+// akışı başlatan adım — dal adı 'always' olmak zorunda
+{ "stepId": "start", "name": "Start", "type": "start", "kind": "normal", "args": {},
+  "branches": [{ "id": "<GUID>", "name": "always", "nextStepId": "load_specialties" }] }
+
+// veriyi çeken adım
+{ "stepId": "load_specialties", "name": "Branşları getir", "type": "microservice", "kind": "normal",
+  "args": { "microserviceId": "<ms id>", "isRaw": false, "parameters": [] },
+  "branches": [{ "id": "<GUID>", "name": "always", "nextStepId": "set_rows" }] }
+
+// prop'a yazan adım
+{ "stepId": "set_rows", "name": "Tabloya yaz", "type": "setter", "kind": "normal",
+  "args": { "iteratees": [{
+      "id":       "<GUID>",
+      "type":     "change",                      // yalnız change | fill
+      "element":  "specialties_table",           // hedef komponentin elementId'si
+      "property": "rows",                        // component_get'teki prop adı
+      "source":   "component",
+      "mapping":  { "source": "", "mappings": {} },   // storage okurken zorunlu, boş da olsa
+      "value":    { "type": "storage", "ref": "Branşları getir.data" } }] },  // kaynak adımın ADI
+  "branches": [{ "id": "<GUID>", "name": "always", "nextStepId": null }] }    // son adım: null
+```
+
+> **`element` ve `property` İKİSİ DE zorunludur — biri eksikse adım sessizce ölür.** `setter.ts`
+> `change()` ve `fill()` her dalda `machine.setNode(element, { [property]: value })` çağırır;
+> `element` boşken çağrı hiçbir düğüme denk gelmez: **adım çalışır, hata vermez, hiçbir şey
+> yazmaz.** Platform gövdeyi 200 ile kabul eder (alan serbest string) ve Studio adımı çizer —
+> ekranda "değer girilmiş ama hedef seçilmemiş" bir adım görürsün. Ölçüm (anket-spike,
+> 2026-08-19): `html` komponentine `context` yazan iki akış da yalnız bu yüzden hiç çalışmıyordu.
+> Platform bu alanları doğrulamaz; tek savunma gateway'in **FLOW-017** kuralıdır — gövdeyi istek
+> göndermeden reddeder. `element` değerini `page_schema_get` çıktısındaki `elementId` ile doğrula,
+> uydurma.
+
+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:
+
+```jsonc
+// toplam kayıt — guard'sız yazarsan hata yolunda patlar
+{ "type": "change", "element": "titles_table", "property": "totalRows", "source": "component",
+  "mapping": { "source": "", "mappings": {} },
+  "value": { "type": "code", "ref": "Number(Steps.load_titles?.headers?.[\"total-count\"] ?? 0)" } }
+
+// satırlar — anahtar mapping.source'ta, mapping anahtarları DÜZ ve kolon key'leriyle birebir
+{ "type": "change", "element": "titles_table", "property": "rows", "source": "component",
+  "mapping": { "source": "load_titles.data", "mappings": {
+      "name":        { "type": "item", "ref": "name",              "propertyType": "text" },
+      "parent_name": { "type": "item", "ref": "parent_title.name", "propertyType": "text" },
+      "status":      { "type": "code", "ref": "Row.status === 'Active' ? 'Aktif' : 'Pasif'", "propertyType": "text" } } },
+  "value": { "type": "storage", "ref": "" } }
+```
+
+`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' }`).
+
+Zorunlu filtresi olan uçlarda (`patient-*`, `doctor-appointments` gibi `isRequired: true`
+filtreli microservice'ler) parametreyi adımda ver, yoksa uç `MissingParameterException` atar:
+
+```jsonc
+"parameters": [{ "name": "patient_id", "type": "guid", "source": "query-string",
+                 "value": { "ref": "<hasta id>", "type": "static" } }]
+```
+
+Gerçek uygulamada `static` yerine sayfa değişkeni / route parametresi kullanılır
+(`variable_create` + `value.type: 'variable'`). **Kullanıcıya özel veri çeken uçlarda
+(hasta/doktor/oturum sahibi) kalıcı çözüm parametre DEĞİL middleware'dir:** uca auth
+middleware'i bağlanır, filtre `source:'expression'` + `value:'user.id'` olur — kimlik
+istemciden gelmediği için sahtelenemez ve sayfada sabit id tutmak gerekmez. Sayfanın kendisi de
+`page_create/update` `middlewareIds` ile korunur (girişsiz kullanıcıyı login'e yönlendirme).
+Tarif: `platform_guide('middleware')`.
+
+**`flow-trigger` adımının İKİ geçerli şekli var** (`flow-trigger.ts`; başka şekil sessizce hiçbir
+şey yapmaz, ikisi de yoksa kayıt 404 döner):
+
+```jsonc
+// (1) başka bir akışı çalıştır — "kaydettim, listeyi yenile"
+{ "stepId": "reload_list", "name": "reload_list", "type": "flow-trigger", "kind": "normal",
+  "args": { "flowId": "<hedef flow id>" },
+  "branches": [{ "id": "<GUID>", "name": "always", "nextStepId": null }] }
+
+// (2) bir komponentin OLAY akışını çalıştır — Studio'nun ürettiği şekil budur
+{ "stepId": "refresh_table", "name": "refresh_table", "type": "flow-trigger", "kind": "normal",
+  "args": { "triggerElementId": "tickets_table", "triggerElementEvent": "mount" },
+  "branches": [{ "id": "<GUID>", "name": "always", "nextStepId": null }] }
+```
+
+- İkisi birden verilirse runtime **yalnız `flowId`'ye** bakar, element dalına hiç girmez.
+- (2)'de `triggerElementId` sayfadaki bir **elementId**'dir ve `triggerElementEvent` o komponentin
+  **gerçekten yaydığı** bir olay olmalı; ayrıca o olayın bir akışa bağlı olması gerekir
+  (`events[].value` dolu), yoksa çalıştıracak bir şey bulunamaz.
+- Adım hedef akışı **bekler** (`await engine.run`), sonra `always` dalından devam eder.
+- Gateway boş/yarım `args`'ı **FLOW-014** ile yakalar.
+
+**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`
+
+> `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
+> **`platform_guide('expressions')`** — uydurma erişim adı sessizce `undefined` üretir.
+
+> Bir microservice adımı kaydedildiğinde platform `args.microserviceSchema`'yı
+> (parameterScheme + returnScheme + `isReturnArray`) kendisi doldurur — `flow_get` ile geri
+> okuyunca hangi alanların döndüğünü oradan görürsün.
+
+**Sayfalama üç parçadır; biri eksikse tablo sessizce tek sayfa kalır.** Uç `limit`/`offset`'i
+**query-string'den** okur (`sourceParameters.limit: { name, offset, source }`) ve
+`TableMicroserviceExecutor.cs:178` sayfalamayı **yalnız limit doluysa** uygular — parametre
+geçmezsen sunucu her çağrıda tüm kayıtları döndürür, `pagination` olayı yeni sayfa çekemez.
+Gereken üçlü:
+
+```jsonc
+// 1) akışta: uca tablonun kendi prop'larını geçir
+"parameters": [
+  { "name": "limit",  "type": "text", "source": "query-string",
+    "value": { "type": "property", "ref": { "source": "component", "element": "blog_table", "property": "limit" } } },
+  { "name": "offset", "type": "text", "source": "query-string",
+    "value": { "type": "property", "ref": { "source": "component", "element": "blog_table", "property": "offset" } } }
+]
+// 2) şemada: { "op": "replace_prop", "target": "blog_table", "prop": "isPaginated", "value": true }
+// 3) şemada: { "op": "set_event",   "target": "blog_table", "event": "pagination", "eventValue": "<load flow id>" }
+```
+
+Toplam kayıt sayısı `Total-Count` header'ından gelir (`TableMicroserviceExecutor.cs:201`, uç
+`isSingle: false` olduğu sürece) — `totalRows`'u yukarıdaki guard'lı ifadeyle yaz. Gateway
+parametreleri geçmeyi unutursan `FLOW-013` ile uyarır.
+
+> **`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
+> çözmeye çalışıp **500 JsonException** verir. Doğrusu `"value": true`; kod prop'u için `value`
+> değil `expression` alanı kullanılır. (Gateway her ikisini de düzeltip `gatewayNormalized` ile
+> bildirir, ama ham HTTP'de bu kural sana ait.) `add_component`'te ise sarmal ZORUNLUdur — iki
+> op'un şekli birbirinin tersidir, karıştırma.
+
+## Kural 1c-2 — Komponentin `name`'i JS TANIMLAYICISI olmalı (yoksa sayfadaki tüm ifadeler ölür)
+
+Runtime, ifade çalıştırmadan önce sayfadaki **her** komponent için bir değişken üretir:
+
+```js
+const <komponentin name'i> = Components["<komponentin name'i>"];
+```
+
+`name` geçerli bir JS tanımlayıcısı değilse (boşluk, nokta, birden çok tire…) üretilen satır
+sözdizimi hatası olur ve **o sayfadaki BÜTÜN ifadeler** — condition kuralları, `value.type:'code'`
+ref'leri, `code` adımları — tek seferde ölür:
+
+```
+Expression error: Missing initializer in const declaration in <senin ifaden>
+```
+
+Belirti kafa karıştırıcıdır: hata **ifadeyi** gösterir, oysa suçlu bambaşka bir komponentin adıdır.
+Ölçüm (2026-08-18, `ik`): `name: "Giriş Kutusu"` yüzünden giriş sayfası hiç çalışmadı — servis 200
+dönüyor, condition patlıyor, kullanıcı yönlenmiyordu.
+
+**Kural:** `name` **her zaman `elementId` ile aynı** olsun (`btn_login`, `tbl_mng`). Okunabilir
+Türkçe başlık `props.title` / `props.text` / `props.label` / `props.pageTitle` içine yazılır —
+`name` bir etiket değil, **değişken adıdır**.
+
+> **Layout adları her sayfaya sızar.** Layout'un komponentleri de aynı `const` listesine girer;
+> layout'ta tek bir bozuk ad, o layout'a bağlı **her** sayfayı öldürür. `layout_update` yaparken de
+> `name = elementId` kuralı geçerlidir.
+>
+> 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.
+
+## Kural 1d — Sayfa iskeleti: `page_container` ve boyutlandırma
+
+**Her sayfada `page_container` adlı bir kapsayıcı vardır ve silinmez.** Komponentler köke değil
+**onun `children`'ına** eklenir:
+
+```jsonc
+{ "op": "add_component", "parent": "page_container", "component": { … } }   // ✔
+{ "op": "add_component", "parent": "root",           "component": { … } }   // ✘ kapsayıcı dışında kalır
+```
+
+`page_container` bir `container`'dır (`isWrapper: true`, `isDroppable: true`,
+`isScrollable: true`, `appearance.heightType: 'auto'`). `container`, `form` ve `repeater` de aynı
+şekilde kapsayıcıdır — onların içine de `parent` vererek eklenir.
+
+Sayfa düzeyi olaylar (page load vb.) **bu kapsayıcıya** bağlanır:
+`set_event { target: 'page_container', event: 'mount', eventValue: <flow id> }`.
+`page_container`'ın kendi `isLoading` prop'u vardır — sayfa açılış akışında yükleniyor bayrağı olarak
+onu kullan. Bir `container` olduğu için **düzen prop'larını da alır**: çocuklarını ızgara yerine
+akışla (ortalama, sağa yaslama, aralık) dizmek istiyorsan `layout: 'flex'` — Kural 1f-2.
+
+**Tek istisna `modal` ve `drawer`:** onlar `page_container`'ın içinde değil, şemanın **kökünde**
+kapsayıcının kardeşi olarak yaşar (qm `[SY] Profil bilgilerim`: `page_container`, `drawer_personel`,
+`mdl_parolayi_guncelle` aynı seviyede). Modal içeriği (kendi formu ve `submit` akışı dahil) modalın
+`children`'ına eklenir. Diğer her komponent kapsayıcıya girer.
+
+> `page_create` sayfayı boş şemayla açar; **gateway `page_container`'ı senin için ekler** ve
+> yanıtta `gatewayNormalized` ile bildirir. `page_schema_get` ile geri okuduğunda ilk düğüm odur.
+
+**Boyut:** `w` 12'lik ızgaradadır. Yükseklikte belirleyici alan `size.h` değil
+`appearance.heightType`'tır:
+
+- **`auto`** — kutunun yüksekliği İÇERİKTEN gelir; Studio tuvalde ölçtüğü yüksekliği
+  `blocks[].size.h`'e geri yazar ve kardeşleri aşağı iter (`ResizeObserver` → `shrinkOrExpand`).
+  Verdiğin `h` yalnız bir başlangıç tahminidir, kırpma yapmaz.
+- **`fixed`** — kutu tam `size.h * 10px` çizilir ve **taşan içerik KESİLİR**
+  (`.draggable__item-component { overflow: hidden }`). Yalnız bilerek sınırlamak istediğinde ver.
+
+> **Gateway bunu senin için yazıyor (PAGE-014).** Platform `appearance` verilmemiş gövdede
+> yüksekliği `fixed`e sabitler — Studio ise komponentin katalogdaki `isDefaultAutoHeight`
+> değerine bakar. MCP hattında oluşan tüm sayfalar bu yüzden kırpılmış çiziliyordu; gateway artık
+> yazma yollarında (`page_create` · `page_update(schema)` · `page_schema_patch(add_component)` ·
+> `layout_*(views)` · `component_*(schema)`) her düğüme katalog varsayılanını damgalar ve
+> `gatewayNormalized` ile bildirir. Senin verdiğin `appearance.heightType`'a dokunmaz.
+>
+> Katalogda `isDefaultAutoHeight: false` olan (yani `fixed` damgalanan) tipler: `auth-layout`,
+> `html`, `image`, `layout`, `qrcode`, `table`, `text-editor`, `video`. Diğer her tip `auto`'dur.
+> Bu tiplerde `size.h` gerçek yüksekliktir — göz kararı değil, içeriğe göre hesapla
+> (bir satır ≈ 10px; Kural 1f).
+
+## Kural 1d-2 — Sayfanın ve layout'un KENDİ olayları: `mount` · `destroy`
+
+Komponent olaylarından AYRI olarak sayfa ve layout kayıtları kendi olay listesini taşır
+(`events: [{ name, value: <flow id> }]`) ve geçerli adlar SABİTTİR: **`mount`**
+(yüklendiğinde) ve **`destroy`** (sayfadan/layouttan ayrılırken — runtime destroy akışlarını
+navigasyondan ÖNCE koşar). Başka ad platformca kabul edilir ama bağ sessizce ölü kalır —
+gateway **PAGE-011 / LAY-004** ile istek gitmeden reddeder.
+
+- Bağlama yolu `set_event` DEĞİLDİR (o komponent hedefler): sayfada `page_create` /
+  `page_update`'in `events` parametresi, layout'ta `layout_create/update`'in `events`'i.
+- Sayfa açılış akışı için yerleşik desen `page_container.mount`'tur (Kural 1d) — ikisi de
+  çalışır; **`destroy` için tek yol buradaki sayfa olayıdır** (interval temizliği, "ayrılmadan
+  kaydet" uyarısı gibi işler).
+- Akış kilidi burada da geçerlidir (Kural 3): önce bütün `flow_create`'ler, sonra events bağı.
+- Mevcut bağları `page_get` gösterir (`events[].value` = flow id).
+
+## Kural 1e — İKİ tablo komponenti var: `table` ve `datatable`
+
+> **`data-table` KALDIRILDI (2026-08-17).** Katalogda böyle bir slug yok; eski bir örnekte ya da
+> eski bir sayfada görürsen `datatable` ya da `table` ile değiştir. Katalogda tablo işi gören
+> başka komponent yoktur — aşağıdaki iki satır listenin tamamıdır.
+
+| slug | Olaylar | Ayırt edici prop'lar |
+|---|---|---|
+| `table` | 8: `mount · pagination · filter · sort · select · selectionChange · doubleClick · rowChange` | `rowSelection` (none/single/multi), `selectedRow`/`selectedRows`, `filterMode` (panel/hide/row), `filters`, `showSort`, `sortField`/`sortType`, `isEditable`, `showColumnMenu`, `actions`, `emptyIcon/emptyText/emptyActions`, `style` (root/thead/th/tr/td) |
+| `datatable` | 1: `mount` | `title`, `locale` (tr/en), `tableStyle` (zebra/plain), kolonlarda `isFilterable`/`isSortable`/`colorMap`/`prefix`/`suffix`/`precision`/`thousands`/`dateFormat`/`imageShape`, `filters`/`sortField`/`sortType` (hidden), `actions` |
+
+**`datatable`'ın tek olay yayması eksiklik değil, tasarım.** Filtre paneli, sıralama ve sayfalama
+komponentin İÇİNDE: kullanıcı süzdüğünde/sıraladığında/sayfa değiştirdiğinde `datatable` önce
+kendi `filters`/`sortField`/`sortType`/`offset` prop'larını node'a yazar, sonra **`mount`'u
+yeniden tetikler** (`updateQuery` → `emitMount`). Yani tek bir `mount` akışı yazarsın; o akış
+tabloya bağlı uca bu prop'ları parametre olarak geçirir ve dönen satırları geri yazar.
+
+**`table`'da her etkileşim AYRI bir olaydır** ve her birini ayrı akışa bağlarsın (`filter`,
+`sort`, `pagination` olayları yükte yeni değerleri de taşır — yukarıdaki olay yükü tablosu).
+
+Her ikisinin de süzme/sıralaması sunucu taraflıdır: seçilen filtreler uca `filters` parametresi
+olarak gider ve ancak `enableDynamicFilters: true` olan bir uçta karşılık bulur
+(`platform_guide('microservice')`).
+
+**Karar senin, dayatma yok.** Sorular:
+
+- *Kullanıcı bu listeyi ekrandan süzecek/sıralayacak mı?* Hayır ise ikisi de olur; en az kavramla
+  kurulanı seç ve `mount` akışı yeterlidir.
+- *Süzme/sıralama var mı?* → `datatable` tek akışla kurar (daha az bağlama), `table` her olayı
+  ayrı akışa bağlamanı ister ama karşılığında satır seçimi (`rowSelection`), çift tık, hücre içi
+  düzenleme (`isEditable`) ve boş-durum aksiyonları verir.
+- *Satır seçimi / çift tıkla forma geçiş / hücre düzenleme gerekiyor mu?* → **`table`**; bunlar
+  `datatable`'da yok.
+- *Zengin kolon biçimlendirme (renk haritası, para birimi öneki, tarih formatı, avatar) gerekiyor
+  mu?* → **`datatable`**; kolon şeması bunun için tasarlandı.
+
+**Bu, katalogdaki her komponent için geçerlidir:** hangi komponenti kullanacağını
+`component_list`/`component_get` ile keşfedip kendin seçersin, rehberdeki örnekler tercih değil
+şablondur.
+
+Kaçınılacak tek şey **yarım kurulum**: süzme arayüzünü açıp (`table` + `filterMode:'row'`, ya da
+`datatable` + `isFilterable` kolonlar) arkasına statik filtreli uç bağlamak. Sayfa çalışır
+görünür, kullanıcı süzer, hiçbir şey olmaz. Ya süzme arayüzünü kapat, ya ucu
+`enableDynamicFilters: true` yap ve akışta `filters` parametresini geçir.
+
+> Komponenti sonradan değiştirmek pahalıdır: flow'un `setter` adımı hedefi kayıt anında
+> **DesignComponent id**'sine çözer (`StepIterate.component?.Id`), komponenti silip yeniden
+> eklersen elementId aynı olsa bile o bağ kopar ve flow'u yeniden kaydetmen gerekir. Tipi
+> baştan doğru seç.
+
+## Kural 1f — Koordinat modeli ve layout-slot yerleşimi
+
+Izgara kapsayıcıya görelidir ve **bir satır ≈ 10px**'tir; `w` 12 kolon. Her komponentin
+`blocks[].position` (x,y) değeri **kendi parent'ının** ızgarasında anlamlıdır — sayfanın
+tamamında değil.
+
+**Sayfa şeması layout'un `slot`'unun İÇİNE enjekte edilir** (Studio ve runtime aynı mapper'ı
+kullanır: `page.mappers.ts` `mapPageLayoutToPreview` — layout varsa çizilen şema layout'un
+`views`'üdür, sayfanın şeması slot'un `children`'ına konur). Bundan üç kural çıkar:
+
+1. **Layout header'ı/sidebar'ı için sayfada boşluk BIRAKMA.** Header slot'un dışındadır;
+   "header'ın altından başlayayım" diye ilk komponente y ofseti verirsen boşluk İKİ KEZ
+   oluşur — semptom: üstte kocaman boş bant, içerik ancak scroll'la görünür. İçerik
+   `page_container` içinde **y=0'dan** başlar.
+2. **`page_container` her zaman (0,0)'dadır.** Studio her kayıtta bunu kendisi sıfırlar
+   (`mapPageSchemaRaw`); gateway de `page_create`/`page_update(schema)` yolunda sıfırlar ve
+   `gatewayNormalized` ile bildirir. Kayıtlı bir sayfada y≠0 kapsayıcı görürsen düzeltme
+   yolu `page_update(schema)`'dır — `move_component` kapsayıcıya uygulanamaz (PAGE-006).
+3. **Kardeş y'lerini bitişik ver.** Çakışma itmesi yalnız AŞAĞI iter, boşluk kapatmaz.
+   Gateway şüpheli boşlukları **PAGE-010 (uyarı)** ile yanıtın `layoutWarnings` alanında
+   söyler: kapsayıcı içinde ilk komponent y>4'te başlıyorsa ya da ardışık kardeşler arasında
+   >12 satır (~120px) dikey bant varsa. Layout `views`'ünde aynı analiz **LAY-003**'tür.
+   Bilinçli boşluksa uyarıyı yok say; değilse y'leri toparla.
+
+> **Layout `views`'ünde satırlar YIĞILMAZ — yalnız kolonlar çalışır.** Ölçüm (anket projesi,
+> 2026-08-19, 1280×720): layout'un doğrudan çocuklarına `position.y` verildiğinde hepsi
+> **top:0**'da çizilir ve üst üste biner; `x`/`w` ise doğru uygulanır. Ölçülen değerler —
+> `public_topbar` (y:0,h:2) → top 0, **576px**; `public_slot` (y:2,h:78) → **top 0**, 576px:
+> ikisi çakıştı, sayfa içeriği header'ın altında kaldı. `heightType: 'auto'` yapmak yüksekliği
+> düzeltmedi (kap yine 576px kaldı).
+>
+> Çalışan desen **kolon ayrımıdır**: sidebar `{x:0,w:2}` + slot `{x:2,w:10}` → sidebar solda,
+> içerik sağda, çakışma yok (aynı ölçümde doğrulandı). Üstte şerit istiyorsan iki seçenek var:
+> (a) şeridi **sayfanın kendi şemasına** koy (ya da tek `html` ekranıysa şablonun içine), ya da
+> (b) katalogdaki `header`/`sidebar` **layout komponent tipleri**ni kullan — generic `container`
+> yerine onlar için ayrı yerleşim yolu var (bu ikinci yol ölçülmedi).
+>
+> Semptom sözlüğü: layout bağlıyken sayfada **devasa üst boşluk + içeriğin başlıkla çakışması**
+> görüyorsan sebep budur; layout bağını kaldırdığında sayfa düzgün çiziliyorsa teşhis kesinleşir.
+
+> **Neden 576px? `states.isWrapper: true` düğüme `min-height: 80vh` bastırıyor.** Renderer
+> `getStyle` içinde wrapper düğümlere koşulsuz `height:100%` + **`min-height:80vh`** +
+> `overflow-y:inherit` yazıyor (`RenderComponent.svelte:134`). 720px'lik pencerede bu tam
+> **576px**'tir — yukarıdaki layout ölçümündeki sayı da, sayfa içinde boş görünen dev
+> kutuların sayısı da budur. Ölçüm (anket-native sayfası, 2026-08-19): `isWrapper:true` bir
+> `container`'ın içinde 36px'lik tek bir `multi-select` varken kutu **576px** çizildi; aynı
+> düğüm `isWrapper:false` yapılınca **36px**'e indi (kart yüksekliği 666px → 126px).
+>
+> Kural: **`isWrapper` yalnız gerçekten sayfa boyu kaplaması gereken kap içindir**
+> (`page_container` böyledir ve öyle kalmalı). Sadece "başlık/çerçeve çizilmesin" diye wrapper
+> yapma — o iş `container` için `style` ile (`background:'transparent'`, `border:'none'`),
+> `form` için `hideBorders`/`hidePadding` prop'larıyla yapılır. **`states` için micro-op
+> YOKTUR:** yanlış `isWrapper`'ı düzeltmenin tek yolu düğümü `remove_component` +
+> `add_component` ile yeniden kurmaktır (sonrasında Kural 2'deki flow yeniden kaydetme adımı
+> ZORUNLU olur).
+
+Mobil not: <768px'te ızgara tek kolona düşer (`RenderComponent` media query'si) — y sırası
+dikey sıraya dönüşür, x/w yok sayılır. Yerleşimi masaüstü (breakpoint 1024) bloğuyla kur.
+
+## Kural 1f-2 — Kapsayıcı düzeni: `flex` (varsayılan) ↔ `grid`
+
+`container` çocuklarını iki şekilde dizebilir ve **`page_container` de bir `container`'dır** —
+aynı prop grubunu o da alır. Grup katalogda tanımlıdır, yani şemadan kurulabilir; ölçüm
+(2026-08-25, `page_schema_validate` kuru koşusu): yedi prop da `valid: true` döndü,
+`layout: 'flexbox'` → `invalid-enum-value`, `flexDirection` → `unknown-prop`
+(doğru adlar `component_get(slug:'container')` çıktısındadır).
+
+| Prop | Değerler (varsayılan **kalın**) | Ne yapar |
+|---|---|---|
+| `layout` | **`flex`** · `grid` | `flex`: akış düzeni. `grid`: 12 kolonluk ızgara (Kural 1f). |
+| `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. |
+
+`stretch` iki eksende farklı anlama gelir: **ana** eksende `space-between` (çocukları uçlara
+dağıtır), **çapraz** eksende gerçekten doldurur.
+
+**Varsayılan ≠ renderer davranışı — ikisini karıştırma.** `layout`'un katalog varsayılanı
+2026-08-25'te `grid` → `flex` oldu, ama varsayılan düğüm **kurulurken** props'a yazılır (Studio
+bırakma yolu `definition.defaults`'u kopyalar); renderer varsayılanı bilmez, yalnız düğümün kendi
+prop'una bakar (`isFlexLayout`). İki sonucu var:
+
+- **Eski kayıtlar değişmedi:** `layout` prop'u olmayan her kapsayıcı ızgara çizilmeye devam eder.
+- **Sen şema kuruyorsan varsayılana güvenme:** istediğin düzeni `layout`'a AÇIKÇA yaz. Yazmazsan
+  ı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).
+
+**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.
+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
+   `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.
+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.
+
+```jsonc
+// Ortalanmış giriş kartı — style ile CSS hack'i YOK, kabın kendi düzeni
+{ "op": "replace_prop", "target": "page_container", "prop": "layout",          "value": "flex" }
+{ "op": "replace_prop", "target": "page_container", "prop": "direction",       "value": "column" }
+{ "op": "replace_prop", "target": "page_container", "prop": "horizontalAlign", "value": "center" }  // çapraz eksen → yatay ortalama
+{ "op": "replace_prop", "target": "page_container", "prop": "verticalAlign",   "value": "middle" }  // ana eksen → dikey ortalama
+{ "op": "replace_prop", "target": "page_container", "prop": "gap",             "value": "large" }
+// kart w:4 verilirse %33 genişlikte ve ortada durur (column'da genişlik = w/12)
+
+// Sağa yaslı aksiyon şeridi — kabın kendisi w:12, çocuklar sıkışmadan sağa toplanır
+{ "op": "replace_prop", "target": "row_actions", "prop": "layout",          "value": "flex" }
+{ "op": "replace_prop", "target": "row_actions", "prop": "horizontalAlign", "value": "right" }
+{ "op": "replace_prop", "target": "row_actions", "prop": "verticalAlign",   "value": "middle" }
+{ "op": "replace_prop", "target": "row_actions", "prop": "gap",             "value": "small" }
+```
+
+> 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.
+
+## Kural 1g — Dinamik form (satır sayısı ve alan tipi veriden gelen ekran): `repeater`
+
+"N tane soru, her birinin cevap tipi farklı" gibi ekranlar için `html` kaçış kapısına gerek
+YOK — `repeater` (katalog adı *List View*) bunun hazır cevabıdır. **Tam gövde (iki akış, satır
+şekli, bağ listesi, doğrulama adımları): `ngapps://examples/page-dynamic-form`.** Ölçülmüş çalışan desen
+(anket-native sayfası, 2026-08-19; 4 soru: tekil seçim / çoklu seçim / evet-hayır / serbest
+metin → tek gönderimde kaydedildi):
+
+```
+q_form (form)
+└─ q_list (repeater)              rows = [{id, no, text, help, required, kind,
+   └─ q_card (container)                   is_single, is_multi, is_text, is_yesno,
+      ├─ q_head (text)                     options:[{label,value}], answer}]
+      ├─ q_help (text)
+      ├─ a_choice (radio)      isHidden: {{ !(item.is_single || item.is_yesno) }}
+      ├─ a_text   (textarea)   isHidden: {{ !item.is_text }}
+      └─ box_multi (container) isHidden: {{ !item.is_multi }}
+         └─ a_multi (multi-select)
+```
+
+- **Şablon `children`'dır.** Repeater `rows` dizisindeki her satır için `children` ağacını
+  yineler; satır bağlamı çocuklara `item` (eşanlamlısı `Row`, sırası `RowIndex`) olarak iner
+  ve **iç içe her seviyeye** taşınır (`box_multi` içindeki `a_multi` de `item`'ı görür).
+- **İki yönlü bağ vardır ve flow gerektirmez.** Bir çocuk komponentin prop'u kod ifadesiyse ve
+  ref'i **tam olarak** `{{ item.<alan> }}` kalıbına uyuyorsa, kullanıcı o alanı değiştirdiğinde
+  runtime değeri `rows.data[<index>].<alan>`'a geri yazar
+  (`repeater.handler.ts` → `handleRepeaterItemPropertySet`, regex `^\{\{\s*item\.(.+?)\s*\}\}$`).
+  Yani `value: {type:'code', ref:'{{ item.answer }}'}` yazmak "cevabı satıra kaydet" demektir.
+  **Kalıp bozulursa geri yazma sessizce çalışmaz:** `{{ item.answer || '' }}` ya da
+  `{{ item["answer"] }}` regex'e uymaz — okur ama yazmaz.
+- **Toplu okuma flow'da `<repeaterAdı>.rows`'tur.** `microservice` adımının `value.type:'code'`
+  parametresinde ve `condition` adımının `expression`'ında komponentlere adıyla erişilir, yani
+  `JSON.stringify((q_list.rows || []).map(…))` doğrudan çalışır. Kod bağlamında satırlar
+  **ham** gelir (Prop sarımı `mapSchemaPropToRawProp` ile her seviyede açılır); `machine.getNode`
+  ile bakarsan `{data,type}` sarılı görünür — ikisini karıştırma.
+- **Satır kimliği:** `getRepeaterRowId` sırayla `row._id` / `row.id` / index'e bakar. Satırlara
+  **kalıcı bir `id` ver**; yoksa index'e düşer ve liste değişince girilen değerler kayar.
+
+**Satır tipine göre FARKLI alan göstermek — aynı ızgara hücresi + `isHidden`.** Dört varyantı
+alt alta dizersen gizli olanların satırları boş kalır (gizli düğüm hiç çizilmez ama grid
+koordinatı sabittir → dev boşluk). Doğrusu **hepsini aynı `position`'a koymaktır**; zaten aynı
+anda yalnız biri görünür. Bu güvenlidir çünkü **`page_schema_patch` çakışma normalizasyonu
+UYGULAMAZ** — koordinatları aynen kaydeder (aşağı itme yalnız `page_create` / `page_update`
+/ `layout_update` yolundadır, Kural 1). Aynı sebeple bu deseni komple şema yazarak kuramazsın.
+
+> **`isHidden` her komponentte YOK.** Renderer `{#if !props.isHidden}` ile *her* düğümü
+> geçiriyor, ama prop sözlüğünde tanımlı değilse doğrulama duvarı `unknown-prop` ile reddeder.
+> Ölçüm: `radio`, `textarea`, `container`, `form`, `button` **var**; `text` ve `multi-select`
+> **yok**. Çözüm: gizlenecek komponenti `isHidden`'ı olan bir `container`'a sar ve koşulu
+> sarmalayıcıya bağla (yukarıdaki `box_multi`). Sarmalayıcıyı **`isWrapper:false`** kur
+> (Kural 1f: wrapper = `min-height:80vh`) ve çerçevesini `style` ile kapat:
+> `{ background:'transparent', border:'none', '&__body': { padding:'0px' } }`.
+> `appearance.isHidden` diye bir kaçış yolu YOKTUR — runtime onu hiç okumaz.
+
+> **Satır BAŞINA doğrulama kurulamaz.** `validations` komponentin kendisindedir, tüm satırlar
+> onu paylaşır — "3. soru zorunlu, 4. soru değil" şemayla ifade edilemez. Zorunluluk satır
+> verisinde taşınır (`required`) ve gönderim akışının ilk `condition` adımında denetlenir:
+> `(q_list.rows||[]).filter(r => r.required && (r.answer==='' || (Array.isArray(r.answer) && !r.answer.length))).length > 0`.
+
+
+> **⚠ İÇ İÇE REPEATER YAZMA İÇİN KULLANILAMAZ (ölçüldü, 2026-08-19).** Repeater içinde ikinci bir
+> repeater (`rows: {{ item.options }}`) **okumada çalışır** — dış satır başına doğru sayıda iç satır
+> çizilir, değerler doğru gelir. Ama:
+> - **Geri yazma ölü:** iç girdiyi değiştirdiğinde dış satırın alanı DEĞİŞMEZ
+>   (`p_outer.rows.data[0].options[0].label` eski kaldı) ve iç repeater'ın `_repeaterValues`'ü
+>   `null`. Sebep yapısal: şemada iç repeater **tek bir düğümdür**, dış satır başına ayrı bir düğüm
+>   yoktur; `_repeaterValues` anahtarı iç satır id'sine göredir ve dış satırlar arasında çakışır.
+> - **DOM bozuluyor:** tek bir düzenlemeden sonra girdi sayısı 3 → **19**'a çıktı, değerler karıştı.
+> - 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).
+>
+> **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ü
+> (`anket-admin/anket-duzenle`). Gerçekten satır satır düzenleme gerekiyorsa iç listeyi AYRI bir
+> sayfada/modalda yönet — iç içe repeater bunu karşılamıyor.
+
+> **Repeater satırını akıştan silmek/eklemek:** repeater ÇOCUĞUNDAKİ bir butonun click akışında
+> `RowIndex` doğru satırı verir, ve hedef repeater'ın KENDİSİ olduğu için `rows`'a yazmak serbesttir
+> (`isRepeaterSelf` dalı satır-değeri yoluna girmez). Ölçülmüş desen:
+> `q_list.rows = (q_list.rows || []).filter(function(r, i){ return i !== RowIndex; })`.
+> Ekleme aynı şekilde `.slice()` + `push` ile yapılır; satır numarasını ekledikten sonra yeniden ata.
+
+**Gönderimi saklamak:** satır başına normalize kayıt yerine tek `TEXT` kolonda anlık görüntü
+(`answers_json`) tutmak bu desende en pratik yoldur — yazarken `JSON.stringify`, okurken platform
+kendisi nesneye çevirir; Studio tablosunda `[object Object]` görünmesi normaldir ve veri sağlamdır
+(`platform_guide('entity')` → "TEXT kolonunda JSON"). Ekranın görsel tarafı için **Kural 1h**:
+tema `--ng-*` değişkenleriyle tek yerden çevrilir, `html` kaçış kapısına gerek kalmaz.
+
+## Kural 1h — Tasarım: `style` prop'u ve tema değişkenleri
+
+Her komponentin `style` prop'u vardır ve emotion `css()` bloğudur: iç seçiciler, pseudo-class'lar
+ve **CSS değişkeni tanımı** çalışır, üretilen sınıf komponente scope'ludur. Ekranı "modern"
+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.
+
+**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`,
+`--ng-border-primary`, `--ng-rounded`, `--ng-font`, `--ng-form-border-focus`,
+`--ng-form-radius-md`, `--ng-form-height-md`…). Bunları kök kapsayıcının `style`'ında yeniden
+tanımlarsan **sayfadaki her komponente miras kalır**:
+
+```jsonc
+{ "op": "replace_prop", "target": "page_container", "prop": "style", "value": {
+    "--ng-accent-primary": "#4F46E5", "--ng-accent-hover": "#4338CA",
+    "--ng-form-border-focus": "#4F46E5",
+    "background": "#F1F5F9",
+    "& > .ng-container__body > .ng-container__slot": {
+        "maxWidth": "720px", "margin": "0 auto", "padding": "48px 20px 80px", "height": "auto" } } }
+```
+Ölçüldü: butonun dolgusu tek satırda `rgb(79,70,229)`'a döndü (buton stilini hiç yazmadan) ve
+içerik sütunu 720px'te ortalandı. **İçeriği ortalamak için `.ng-container__slot`'u hedefle** —
+`.ng-app__node-children`'ın `padding`'i renderer tarafından SATIR İÇİ yazılır, sınıfla ezilmez.
+
+**2. Alt parça seçicileri `&__parça` şeklindedir ve komponent markup'ıyla eşleşir.** Komponent
+kendi elemanlarına `class="{emotionSınıfı}__parça"` basar; `style` içinde `"&__item"` yazınca
+emotion `.css-xxx__item` üretir ve tutar. Hangi parçaların olduğu `component_get`'in
+`style` prop'unun alt listesindedir (`radio` → `&__items · &__item · &__item-input ·
+&__item-text · &__label · &__description · &__error`). Pseudo-class, `::before/::after`,
+kardeş ve iç seçiciler de yazılabilir: `"&__item:hover &__item-text"`,
+`"&__item-input:checked + &__item-text"`, `"&__item-text::before"`.
+
+**3. ⚠ Platform `style` anahtarlarının SIRASINI korumaz.** Prop sözlüğü `Dictionary` olarak
+saklanıp yeniden serileştiriliyor; `appliedPatch` çıktısında `ref` ile `data` anahtar sırasının
+farklı olduğunu görebilirsin. Sonuç: **aynı özgüllükteki iki kendi kuralın arasında "sonra yazan
+kazanır" GARANTİ DEĞİLDİR.** Ölçüm: `&__item` ile `&__item:has(...)` arasında yalnız bazı
+bildirimler geçti. Çözüm — durum kurallarını **özgüllükle** ayır
+(`&__item-input:checked + &__item-text` = 0,2,0 > `&__item-text` = 0,1,0) ya da kritik
+bildirimlere `!important` koy.
+
+**4. Komponentin kendi boyut kuralları seninkinden ÖZGÜLDÜR.** `radio`/`textinput` vb.
+`--sm/--md/--lg` modifier'ları `.css-x--md .css-x__item-text { padding-left: … }` gibi (0,2,0)
+kurallar yazar; senin `&__item-text` kuralın (0,1,0) bunu ezemez. Ölçüm: `padding` verdim,
+`padding-left` 22.4px kaldı (dot ile metin çakıştı); `!important` ile 42px'e oturdu. Kural:
+komponentin varsayılanının üstüne yazarken ya `&--md &__parça` yaz ya da `!important` kullan.
+
+**5. Gizlenecek/koşullu görsel durumlarda `:has()`'e bel bağlama.** `:has(input:checked)`
+seçicisi doğru eşleşiyor (`element.matches()` true) ama işaretleme çalışma anında değiştiğinde
+tarayıcı üst elemanı yeniden stillendirmeyebiliyor — ölçümde yalnız kalıtılan `color` güncellendi,
+`background`/`border`/`box-shadow` eski kaldı (aynı bayatlama platformun KENDİ radyo noktasında da
+görüldü: `input:checked + span::after { opacity: 1 }` uygulanmadı). Sağlam yol kardeş seçicidir:
+işareti taşıyan input'un **sonraki kardeşini** boya (`&__item-input:checked + &__item-text`).
+
+
+### 1h-2 — Tema değişkeni envanteri (`Theme.svelte`, tamamı)
+
+Bunlar **runtime'da her sayfada tanımlıdır**; `style` içinde yeniden tanımlayarak eziyorsun.
+Varsayılan palet `white.ts` (accent `#0052CC`, border `#dfe1e6`, text `#262626`) — yani hiçbir şey
+yapmazsan ekran "platform mavisi" görünür; marka rengine çevirmek tek satırdır.
+
+| Küme | Değişkenler |
+|---|---|
+| Vurgu | `--ng-accent-primary` · `--ng-accent-hover` · `--ng-accent-muted` · `--ng-accent-subtle` |
+| Zemin | `--ng-background-canvas` · `--ng-background-surface` · `--ng-background-surface-alt` · `--ng-background-readonly` · `--ng-background-disabled` · `--ng-background-overlay` |
+| Metin | `--ng-text-primary` · `--ng-text-secondary` · `--ng-text-disabled` |
+| Çerçeve / köşe / gölge | `--ng-border-primary` · `--ng-border-secondary` · `--ng-rounded` · `--ng-shadow-none/sm/md/lg` |
+| Tipografi | `--ng-font` · `--ng-font-size` · `--ng-font-weight` |
+| Boşluk | `--ng-spacing` · `--ng-spacing-small` · `--ng-spacing-large` |
+| Durum | `--ng-status-success` · `--ng-status-warning` · `--ng-status-error` · `--ng-status-info` |
+| Form (girdilerin tamamı) | `--ng-form-color` / `-disabled` / `-placeholder` / `-invalid` · `--ng-form-background` / `-disabled` / `-readonly` · `--ng-form-border` / `-focus` / `-disabled` / `-invalid` · `--ng-form-radius-sm/md/lg` · `--ng-form-height-sm/md/lg` · `--ng-form-padding-x-sm/md/lg` · `--ng-form-font-family` · `--ng-form-font-size-sm/md/lg` · `--ng-form-label-color` / `-font-weight` / `-font-size-*` / `-margin-bottom-*` · `--ng-form-default-size` |
+
+**Önce token'ı ez, sonra komponent stiline in.** `--ng-form-radius-md`'yi 10px yapmak sayfadaki
+BÜTÜN girdileri yuvarlar; aynı şeyi komponent komponent `&__input { borderRadius }` yazarak
+yapmak hem uzun sürer hem de yeni komponent eklendiğinde tutarsızlık üretir.
+
+### 1h-3 — Ölçülmüş hazır bloklar (anket ekranından, olduğu gibi kullanılabilir)
+
+```jsonc
+// 1) Sayfa kabuğu — tema + ortalanmış içerik sütunu   [page_container.style]
+{ "--ng-accent-primary": "#4F46E5", "--ng-accent-hover": "#4338CA",
+  "--ng-form-border-focus": "#4F46E5",
+  "background": "#F1F5F9",
+  "fontFamily": "'Inter', ui-sans-serif, system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif",
+  "& > .ng-container__body": { "overflowY": "visible" },
+  "& > .ng-container__body > .ng-container__slot": {
+      "maxWidth": "720px", "margin": "0 auto", "padding": "48px 20px 80px", "height": "auto" } }
+
+// 2) Kart — beyaz yüzey, ince çerçeve, hover'da yükselen gölge   [container.style, isWrapper:false]
+{ "background": "#FFFFFF", "border": "1px solid #E2E8F0", "borderRadius": "16px",
+  "boxShadow": "0 1px 2px rgba(15, 23, 42, 0.04)",
+  "transition": "border-color 140ms ease, box-shadow 140ms ease",
+  "&:hover": { "borderColor": "#CBD5E1", "boxShadow": "0 6px 16px rgba(15, 23, 42, 0.07)" },
+  "&__body": { "padding": "22px 24px 24px", "overflowY": "visible", "height": "auto" } }
+
+// 3) Radyo → tıklanabilir seçenek satırları (46px hedef, seçilince indigo)   [radio.style]
+//    padding/lineHeight'ta !important ŞART: komponentin --md kuralı daha özgül (madde 4).
+{ "marginTop": "16px",
+  "&__items": { "gap": "8px" },
+  "&__item": { "display": "block", "cursor": "pointer" },
+  "&__item-text": { "display": "block", "border": "1px solid #E2E8F0", "borderRadius": "10px",
+      "padding": "12px 14px 12px 42px !important", "lineHeight": "1.45 !important",
+      "background": "#FFFFFF", "fontSize": "15px", "color": "#334155",
+      "transition": "border-color 120ms ease, background-color 120ms ease, box-shadow 120ms ease" },
+  "&__item-text::before": { "left": "15px" },
+  "&__item-text::after":  { "left": "calc(15px + (var(--ng-form-font-size-md) * 1.1) / 2 + 1px)" },
+  "&__item:hover &__item-text": { "borderColor": "#C7D2FE", "background": "#F8FAFF" },
+  "&__item-input:checked + &__item-text": { "borderColor": "#4F46E5", "background": "#EEF2FF",
+      "boxShadow": "inset 0 0 0 1px #4F46E5", "color": "#1E1B4B", "fontWeight": "500" } }
+
+// 4) Metin alanı — odak halkası   [textarea.style]
+{ "marginTop": "16px",
+  "&__input": { "borderRadius": "10px", "border": "1px solid #E2E8F0", "padding": "12px 14px",
+      "fontSize": "15px", "lineHeight": "1.6", "color": "#0F172A", "background": "#FFFFFF",
+      "transition": "border-color 120ms ease, box-shadow 120ms ease" },
+  "&__input:focus": { "borderColor": "#4F46E5", "boxShadow": "0 0 0 3px rgba(79, 70, 229, 0.12)",
+      "outline": "none" } }
+
+// 5) Çoklu seçim — dış sarmalayıcıya yazılır, iç kutu iner seçiciyle bulunur   [multi-select.style]
+{ "& .ng-multiselect": { "borderRadius": "10px", "border": "1px solid #E2E8F0",
+      "minHeight": "44px", "background": "#FFFFFF" },
+  "& .ng-multiselect:focus-within": { "borderColor": "#4F46E5",
+      "boxShadow": "0 0 0 3px rgba(79, 70, 229, 0.12)" } }
+
+// 6) Görünmez-kalabilen hata şeridi   [container.style + isHidden akıştan çevrilir]
+{ "background": "#FEF2F2", "border": "1px solid #FECACA", "borderRadius": "10px",
+  "marginTop": "20px",
+  "&__body": { "padding": "12px 14px", "overflowY": "visible", "height": "auto" } }
+
+// 7) Birincil buton — dolgu rengi token'dan gelir, burada sadece ölçü   [button.style]
+{ "marginTop": "24px", "height": "48px", "borderRadius": "10px", "fontSize": "15px",
+  "fontWeight": "600", "paddingLeft": "30px", "paddingRight": "30px",
+  "boxShadow": "0 1px 2px rgba(15, 23, 42, 0.08)" }
+```
+
+Ölçülen sonuç (1280×720): gövde 1292px, kartlar 680px genişlik / 14px ara, seçenek satırları
+46px, buton 48px; 375px'te yatay taşma yok, seçenekler 285px. Boş `text` komponenti ~24px yer
+kaplar — yardım metni opsiyonelse bunu hesaba kat.
+
+> **Erişilebilirlik notu:** seçenek satırını `label`'ın İÇİNDEKİ `span`'e boyamak tıklama
+> alanını daraltmaz (`label` zaten sarmalayıcıdır) ama **odak halkasını da taşımanız gerekir** —
+> `input` `display:none` olduğu için klavye odağı görünmez. Klavyeyle gezilecek ekranlarda
+> `&__item-input:focus-visible + &__item-text` için de bir dış çizgi tanımlayın.
+
+## Kural 2 — Şema değişikliği `page_update` ile YAPILMAZ
+
+İki ayrı yazma yolu vardır ve karıştırılmaz:
+
+| 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 |
+
+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
+alanları değiştirip tam gövdeyi geri yazar (`layout_update` ve `component_update` de aynı).
+Yine de `schema` parametresini elle doldurursan okuduğun hâli değil, **verdiğin liste** yazılır.
+
+### Atomiklik: 500 KB'lık şemada tek komponente dokunmak
+
+`page_schema_patch` şemanın tamamını göndermez — yalnız op'ları gönderir. Tam gövde ne LLM
+bağlamına girer ne de tel üzerinden geçer; şemayı platform kendi belleğinde okur, op'ları uygular
+ve geri yazar. Sözleşme (`PatchPageSchemaCommandHandler`):
+
+| Aşama | Ne yapar |
+|---|---|
+| Kilit | Sayfa başına 60 sn'lik dağıtık kilit; başka bir aktör yazıyorsa istek `PageSchemaLockedException` ile döner (409) |
+| Sürüm | `baseVersion` verdiysen `UpdatedAt.Ticks` ile karşılaştırılır; tutmazsa `PageSchemaVersionConflictException` (409) ve **hiçbir op uygulanmaz** |
+| Uygulama | Her op hedefini ağaçta arar (`Find` → JSON Pointer) ve **yalnız o düğüme** dokunur; kardeşler, üst düğümler ve diğer alt ağaçlar bit düzeyinde korunur |
+| Hep-ya-hiç | Op'lar önce bellekte uygulanır; **tek bir hata** (bilinmeyen op, bulunamayan hedef, tekrar eden elementId, doğrulama) tüm komutu düşürür — kısmi yazma yoktur |
+| Doğrulama | Tam şema `PageSchemaValidator`'dan geçer (422 + alan bazlı `errors`) |
+| Yazma | Tek transaction (`ITenantContextTransactionalCommand`) |
+| Yayın | Açık Studio canvas'larına SignalR ile `page-schema-patched` |
+
+Yanıt üç alan döner: `applied` (uygulanan op sayısı), **`appliedPatch`** (her op'un şemada tam
+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`).
+
+**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
+`expectedUpdatedAt` ile yapılır: sayfa okunur, `audit.updatedAt` karşılaştırılır, tutmazsa istek
+hiç gönderilmez. Bu kontrol **iki çağrı arasına başka bir yazar girerse yakalamaz**; gerçek
+korumayı isteyen ham HTTP ile `baseVersion` göndermelidir.
+
+> **Büyük şemada çalışma sırası:** `mode:'summary'` ile ağacı çıkar (props yok, 500 KB'lık sayfada
+> bile küçük) → hedefin `elementId`'sini al → gerekiyorsa `mode:'subtree'` ile yalnız o dalı oku →
+> op'ları `page_schema_validate` ile kuru koştur → `page_schema_patch`. `mode:'full'` yalnız
+> gerçekten tüm şema gerektiğinde çağrılır.
+
+> **`remove_component`'in yan etkisi — tek istisna.** Sayfa kaydedilirken artık hiçbir komponent
+> olayının, prop'unun ya da sayfa olayının referans vermediği akışlar platformca **kalıcı olarak
+> silinir** (`PageService.UpdateAsync` → `flowRepository.DeleteRangeAsync`). Yani akış bağlı bir
+> komponenti silmek, o akış başka yerde kullanılmıyorsa akış kaydını da götürür. Gateway bunu
+> yanıtta `flowWarnings` ile bildirir; akışı korumak istiyorsan silmeden önce başka bir komponente
+> `set_event` ile bağla ya da `flow_get` ile gövdesini yedekle. Ayrıntılı analiz:
+> `PatchPageSchemaCommandHandler` (backend) — kilit, sürüm ve hep-ya-hiç davranışının kaynağı.
+
+## Kural 3 — Flow yazımı barındırıcıyı da günceller
+
+Platform `flow` uçlarında gövdede hem akışı hem barındırıcının tam güncelleme komutunu ister
+(`{ flow, page | layout | component }`) — şemadaki `events[].value` = flow id bağı tek işlemde
+tutarlı kalsın diye. **Silme bile gövdelidir.** Gateway barındırıcıyı okuyup gövdeye kendisi
+koyar; sen yalnız akışı verirsin.
+
+Akışı bir komponente bağlamak ayrı adımdır:
+
+```
+flow_create(host:'page', hostId:<pageId>, name:'Save order', slug:'save-order', steps:[…])
+page_schema_patch(ops:[{ op:'set_event', target:'button_1', event:'click', eventValue:<flow id> }])
+```
+
+> Olay adı `component_get`'in `events` listesinden alınır ve **`on` öneki almaz**: buton `click`,
+> form `submit`, tablo `mount`/`select`/`sort`. `onClick` yazarsan platform 200 döner ama bağ
+> ölüdür — gateway bunu PAGE-008 ile istek gitmeden reddeder.
+
+`flow_create`'e `flowId` verirsen id'yi önceden bilir, iki adımı tek planda kurabilirsin.
+
+### Sayfada bağlı akış varken YENİ akış eklenemez — ve çözümü
+
+Bir sayfanın herhangi bir olayı zaten bir akışa bağlıysa, o sayfaya ikinci bir `flow_create`
+FK ihlaliyle reddedilir:
+
+```
+Geçersiz istek: This record is in use. Please remove its relations first.
+```
+
+Bu yüzden **kuruluş sırası bağlayıcıdır** — önce şema, sonra **bütün** akışlar, en son **tek**
+patch'te bütün `set_event`'ler:
+
+```
+page_create → page_schema_patch (tüm add_component)
+            → TÜM flow_create'ler
+            → TEK page_schema_patch (bütün set_event'ler)
+```
+
+Sonradan akış eklemen gerekirse sayfayı baştan kurmana gerek yok — **bağı geçici olarak çöz**:
+
+```jsonc
+1) page_schema_patch [{ "op":"set_event", "target":"page_container", "event":"mount", "eventValue": null }]
+2) flow_create × N
+3) page_schema_patch [ bütün set_event'ler tek seferde ]
+```
+
+`eventValue: null` olay kaydını bırakıp değerini boşaltır ve kilidi açar.
+
+> **Aynı kilit LAYOUT'ta da vardır** (ölçüm 2026-08-18: menüye yeni bağlantı eklerken
+> `POST /layouts/<id>/flows` aynı hatayı verdi). Layout'un olayları komponentin kendi `events`
+> dizisinde satır içidir (`{ "name": "click", "value": "<flow id>" }`) ve `page_schema_patch`
+> layout'a uygulanmaz; çözüm de bu yüzden farklı yazılır:
+>
+> ```
+> 1) layout_update  → tüm komponentlerde "events": []   (bağları çöz)
+> 2) flow_create × N
+> 3) layout_update  → tam ağaç + bütün events'ler
+> ```
+>
+> Sıfırdan kurarken kilide takılmazsın (akışları bağlamadan önce yaratırsın); kilit yalnız
+> **mevcut ve bağlı** bir layout'a yeni akış eklerken çıkar.
+
+## Kural 4 — Komponent güncellemesi slug ile, silme id ile
+
+`component_update` platformdaki **tek** slug'la çalışan update ucudur
+(`PUT components/{applicationId}/{slug}`); `component_delete` id alır. Widget kaydında
+(`kind:'widget'`) `widgetType` (`container` | `modal` | `drawer`) zorunludur.
+
+`component_list`/`component_get` iki işi görür: (1) sayfaya konabilecek tipleri ve prop
+sözlüğünü okumak — şemaya **uydurma prop yazma**, (2) kendi yazdığın komponentleri yönetmek.
+`scope:'all'` platformun varsayılan kataloğunu getirir.
+
+## Kural 5 — Layout: şema alanı `views` ve MUTLAKA bir `slot` içerir
+
+`layout_create/update` komponent ağacını `views` alanında taşır (`schema` değil) ve layout'un
+micro-op hattı **yoktur** — değişiklik tam gövde PUT'tur (gateway merge eder).
+
+**Slot şart:** sayfa bir layout'a bağlandığında render şeması **layout'un views'ü** olur ve
+sayfanın kendi içeriği YALNIZ layout'taki `type: 'slot'` komponentinin içine yerleştirilir
+(Studio `page.mappers.ts`: `mapPageLayoutToPreview` sayfa şemasını slot'un `children`'ına koyar).
+Slot'suz bir layout'a bağlanan her sayfa — kaydı kusursuz olsa da — **Studio'da ve runtime'da
+boş görünür**; kayıt tarafında hiçbir hata çıkmaz (kütüphane turu R1). Gateway slot'suz
+`views`'te LAY-002 uyarısı verir. İskelet:
+
+```jsonc
+"views": [
+  { "elementId": "app_header", "kind": "component", "type": "header", "props": { … },
+    "blocks": [{ "breakpoint": 1024, "size": { "h": 8, "w": 12 }, "position": { "x": 0, "y": 0 } }] },
+  { "elementId": "content_slot", "kind": "component", "type": "slot", "name": "İçerik",
+    "props": {}, "blocks": [{ "breakpoint": 1024, "size": { "h": 80, "w": 12 }, "position": { "x": 0, "y": 8 } }] }
+]
+```
+
+Doğrulama: `page_state` çıktısındaki `layoutSlots` — **boşsa sayfa içeriği görünmeyecek** demektir.
+
+> Layout gövdesindeki `parameters` alanını **boş bırak**: domain'de saklanır ama Studio'da
+> editörü yoktur ve runtime'da okunan bir tüketicisi tespit edilmedi (22 E-8a).
+
+## Kural 6 — Değişkenler: tek kayıt, `state.page.<key>` ile okunur
+
+`set_binding` ifadeleri yalnız `page_state`'in döndürdüğü değişken/komponent/microservice
+isimlerine bağlanır.
+
+**Platform değişkenleri tek tek değil SET olarak tutar:** uygulama başına bir kayıt, sayfa başına
+bir kayıt (`variable_create` `pageId` verirsen sayfa, vermezsen uygulama düzeyi). Kayıt zaten varsa
+create update'e döner. Şekil `[{ key, value }]`; `value` **herhangi bir JSON** olabilir:
+
+```jsonc
+variable_create({ applicationId, pageId, variables: [
+  { "key": "MyTest",  "value": { "isActive": true } },
+  { "key": "sayfaBaslik", "value": "Etkinlikler" }
+]})
+```
+
+- Uç seti **komple değiştirir**; gateway mevcut seti okuyup anahtar bazında birleştirir. Kasten
+  silmek için `replace: true`. `variable_delete` **setin tamamını** siler.
+- Platform `data`'yı JSON **string** olarak saklar (`"[{\"key\":…}]"`); gateway çeviriyi iki yönde
+  de yapar — `variable_list` sana `[{key, value}]` döndürür. Ham HTTP kullanıyorsan string
+  zorunludur: gövdede yalnız `data` alanı okunur, `name`/`type`/`defaultValue` gibi alanlar
+  **sessizce yok sayılır** ve kayıt boş yazılır (istek yine 200 döner).
+
+**Okuma yolu — sayfada `state.page.<key>`, uygulama düzeyinde `state.app.<key>`:**
+
+```jsonc
+// prop'u doğrudan ifadeye bağlama (flow gerekmez):
+"text": { "type": "code",
+          "data": "Button text",
+          "ref": "{{ state.page.MyTest.isActive == true ? 'Test' : 'FalseTest' }}" }
+```
+
+`type: 'code'` prop'unda **ifade `ref` alanındadır ve `{{ }}` ile sarılır**; `data` tasarım
+zamanı/yedek değeri taşır. Aynı erişim flow `code` adımlarında ve `value.type:'state'`
+ref'lerinde de geçerlidir (`platform_guide('expressions')` §2-3). `value` bir nesneyse alanlarına
+`state.page.<key>.<alan>` ile inilir.
+
+**Kod prop'ları CANLI bağdır (reaktif).** Runtime, `type:'code'` + `ref` taşıyan HER prop'u
+otomatik olarak canlı bağa çevirir: ifadenin okuduğu state/komponent değeri her değiştiğinde
+prop KENDİLİĞİNDEN yeniden hesaplanır — güncellemek için flow kurmak gerekmez (kaynak:
+zeyrek-frontend `initialization.handler.ts` → `executeStateBindings`, her prop yazımından sonra).
+Tercih kuralı: *"bu değer başka bir değerden TÜRETİLİYORSA"* `set_binding` / kod prop'u kullan;
+*"bir OLAY sonucunda bir kez yazılacaksa"* (uçtan veri çekme gibi) flow + setter kullan.
+İkisini aynı prop'ta karıştırma — setter'ın yazdığı değeri canlı bağ bir sonraki tetikte ezer.
+
+**`stateBindings[]` (şema düğümündeki dizi)** Studio'nun state-bağımlılık özelliğidir:
+`[{ name, expression, targets: [{ elementId, elementProperty }] }]` — bir ifade değişince
+listedeki hedef prop'lara yazılır. Micro-op sözlüğünde karşılığı YOKTUR; yalnız
+`add_component` gövdesinde ya da `page_update(schema)` ile yazılabilir. Aynı işi kod prop'u
+zaten gördüğü için yeni kurulumda tercih etme; mevcut sayfada görürsen silme.
+
+## Kural 7 — Sayfa arketipleri: liste tek başına uygulama değildir
+
+Bir uygulama, tabloların listelendiği ekranlar toplamı değildir. **CRUD ucu yazdıysan o kaydın
+yönetim ekranını da kur.** Kullanıcı kavramı varsa giriş ekranı olmadan sistem kullanılamaz.
+Aşağıdaki dört arketip `qm` projesinin canlı kayıtlarından çıkarıldı (140 sayfa aynı desende);
+ayrıntılı kanıt ve kayıt id'leri: `zeyrek-mcp/docs/18-sayfa-arketipleri.md`. **Tam gövdeler
+altın örneklerde** — şemayı ve akışları oradan kopyalayıp uyarla:
+
+| Arketip | Örnek |
+|---|---|
+| Liste | `ngapps://examples/flow-load-table` |
+| Form (create+edit) | `ngapps://examples/page-form-upsert` |
+| Liste → form geçişi | `ngapps://examples/flow-list-to-form` |
+| Giriş | `ngapps://examples/page-sign-in` |
+| 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
+> **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
+> middleware'i var ama giriş sayfası yok, yazma ucu var ama sayfa yok.
+
+**Adlandırma:** çoğul = liste sayfası, tekil = form sayfası (`Departmanlar` / `Departman`).
+Sayfa çiftini bu şekilde kur.
+
+### 7a — Form sayfası (create + edit AYNI sayfa)
+
+```
+page_container
+├── breadcrumb · notification
+├── form[ text · form-validation-errors · textinput · textarea · dropdown … ]
+└── container[ container[ btn_save · btn_cancel ] · container[ audit-basic ] ]
+```
+
+`form` komponenti `submit` olayı yayar; `errorElementId` prop'unu sayfadaki
+`form-validation-errors` komponentine bağla, input'ların `validations`'ı (required/minLength/
+maxLength/pattern — sözlük `component_get`'te) orada listelenir.
+
+**Validasyon yazma şekli — DÖRT alan da zorunludur:** `{ type, message, value, isActive }`.
+
+```jsonc
+{ "op": "set_validations", "target": "in_email", "validations": [
+  { "type": "required",   "message": "E-posta zorunludur.",    "value": true, "isActive": true },
+  { "type": "email",      "message": "Geçerli bir e-posta girin.", "value": true, "isActive": true },
+  { "type": "max-length", "message": "En fazla 120 karakter.",  "value": 120,  "isActive": true }
+] }
+```
+
+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):
+
+| Yanlış gövde | Ne olur |
+|---|---|
+| `{ type, isActive }` (mesaj/değer yok) | Kullanıcı neyin yanlış olduğunu göremez; eksik alanlı gövde sayfayı okunamaz bırakabilir (doküman 23 §B-2). Gateway **PAGE-016** ile reddeder. |
+| `{ name, value, message }` (`type` yok) | `ValidationModel.Name` **JsonIgnore**'dur: tip enum varsayılanına düşer ve alan SESSİZCE `regex` doğrulamasına döner. |
+| `{ type: "maxLength" }` (deve harfli) | Backend eski enum üyesiyle kabul edip geri okur ama **runtime doğrulayıcı yalnız tireli adları tanır** (`validation.ts` switch → `default: return true`): doğrulama hiç koşmaz. |
+
+Gateway ilk iki ve üçüncü durumdan düzeltebildiklerini düzeltir (`name` → `type`, `maxLength` →
+`max-length`, eksik `isActive` → `true`) ve `gatewayNormalized` ile bildirir; düzeltilemeyen
+(mesajsız / tanınmayan tip / değersiz eşik) gövdeyi **PAGE-016** ile yazmadan reddeder.
+Validasyon ya `add_component` gövdesinde baştan verilir ya da sonradan `set_validations` ile
+değiştirilir.
+
+Op **listeyi tamamen değiştirir** (boş dizi hepsini siler) ve yalnız o düğümün `validations`
+alanına dokunur. **Komponenti silip yeniden eklemeyin:** `remove_component` + `add_component`
+turu o komponente bağlı setter hedeflerini koparır (Kural 1e sonundaki not) ve komponentin tek
+referans verdiği akışları kalıcı olarak sildirir (Kural 2'deki yan etki notu).
+
+**Kip ayrımı query parametresidir:** aynı sayfa `?id=<kayıt>` ile edit, parametresiz create.
+
+`mount` akışı (`page_container` ya da `form` üzerine bağlanır):
+
+```
+start → [setter] page_container.isLoading = true
+      → [condition] Page.queryParams.id !== undefined
+          ├─ always → [setter] page_container.isLoading = false
+          ├─ if   → [setter] EDIT etiketleri (buton metni, breadcrumb.currentTitle, audit görünür)
+          │         → [microservice] get (id query-string'den) → [setter] alanları doldur
+          └─ 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' }`.
+>
+> **`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.
+>
+> **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).
+
+**İ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:
+
+```jsonc
+{ "type": "change", "element": "tbl", "property": "rows", "source": "component",
+  "mapping": { "source": "", "mappings": {} },
+  "value": { "type": "code", "ref": "[].concat(Steps.load_a?.data || [], Steps.load_b?.data || []).filter(function (r) { return !!r.request_id; }).map(function (r) { return { … }; })" } }
+```
+
+> Bir tablo birden çok kayıt tipini besliyorsa (aynı `approval_steps` hem izin hem avans
+> kademesi tutuyor gibi) **ilgisiz tipi süzmek şart** — süzülmezse karşı tipin satırları
+> arayüzde **boş satır** olarak belirir ve hiçbir hata çıkmaz.
+
+Alanları doldurma — kaynak adımın **ADI**, ilişki alanında **`.id`**:
+
+```jsonc
+{ "type": "change", "element": "name_f7bc", "property": "value", "source": "component",
+  "mapping": { "source": "", "mappings": {} },
+  "value": { "type": "storage", "ref": "get_service.data.name" } }
+// ilişki (dropdown) → etiket değil id
+{ "type": "change", "element": "manager_bb97", "property": "value", "source": "component",
+  "mapping": { "source": "", "mappings": {} },
+  "value": { "type": "storage", "ref": "get_service.data.manager.id" } }
+// audit kutusu tek prop'ta beslenir
+{ "type": "change", "element": "auditbasic7f72", "property": "meta", "source": "component",
+  "mapping": { "source": "", "mappings": {} },
+  "value": { "type": "storage", "ref": "get_service.data.meta" } }
+```
+
+`submit` akışı:
+
+```
+start → [setter] btn_save.isLoading = true
+      → [microservice] upsert (POST)
+      → [condition] Steps.upsert_service.error
+          ├─ always → [setter] btn_save.isLoading = false
+          ├─ if   → [setter] notification: kind='error', header, content, isHidden=false
+          └─ else → [condition] Page.queryParams.id
+                     ├─ if (edit)   → [setter] notification: kind='success', timeout=7000
+                     └─ else (create) → [redirect] { pageId:<liste>, path:'departmanlar' }
+```
+
+**Komponentten uca değer geçirme** — form kablolamasının tamamı bu şekildedir:
+
+```jsonc
+"parameters": [
+  { "name": "id", "type": "number", "source": "query-string",
+    "value": { "type": "code", "ref": "Page.queryParams.id" } },
+  { "name": "name", "type": "string", "source": "body",
+    "value": { "type": "property",
+               "ref": { "source": "component", "element": "name_f7bc", "property": "value" } } }
+]
+```
+
+- **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.
+- 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.
+>
+> **`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
+> göstermek için ya komponenti `isHidden`'ı OLAN bir `container`'a sar (Kural 1g) ya da
+> görünürlüğü sayfa açılış akışının setter'ıyla kur.
+
+### 7b — Liste → form geçişi
+
+**Önce hangi tabloyu kullandığını bil — ikisi FARKLI kurulur:**
+
+| | `table` | `datatable` |
+|---|---|---|
+| Yaydığı olaylar | `mount` · `select` · `doubleClick` · `filter` · `sort` · `pagination` … | **yalnız `mount`** |
+| Süzme/sıralama/sayfalama | her biri AYRI akışa bağlanır | komponent kendi prop'larını (`filters`/`sortField`/`sortType`/`offset`) yazıp `mount`'u yeniden tetikler → **tek akış yeter** |
+| Satır seçimi / çift tık | var (`self.selectedRow`) | **YOK** — `doubleClick` bağlamak 200 döner ama bağ ölüdür (gateway PAGE-008 keser) |
+| Kayıt açma | `doubleClick` akışı | satır **aksiyonu**: `actions: [{ text, kind, icon, flow: { type: 'flow', ref: <flowId> } }]` |
+
+`datatable` satır aksiyonunda tıklanan satır komponentin `selectedRow` prop'una **komponent
+tarafından** yazılır, sonra akış çalışır (`Table.svelte:72` → `setNode` + `onEmit`): akışta
+`<elementId>.selectedRow.<alan>` ile okunur. `actions[].kind` sözlüğü **butonunkinden farklıdır**
+(`error · information · solid · transparent · dark · danger · warning`; butonda
+`success · error · info · primary · warning`) — yanlış sözlükten değer `invalid-enum-value` verir.
+
+Aşağıdaki `doubleClick` tarifi **`table`** içindir. Geçişi `redirect` yapar ve
+**`query` bir İFADEDİR**:
+
+```jsonc
+// satıra çift tıkla → edit ; self = tetikleyen komponent
+{ "stepId": "go_edit", "type": "redirect", "kind": "normal",
+  "args": { "pageId": "<form sayfası id>", "path": "departman",
+            "query": "`id=${self.selectedRow.id}`" },
+  "branches": [{ "id": "<GUID>", "name": "always" }] }
+
+// "Yeni" butonu → create (bağlamı taşıyarak; komponente ADIYLA erişim)
+{ "args": { "pageId": "<form sayfası id>", "path": "departman",
+            "query": "table?.selectedRow?.id ? `parent=${table.selectedRow.id}` : ''" } }
+```
+
+Sayfalar arası veri geçmenin yolu budur: gönderen `query`'ye yazar, alan `Page.queryParams.<ad>`
+ile okur. `variable_create`'e ihtiyaç yoktur.
+
+### 7c — Giriş sayfası (kimlik varsa ZORUNLU)
+
+```
+page_container
+└── auth-layout[ text · notification · form[ textinput · password · checkbox · button ] ]
+```
+
+```
+start → [setter] btn.isLoading = true, btn.isDisabled = true, notification gizle
+      → [microservice] sign-in (POST; email + password body'den)
+      → [condition] !!Steps.signIn.data.token
+          ├─ always → [setter] buton durumunu sıfırla
+          ├─ if   → [setcookie] { name:'APP_Token', value:'Steps.signIn.data.token',
+          │                        expiresInHours: 240 }
+          │         → [redirect] hedef sayfaya
+          └─ else → [setter] notification.content =
+                      { type:'code', ref:'Steps.signIn.data.message || "Giriş başarısız"' }
+```
+
+- **Cookie adı middleware'in okuduğu adla birebir aynı olmalı** (`cookie.APP_Token` —
+  `platform_guide('middleware')` Tarif 1). Uyuşmazlık sessizce "hep 401" demektir.
+- `redirect` adımı `isRaw: true` iken `path` **çok satırlı JS bloğudur** (son ifade değeri döner) —
+  "korunan sayfaya gitmek isterken login'e düşen kullanıcıyı geri gönderme" böyle kurulur.
+- Prop değeri nesne olabilir: `icon` → `{ "type": "static", "ref": { "name": "progress_activity" } }`.
+- Giriş sayfası kimlik işinin görünen yarısıdır. Sign-in ucu + auth middleware'i kurup bu sayfayı
+  kurmamak, sistemi kullanılamaz bırakır.
+
+### 7d — Detay / profil sayfası
+
+Form arketipinin salt-okuma akrabası: input'lar `isViewmode: true`, altında ilişkili kayıt tablosu,
+`modal`/`drawer` ile ikincil işlemler (parola güncelleme gibi — modalın içinde kendi formu ve kendi
+`submit` akışı). Kimliği query parametresinden değil **middleware'den** alır: uca auth middleware'i
+bağlanır, filtre `source:'expression'` + `value:'user.id'` olur.
+
+### 7e — Hangi iş için hangi komponent
+
+`component_get` prop sözlüğünü verir ama **hangi işe hangisi** kararını sen verirsin:
+
+| İş | Komponent |
+|---|---|
+| Metin / uzun metin / zengin metin | `textinput` · `textarea` · `texteditor` |
+| Öneri listeli serbest metin | `autocomplete` (value YAZILAN metindir; id gerekiyorsa `select` olayı) |
+| Sayı / artan kod / kaydırıcı | `numberinput` · `incrementalinput` · `slider` |
+| Seçim (tek / çok / etiket) | `dropdown` · `multi-select` · `tag-input` · `radio` · `checkboxgroup` (değeri dizi) |
+| İki durumlu | `checkbox` · `switch` · `switcher` (iki durum yan yana) |
+| Puan / kod girişi | `rating` · `otpinput` |
+| Tarih / saat / aralık | `datepicker` · `datetimepicker` · `daterangepicker` · `datetimerangepicker` · `timepicker` (yalnız HH:mm) |
+| Kimlik alanları | `email` · `password` |
+| Dosya | `fileUpload` (dropzone) · `fileInput` · `filebutton` · `file-viewer` |
+| Liste | `table` · `datatable` (Kural 1e) · `repeater` (kart listesi VE dinamik form — Kural 1g) · `tree-view` (hiyerarşi; `isSearchable` ile istemci içi arama) · `timeline` (tarihli olay akışı) |
+| Sayfalama (tablo dışı listeler için) | `pagination` — offset/limit yazar, `self.offset`/`self.limit` ile sorguya bağlanır |
+| Grafik / KPI | `chart` (ECharts: bar·line·area·pie·donut + waterfall/histogram/pareto/bullet/tornado/radial) · `statcard` (tek KPI + trend + sparkline) · `progress` |
+| Kapsayıcı / düzen | `container` (ızgara ya da flex — Kural 1f-2) · `form` (düzen prop'u YOK, çocuklar ızgara koordinatıyla dizilir) · `tabs` · `collapsible-container` · `accordion` |
+| Kart görünümü | `card` — **kapsayıcı DEĞİLDİR**, çocuk kabul etmez (`not-droppable`) ve yüksekliği 10-50 aralığındadır. Kutu içinde serbest içerik için `container` kullan. |
+| Katman | `modal` · `drawer` (şema kökünde — Kural 1d) |
+| Geri bildirim | `notification` (sayfa içi kutu) · `toast` (geçici bildirim; isOpen yükselen kenarı) · `form-validation-errors` · `confirm-bar` · `result` (işlem sonucu ekranı) · `emptystate` (boş liste; ikon YA DA görsel + aksiyon düğmeleri) |
+| Gezinme / başlık | `breadcrumb` · `breadcrumb-title` (başlık + daralan iz) · `page-header` · `header` · `sidebar` · `auth-layout` · `language-selector` (dil değiştirici) |
+| Sunum | `text` · `html` · `image` · `video` · `icon` · `qrcode` · `tags` · `avatar` · `badge` (sayaç “99+” / nokta / durum metni) · `carousel` · `iframe` (sandbox’lı gömme) · `jsonviewer` (katlanabilir JSON; JSON METNİNİ de parse eder) · `audit-basic` · `audit-history` |
+
+> **`chart` komponenti VAR (2026-08-25 ölçümü) — bu satır düzeltildi.** Rehberin önceki hâli
+> "grafik komponenti yoktur, `html` + `loadScript` kullanın" diyordu; `component_list` çıktısında
+> `chart` kayıtlıdır ve `component_get(slug:'chart')` prop sözlüğünü verir. Veri `rows` prop'una
+> akışla yazılır (komponent kendi verisini ÇEKMEZ), kategori `categoryField`, değerler
+> `series[].valueField` ile çözülür; `aggregate`/`sort`/`topN` dönüşümü komponent yapar.
+> `html` + `loadScript` yalnız `chart`'ın kapsamadığı görselleştirmeler için gerekir.
+>
+> **Veriye göre değişen form (çalışma anında N alan) `html` GEREKTİRMEZ — `repeater` bunu
+> yapar.** Girdiler şemaya tasarım anında yazılır ama `repeater` o şablonu `rows`'un her satırı
+> için yineler, `{{ item.<alan> }}` kod prop'u iki yönlü bağlanır ve alan tipi satır başına
+> `isHidden` ile seçilir. Anket / dinamik başvuru formu bu desenle kurulur — tam tarif ve
+> ölçülmüş sınırlar **Kural 1g**'de. (Bu satır 2026-08-19'da düzeltildi: önceki hâli "hazır
+> komponent yoktur, `html` kullanın" diyordu ve YANLIŞTI.)
+
+**Hiçbiri işi karşılamıyorsa `html` kaçış kapısıdır** — Mustache + `context` ile veri basar,
+`actions` + `fireEvent` ile flow tetikler, satır içi script çalıştırır. "Platform bunu yapamaz"
+demeden önce `platform_guide('html')` oku; genel komponent modeli için `platform_guide('component')`.
+
+Komponentlerin **`style` prop'u** vardır ve iç parçalara iner (`textinput.style`:
+`&__label` · `&__input` · `&__error` · `&__description`; `form.style`: `&__title` · `&__header` ·
+`&__body`). Tasarım kararlarını buradan uygula — varsayılan görünümle bırakmak zorunda değilsin.
+
+> **Boyut tuzağı:** katalog varsayılan `size`'ı `maxSize`'ı aşan komponentler var
+> (`textinput` default `h:8`, `maxSize.h:5`). Varsayılanı körü körüne kopyalarsan doğrulayıcı
+> reddeder; gateway aşan değeri `maxSize`'a kırpar ve `gatewayNormalized` ile bildirir.
+
+## Kural 8 — Korunan sayfa: `middlewareIds` vermeden `Page.user` YOKTUR
+
+Uçları middleware'e bağlamak sayfayı korumaz ve **`Page.user`'ı doldurmaz**. `Page.user`,
+sayfaya `page_update` ile bağlanan middleware'in `set-user` çıktısıdır; bağ yoksa `undefined`
+gelir ve `Page.user.x` okuyan her ifade *"Cannot read properties of undefined"* ile patlar.
+Bir `condition` adımında bu **sessizce else dalına düşmek** demektir.
+
+```
+page_update({ pageId, middlewareIds: ['<authenticate workflow id>'] })
+```
+
+Ölçüm (klinik/kutuphane/obs, 2026-08-18): 42 ucun 41'i middleware'e bağlıyken **sayfaların
+hiçbiri** bağlı değildi; üç portalın da rol menüsü boş çıkıyor, panel ifadeleri patlıyordu.
+
+İki şeyi karıştırma:
+
+| İstenen | Yol |
+|---|---|
+| Veri güvenliği | **ucun** `middlewareIds` + filtre `source:'expression'`, `value:'user.id'` |
+| `Page.user` + sayfa yönlendirmesi | **sayfanın** `middlewareIds`'i |
+
+> **`page.roleIds` yetki KAPATMAZ — güvenlik olarak ona güvenme.** Ölçüm (2026-08-18): `roleIds`
+> yalnız yönetici rollerine ayarlanmış bir sayfayı hasta rolündeki kullanıcı **açabildi** (sayfa
+> çizildi, tablo boş kaldı çünkü **uçlar** 401/403 verdi). `roleIds` menü/görünürlük kararı için
+> bir sinyaldir; erişimi kapatan tek şey **ucun** rol kapısıdır. **Ama `microservice.roles` de
+> tek başına kapı değildir** (ölçüm 2026-08-19: `roleIds` dolu + `middlewareIds` boş uç,
+> tokensız POST'u 200 ile kabul etti). `roles` yalnız middleware'e `triggerSource.roles` olarak
+> taşınan veridir; kapıyı kuran şey middleware içindeki açık `Authorized(user.roles)` adımıdır
+> (`platform_guide('middleware')` Tarif 3b). Bir ekranı gerçekten kapatmak istiyorsan verisini
+> besleyen her ucu `middlewareIds` + `Authorized` kapısına al; sayfayı gizlemek kozmetiktir.
+>
+> **Sayfa kapısı VARDIR ama onu `redirect` DEĞİL, `redirect`'i izleyen `response` tutar.**
+> *(Ölçüm 2026-08-19 — bu bölümün önceki sürümü yanlıştı.)* `RedirectStep.cs` yalnız bir
+> `UiAction` kaydedip success dalından devam eder; durum kodunu değiştirmez. Akış `response`
+> adımı olmadan biterse sonuç 2xx kalır, `ExecutePageBehavior` kesmez ve **sayfanın tamamı
+> anonim isteğe döner** — üstelik `PagesController.HandleResult` `uiActions`'ı yalnız non-2xx
+> dalında yayınladığı için yönlendirme de kaybolur. Ölçüm: yalnız `redirect` ile biten guard'a
+> bağlı sayfa tokensız istekte **HTTP 200 + şemanın tamamı** döndürdü.
+>
+> Doğru desen (ölçülerek doğrulandı — 401, şema sızmadı, `uiActions` yönlendirmeyi taşıdı):
+>
+> ```
+> guard → [condition] triggerSource.type === 'page'
+>          ├─ if   → [redirect] expression: "'giris'"  →  [response] 401   ← kapı BURADA
+>          └─ else → [response] 401                                        ← uç çağrısı 401 alır
+> ```
+>
+> `redirect` adımının `nextStepId`'si `null` değil, **`response` adımını** göstermeli. Tam gövde
+> ve tırnak tuzağı (`"'giris'"` — tırnaksız yazarsan runtime'da `giris is not defined`):
+> `platform_guide('middleware')` Tarif 1b. **Korumalı her sayfa, tokensız bir istekle 401
+> verdiği görülerek kabul edilir;** 200 + şema dönüyorsa kapı kurulmamıştır.
+>
+> **Tokensız istek nasıl atılır:** `page_runtime_get` + **`anonymous: true`** — gateway o çağrıya
+> hiçbir `Authorization` header'ı koymaz; korumalı sayfada `middlewareBlocked` (401) dönmeli ve
+> şema gelmemelidir. Sayfanın ham serve yolu **`GET /{project}/{application}/p/{sayfa slug'ı}`**
+> (`PagesController:127` — `{project}` öneki ZORUNLUDUR; `/{app}/p/{slug}` tek başına 404 verir),
+> `Host: <org>.<suffix>` + `X-Environment` başlıklarıyla. Ham `curl` yerine tool'u kullanmak
+> yeterlidir.
+>
+> `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
+> (`dto_get` ile bak: genelde `role`, `role_name`, `roles_csv` vardır). Sayfa tarafında CSV
+> kullan — ayrıntı ve şablon `platform_guide('expressions')` §2.
+>
+> **Uç hata dönerse `.data` dizi değildir.** 401/404 sonrası `Steps.x.data` bir nesnedir ve
+> `rows || []` bunu yakalamaz (nesne truthy) → `rows.filter is not a function` /
+> `(items ?? []).map is not a function`. `Array.isArray(Steps.x?.data) ? Steps.x.data : []` yaz.
+
+## ⚠️ `page_schema_patch` `html` komponentini reddediyor — katalogda mükerrer kayıt (2026-08-19)
+
+`page_schema_patch` ile `html` eklemeye çalışırsan:
+
+```
+Component type 'html' has no prop named 'context'   → kabul edilenler: content
+Component type 'html' has no prop named 'style'
+Height of 'html' must be between 1 and 1
+```
+
+Oysa `component_get('html')` `content · context · style · actions · isHidden` prop'larını ve
+`maxSize {w:12,h:50}` döndürür. Çelişkinin sebebi **katalogdaki mükerrer satırlardır**:
+`development.components` tablosunda 11 slug'ın ikişer kaydı var —
+`button · checkbox · container · html · image · notification · numberinput · password · text ·
+textarea · textinput`. `ComponentRepository.FindBySlugsWithDefinitionsAsync` yalnız slug'a göre
+süzer (tekillik filtresi yok), `PageSchemaValidator` da `GroupBy(Slug).First()` yapar: **ilk
+satır kazanır ve sıralama garanti değildir.** `html`'de eski/fakir kayıt (tek prop `content`,
+0 event) gerçek kaydı (8 prop, `mount` olayı) gölgeliyor.
+
+Diğer 10 slug bugün çalışıyor çünkü zengin kayıt daha eski — bu tasarım değil sıralama şansıdır.
+
+**Neden yalnız micro-op hattı etkileniyor:** prop/boyut denetimi yalnız
+`PageSchemaValidationMode.Full`'de yapılır. `page_create`/`page_update` `Structural` çağırır,
+`layout_*` doğrulayıcıya hiç uğramaz. `Full` kullanan tek iki yer `page_schema_patch` ve
+`page_schema_validate`'tir.
+
+**Geçici çözüm (doğrulandı):** `html` içeren sayfayı `page_update(schema)` ile **tam gövde**
+yaz — `content`/`context`/`style`/`actions` prop'ları ve `events: [{ name:'mount', value:<flowId> }]`
+bağı kalıcı olur ve `page_runtime_get` paketinde görünür. Bedeli: o sayfada doğrulama duvarı,
+canlı canvas güncellemesi ve `baseVersion` iyimser kilidi devre dışı kalır. Kusur düzeltilince
+micro-op hattına dönün.
+
+> **Sıra kritik — `page_update(schema)` mevcut flow'ların setter hedeflerini KOPARIR.**
+> Setter iteratee'sindeki `element` bir string olarak saklanmaz: platform onu **kayıt anında**
+> sayfanın komponentlerine karşı çözüp `DesignComponentId`'ye çevirir. `page_update(schema)` ise
+> komponent satırlarını yeniden üretir (yeni id'ler) — daha önce kurulmuş her flow'un setter
+> hedefi böylece dangling kalır ve `flow_get` çıktısında **`element` alanı kaybolur**. Semptom:
+> akış koşar, microservice 200 döner, ama komponent hiç güncellenmez (ölçüm: anket projesi,
+> 2026-08-19 — `html` sonsuza kadar "yükleniyor" durumunda kaldı).
+>
+> Doğru sıra: komponentleri yaz → `page_update(schema)` ile `actions`/`events` bağlarını kur →
+> **en son** flow'ları oluştur. Şemayı sonradan yeniden yazmak zorunda kaldıysan **etkilenen her
+> flow'u `flow_update` ile yeniden kaydet** (aynı gövde yeter; kayıt sırasında hedefler tekrar
+> çözülür) ve `flow_get` ile `element` alanının geri geldiğini doğrula.
+>
+> **Aynı tuzak micro-op yolunda da var:** `page_schema_patch` ile bir düğümü
+> `remove_component` + `add_component` yapıp **aynı `elementId`'yi** geri koyduğunda satırın
+> `DesignComponentId`'si yenidir — o düğümü hedefleyen setter'lar yine dangling kalır. Ölçüm
+> (anket-native, 2026-08-19): `q_list` repeater'ı `isWrapper`'ı düzeltmek için yeniden kurulunca
+> `t_title`/`t_desc` setter'ları çalışmaya devam etti (dokunulmamışlardı) ama `q_list.rows`
+> 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.**
+
+## Bilinen sınırlar
+
+- **Ekranı tarayıcıdan doğrularken: `dropdown` ve `multi-select` seçeneklerine tıklamak için iç
+  `<button>`'ı hedefle.** Bu iki komponentin açılır listesinde satır sarmalayıcıları (`div`) tıklama
+  dinlemiyor; asıl dinleyici `button.ng-select-item__content` (dropdown) ve
+  `button.ng-multiselect-item__content` (multi-select). Ölçüm (2026-08-19): satır `div`'ine tam
+  pointer dizisi (`pointerdown/mousedown/pointerup/mouseup/click`) göndermek değeri DEĞİŞTİRMEDİ
+  (`in_status.value` `draft` kaldı); iç `button`'a düz `.click()` göndermek değiştirdi
+  (`published`). Listeyi açmak için ise `.ng-select__value-container` / `.ng-multiselect`'e tam
+  pointer dizisi gerekir — düz `.click()` açmıyor. Değeri doğrulamanın kesin yolu DOM değil
+  `machine.getNode('<elementId>').props.value`'dur.
+- **`style` prop'una CSS STRING yazma — nesne olmak zorunda.** String de kabul edilir ve emotion onu
+  CSS metni sayar, ama (a) `--ng-*` token ezemezsin, (b) iç seçici / pseudo-class yazamazsın,
+  (c) yanlışlıkla kabın kendi düzenini bozarsın. Ölçüm (anket-admin giriş sayfası, 2026-08-19):
+  `page_container.style` string olarak `display:flex; align-items:center; justify-content:center`
+  taşıyordu; `.ng-container` zaten `display:flex; flex-direction:column` olduğu için kabın iç
+  düzeni çöktü — kart **66px genişlik × 733px yükseklik**, buton 44px çizildi. Aynı ekran nesne
+  style + Kural 1h deseniyle yeniden kurulunca kart 400px'e ve ortaya oturdu. Gateway bunu **PAGE-014 (uyarı)** ile
+  yanıtın `layoutWarnings` alanında bildirir. **Düzeni `style` ile kurmaya hiç kalkışma:**
+  ortalama/yaslama/aralık işi kapsayıcının kendi `layout: 'flex'` prop grubuna aittir (Kural 1f-2).
+- **`isHidden` olmayan komponent listesine `dropdown` da dahildir** (`text`, `multi-select`,
+  `dropdown`). Koşullu göstermek için `isHidden`'ı olan bir `container`'a sar (Kural 1g).
+- **Ana sayfayı TAŞIYAMAZSIN — `application_update.homepageId` kalıcı DEĞİL ve yanıtı yanıltıcı.**
+  `ApplicationService.UpdateAsync` sayfaları `AsNoTrackingWithIdentityResolution()` ile okunmuş
+  **takipsiz** bir graf üzerinde `SetHomepage(...)` ile işaretliyor; yanıttaki `homepage` alanı bu
+  bellek içi değişiklikten üretildiği için **yeni sayfayı gösterir ama `pages.is_homepage` diskte
+  değişmez** (ölçüm 2026-08-19: çağrıdan sonra `page_get` eski sayfada hâlâ `isHomepage: true`,
+  yeni sayfada `false`). Sonucu: **ana sayfa silinemez** (`CantDeleteHomepage`) ve gateway'de bunu
+  düzeltmenin yolu yoktur — `UpdatePageCommand`'da `IsHomepage` alanı yok.
+  Daha kötüsü **iki ayrı ana sayfa kapısı var ve birbirine düşebilir:** çağrıdan sonra eski sayfa
+  `pages.is_homepage` yüzünden ("… ana sayfadır ve silinemez"), YENİ sayfa da application'ın
+  referansı yüzünden ("The home page can't be deleted") silinemez hâle geldi; kilidi açmak için
+  `application_update`'i eski sayfaya geri çevirmek gerekti.
+  **Pratik kural:** ana sayfayı değiştirmen gerekiyorsa sayfayı silip yeniden kurma —
+  **mevcut ana sayfanın İÇİNİ** değiştir (`remove_component` + `add_component`), böylece slug,
+  ana sayfa bayrağı ve gelen bağlantılar korunur. Gerçek ana sayfa taşıma Studio'dan yapılmalı.
+- **Akış adımlarının `branches[].id` ve `iteratees[].id` GUID'leri TÜM projede tekildir.** Başka
+  bir sayfadaki akıştan kopyaladığın gövdeyi aynı GUID'lerle `flow_create`'e verirsen platform
+  `RowAlreadyExists` döner — hata mesajı slug çakışması gibi okunur ve seni yanlış yere götürür
+  (ölçüm 2026-08-19: slug'ı değiştirmek çözmedi, GUID'leri değiştirmek çözdü). Şablon olarak
+  `flow_get` çıktısı kullanırken **bütün id alanlarını yenile**.
+- **Katalog kaydı frontend'in gerisinde kalabiliyor — doğrulama duvarı frontend'i değil KATALOĞU
+  bilir.** Bir prop'un renderer'da çalışıyor olması onu yazabileceğin anlamına gelmez; **tek
+  referans `component_get`'tir** (platform o satırı `unknown-prop` duvarında kullanır). Yaşanmış
+  örnek ve **kapanışı**: `container`'ın flex düzen grubu (`layout`, `direction`,
+  `horizontalAlign`, `verticalAlign`, `size`, `gap`, `wrap`) 2026-08-19 ölçümünde `ng-apps-ui`
+  şemasında ve renderer'da vardı ama katalog satırında YOKTU — `page_schema_patch` hepsini
+  `unknown-prop` ile reddediyordu. **2026-08-25 ölçümü: katalog güncellenmiş**, yedi prop da
+  `component_get(slug:'container')` çıktısında (varsayılanlarıyla birlikte) ve
+  `page_schema_validate` hepsine `valid: true` diyor — flex kapsayıcı artık şemadan kurulur
+  (Kural 1f-2). Aynı sınıf sorunun HÂLÂ açık örneği: `text` ve `multi-select` komponentlerinde
+  `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
+  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
+  `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ş**
+  render edilir. `set_binding` micro-op'u eski sürümlerde `data`'ya yazıyordu — bu davranış
+  düzeltildi, ama daha önce kurulmuş sayfalarda kalıntı olabilir. Prop nesnesini birebir
+  kontrol etmen gerekirse `remove_component` + `add_component` ile
+  `{"type":"code","ref":"{{ … }}","data":"<yedek>"}` yaz; `replace_prop` her zaman `static` kurar.
+
+- **Ana sayfa sayfadan değil application'dan değişir:** `page_create/update` gövdesindeki
+  `isHomepage` platformca yok sayılır (tasarım). Doğru yol `application_update` →
+  `homepageId`; platform o çağrıda uygulamanın tek sayfasını ana sayfa yapar. `page_delete`
+  ana sayfayı reddeder — gateway bunu istek göndermeden söyler.
+- **Runtime çıktısı `page_runtime_get` ile okunur:** Studio preview'u ve çıkan uygulama aynı
+  ucu (`GET {application}/p/{slug}`) tüketir; bu tool birleşik son hâli (şema + layout +
+  olaylar + flow'lar) döner ve sayfaya bağlı middleware'ler çağrıda GERÇEKTEN koşar —
+  korumalı sayfada `middlewareBlocked` dönmesi beklenen davranıştır ve kendisi bir
+  doğrulamadır. Tam doğrulama seti: `page_schema_validate` (kuru koşu) + `page_get` (bağlar)
+  + `page_runtime_get` (son hâl).
+- **Sayfada dosya toplanabilir:** `fileUpload` (dropzone) · `fileInput` · `filebutton`
+  komponentleri vardır, göstermek için `image` · `file-viewer`. Yani "dosya yükleyerek cevapla"
+  tipi bir alan kurulabilir. Gateway tarafında `file_upload`/`file_download` tool'ları eklendi
+  (multipart / `outPath`) ama **canlı platforma karşı henüz doğrulanmadı** — ilk kullanımda
+  sonucu teyit et.