@appaflytech/zeyrek-ai-mcp 0.0.5 → 0.0.7

package/dist/knowledge/normalize.js

@@ -1,4 +1,5 @@
 import { logStep } from '../observability/trace.js';
+import { PlatformApiError } from '../platform/errors.js';
 import { ensureWorkflowErrorPath } from './errorPath.js';
 const SORT_DEFAULT = { name: 'sortField', type: 'sortType', source: 'query-string' };
 const LIMIT_DEFAULT = { name: 'limit', offset: 'offset', source: 'query-string' };
@@ -79,6 +80,33 @@ function fillRootAlias(table, fixes) {
     table.alias = alias;
     fixes.push(`kök alias '${alias}' olarak dolduruldu — join'li table'da kök alias boşsa SQL'e '.<alan>' gider ve Postgres 42601 (zero-length delimited identifier) döner`);
 }
+/**
+ * S-06 (2026-09-09 koşusu): yazma alanlarında `alias` sözleşmede YOKTUR. Okuma/dönüş seçimleri
+ * `TableSelect` ile modellenir ve `Alias`/`Path`/`FieldSlug` taşır; yazılacak alanlar ise
+ * `TableField` ile — o sınıfta yalnız `FieldId`, `Source`, `Value`, `FolderId`, `Order`,
+ * `WriteOn` vardır (`MicroserviceTableGetParameter.cs:326`; aynı tip `WorkflowDto.cs:252`
+ * table step kuralında da kullanılıyor). Gönderilen `alias` model bağlamada düşer, yanıt onu
+ * geri getirmez ve `silentlyDropped` her yazma çağrısında sahte bir kayıp satırı basardı.
+ * Alan gövdeden **istek gitmeden** çıkarılır ve `gatewayNormalized` ile bildirilir — kayıp değil,
+ * sözleşme dışı bir alan.
+ *
+ * Sıra önemlidir: `fillRootAlias` kök alias'ı türetirken `fields[].alias`'ı da aday sayar, bu
+ * yüzden ayıklama ondan SONRA çalışır.
+ */
+function dropWriteFieldAliases(table, fixes) {
+    const dropped = [];
+    for (const field of asObjects(table.fields)) {
+        const alias = String(field.alias ?? '').trim();
+        if (!Object.hasOwn(field, 'alias'))
+            continue;
+        delete field.alias;
+        if (alias)
+            dropped.push(`${alias}.${String(field.fieldSlug ?? field.fieldId ?? '?')}`);
+    }
+    if (dropped.length === 0)
+        return;
+    fixes.push(`fields[].alias gövdeden çıkarıldı (${dropped.join(', ')}): yazma alanları TableField ile modelleniyor ve o sözleşmede alias YOK — alias yalnız selectFields / returnFields / filters / joins için geçerlidir (platform_guide('microservice') §Alias nerede geçerli)`);
+}
 /**
  * Platform sort/limit'i null bırakır ve path'i türetmez; Studio ikisini de guard'sız okur.
  * Eksik olanları doldurur, dolu olanlara DOKUNMAZ (yanlış değerleri MS-007 block'u yakalar).
@@ -103,6 +131,7 @@ export function normalizeTableParameters(parameters, fallbackEntityId) {
         fillJoinPaths(rootEntityId, table.joins, [], aliasChains, fixes);
         fillSelectionPaths(table, aliasChains, fixes);
     }
+    dropWriteFieldAliases(table, fixes);
     return fixes;
 }
 export function normalizeMicroserviceDefinition(definition) {
@@ -194,9 +223,79 @@ export function normalizeWorkflowDefinition(definition) {
  * '<adım adı>.data'dır; verilmemiş isRaw'ı buna eşitliyoruz ki editörde bir kez açılan akış
  * sessizce başka bir şeye dönüşmesin. Kalan tutarsızlığı FLOW-009 yakalar.
  */
-export function normalizeFlowSteps(steps) {
+/**
+ * Adım tipi sözlüğü backend'in, KOŞAN tipler barındırıcının: motor yedi tip register eder, web
+ * `Runtime.svelte` altı, mobil `ScreenRuntime.tsx` beş tip ekler ve aynı sayfa kaydı ikisinde de
+ * koşar. Register edilmemiş bir tipe gelen akış sessizce ölür (`flow-engine.ts` `process()`
+ * callback bulamazsa next/completed/stopped hiç çağrılmaz), üstelik `run()` promise'i
+ * çözülmediği için `__ngAppsFlowActivity.running` sıfıra inmez. İki hâl tamamen türetilebilir
+ * olduğu için lint değil NORMALİZASYON — kalanı (`confirm`/`download` mobilde yok) yalnız
+ * uygulama tarafında kapanabilir, `FLOW-023` onları uyarır.
+ */
+function normalizeFlowHostGaps(steps, list) {
     const fixes = [];
-    for (const step of asObjects(steps)) {
+    const label = (step) => String(step.stepId ?? step.name ?? '?');
+    // 'end' adımını hiçbir barındırıcı register etmez ve Studio yeni akışı YALNIZ bir start adımıyla
+    // tohumlar (`event-actions.context.ts` initFlow) — yani End düğümü hiçbir yerde gerekmiyor.
+    // Ona işaret eden dal `nextStepId: null` olur (motor completed/stopped'ı düzgün çağırır) ve ölü
+    // adım gövdeden çıkar; bırakılsaydı FLOW-005 onu haklı olarak erişilemez adım diye bloklardı.
+    const endStepIds = new Set(list
+        .filter(step => step.type === 'end')
+        .map(step => String(step.stepId ?? ''))
+        .filter(id => id.length > 0));
+    for (const step of list) {
+        // navigate ile redirect'in argümanı AYNI ({ path, pageId, query, targetBlank }) ama navigate'i
+        // yalnız mobil register eder; redirect ise iki barındırıcıda da koşar (mobilde aynı navigate
+        // uygulamasına eşlenir), yani redirect kesin üstün.
+        if (step.type === 'navigate') {
+            step.type = 'redirect';
+            fixes.push(`'${label(step)}': type navigate → redirect yazıldı — argüman şekli aynı ({ path, pageId, query, targetBlank }) ama navigate'i web barındırıcısı register etmez, redirect ikisinde de koşar`);
+        }
+        if (endStepIds.size === 0)
+            continue;
+        const branches = step.branches;
+        if (Array.isArray(branches)) {
+            for (const branch of asObjects(branches)) {
+                if (!endStepIds.has(String(branch.nextStepId ?? '')))
+                    continue;
+                branch.nextStepId = null;
+                fixes.push(`'${label(step)}': '${String(branch.name ?? branch.id ?? '?')}' dalının nextStepId'si null yazıldı — hedef bir 'end' adımıydı, o tipi hiçbir barındırıcı register etmez ve akış oraya girince çıkamaz`);
+            }
+        }
+        else if (branches && typeof branches === 'object') {
+            const dictionary = branches;
+            for (const name of Object.keys(dictionary)) {
+                if (!endStepIds.has(String(dictionary[name] ?? '')))
+                    continue;
+                dictionary[name] = null;
+                fixes.push(`'${label(step)}': '${name}' dalının nextStepId'si null yazıldı — hedef bir 'end' adımıydı, o tipi hiçbir barındırıcı register etmez ve akış oraya girince çıkamaz`);
+            }
+        }
+    }
+    if (Array.isArray(steps) && endStepIds.size > 0) {
+        for (let index = steps.length - 1; index >= 0; index--) {
+            const step = steps[index];
+            if (!step || typeof step !== 'object' || step.type !== 'end')
+                continue;
+            steps.splice(index, 1);
+            fixes.push(`'${label(step)}': 'end' adımı gövdeden çıkarıldı — motor bu tipi register etmez, Studio da yeni akışı yalnız start ile tohumlar; akış son adımın dalındaki nextStepId: null ile biter`);
+        }
+    }
+    return fixes;
+}
+export function normalizeFlowSteps(steps) {
+    const list = asObjects(steps);
+    const fixes = normalizeFlowHostGaps(steps, list);
+    for (const step of list) {
+        if (step.type === 'function') {
+            const args = (step.args ?? {});
+            if (!Array.isArray(args.parameters)) {
+                args.parameters = [];
+                step.args = args;
+                fixes.push(`'${String(step.stepId ?? step.name ?? '?')}': args.parameters=[] yazıldı — function adımı parametreleri dizi bekler; eşleme bildirimdeki ada göre, sıra konumsal (K5)`);
+            }
+            continue;
+        }
         if (step.type !== 'microservice')
             continue;
         const args = (step.args ?? {});
@@ -223,7 +322,10 @@ const REQUIRED_COLLECTIONS = ['events', 'validations', 'stateBindings', 'childre
  * girmez) — doğrulayıcı "valid" der, yazma patlar. Tamamen türetilebilir olduğu için lint
  * değil normalizasyon.
  */
-const PROP_VALUE_TYPES = new Set(['static', 'file', 'flow', 'widget', 'element', 'page', 'code']);
+// PropValueType (DesignComponentProperty.cs:421) — 'translation' listeden düşünce çeviriye bağlı
+// prop'un KENDİSİ veri sanılıp static Prop'a sarılıyordu: istek 200 dönüyor, prop bozuk kuruluyordu
+// (09-04 Y-22). Enum burada eksiksiz tutulur.
+const PROP_VALUE_TYPES = new Set(['static', 'file', 'flow', 'widget', 'element', 'page', 'code', 'translation']);
 function isPropShaped(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value) && PROP_VALUE_TYPES.has(String(value.type));
 }
@@ -387,6 +489,52 @@ export function schemaOpValidationErrors(ops) {
     }
     return errors;
 }
+/**
+ * F-06 — `style` prop'una kebab-case CSS anahtarı yazmak sessizce etkisiz kalıyor: platform
+ * değeri kabul ediyor, `page_schema_get` aynen geri veriyor ve runtime hiç uygulamıyor. Tek işaret
+ * tarayıcı konsolundaki tek satır ("Using kebab-case for css properties in objects is not
+ * supported. Did you mean minHeight?") ve `page_screenshot` konsolu döndürmediği için yalnız MCP
+ * ile çalışan bir ajan bunu HİÇ göremiyor. 09-05 koşusunun en pahalı yanlış teşhisi buydu (~15 dk)
+ * ve yanlış teşhis düğümleri silip yeniden kurmaya, o da 20 setter'ın kopmasına yol açtı.
+ *
+ * Seçici anahtarlara (`&__body`, `:hover`, `--token`) DOKUNULMAZ; yalnız `a-b` biçimli düz CSS
+ * özellik adları camelCase'e çevrilir ve çevrim `gatewayNormalized` ile bildirilir.
+ */
+const styleKeyPattern = /^[a-z][a-z0-9]*(-[a-z0-9]+)+$/;
+export function isStylePropName(name) {
+    return name === 'style' || /Style$/.test(name);
+}
+export function normalizeStyleKeys(value, label, fixed) {
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            normalizeStyleKeys(entry, label, fixed);
+        return;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    const record = value;
+    for (const key of Object.keys(record)) {
+        normalizeStyleKeys(record[key], label, fixed);
+        if (!styleKeyPattern.test(key))
+            continue;
+        const camel = key.replace(/-([a-z0-9])/g, (_, character) => character.toUpperCase());
+        if (Object.hasOwn(record, camel)) {
+            delete record[key];
+        }
+        else {
+            record[camel] = record[key];
+            delete record[key];
+        }
+        fixed.push(`${label}: '${key}' → '${camel}'`);
+    }
+}
+export function styleKeyNote(fixed) {
+    if (fixed.length === 0)
+        return [];
+    return [`stil anahtarları camelCase'e çevrildi (${fixed.join(' · ')}) — runtime kebab-case anahtarı OKUMAZ, `
+            + 'değer kaydedilir ama hiç uygulanmaz ve tek işareti tarayıcı konsoludur (F-06). '
+            + "Seçici anahtarlara ('&__body', ':hover', '--token') dokunulmadı."];
+}
 export function normalizeComponentDefaults(nodes) {
     const fixed = [];
     for (const node of asObjects(nodes)) {
@@ -402,7 +550,14 @@ export function normalizeComponentDefaults(nodes) {
             missing.push(key);
         }
         if (node.props && typeof node.props === 'object' && !Array.isArray(node.props)) {
-            const { wrapped, deepened } = wrapNodeProps(node.props);
+            const props = node.props;
+            const styleKeys = [];
+            for (const name of Object.keys(props).filter(isStylePropName)) {
+                normalizeStyleKeys(props[name], `${String(node.elementId ?? node.name ?? '?')}.${name}`, styleKeys);
+            }
+            if (styleKeys.length > 0)
+                missing.push(`stil anahtarları camelCase'e çevrildi: ${styleKeys.join(' · ')}`);
+            const { wrapped, deepened } = wrapNodeProps(props);
             if (wrapped.length > 0)
                 missing.push(`prop'lar Prop sarmalına alındı: ${wrapped.join('+')}`);
             if (deepened.length > 0)
@@ -459,7 +614,9 @@ function normalizeReplacePropValue(op) {
         op.expression = expression;
         return [`${label}: replace_prop code prop'u 'expression' alanına taşındı — kod prop'u value ile değil expression ile verilir`];
     }
-    return [];
+    // Applier her value'yu Static (ifade verilmişse Code) Prop'a çevirir; diğer tipler bu op'la
+    // ifade EDİLEMEZ. Sessiz bozuk kayıt yerine çağrı burada durur (09-04 Y-22).
+    throw new PlatformApiError(`${label}: '${propType}' tipli Prop replace_prop ile kurulamaz — bu op her değeri static (ifade verilmişse code) Prop'a çevirir, gönderdiğiniz sarmal Data'nın içine düşer ve prop sessizce bozulur. Bu prop'u add_component ile (komponenti yeniden ekleyerek) ya da page_update(schema) ile tam şema yazarak kurun; çeviri bağlama şekli için platform_guide('translation').`, 400);
 }
 export function normalizeSchemaOps(ops) {
     const components = [];
@@ -467,6 +624,9 @@ export function normalizeSchemaOps(ops) {
     const validations = [];
     for (const op of asObjects(ops)) {
         if (op.op === 'replace_prop') {
+            if (isStylePropName(String(op.prop ?? ''))) {
+                normalizeStyleKeys(op.value, `'${String(op.target ?? '?')}.${String(op.prop)}'`, props);
+            }
             props.push(...normalizeReplacePropValue(op));
             continue;
         }
@@ -501,6 +661,8 @@ export const PAGE_CONTAINER_ELEMENT_ID = 'page_container';
  * `CreatePageWhenApplicationCreatedEventHandler` + `SeedData`). Renderer varsayılanı
  * BİLMEZ — `isFlexLayout` yalnız düğümün kendi prop'una bakar — bu yüzden gateway'in kurduğu
  * kapsayıcı da seti açıkça taşır; yoksa Studio'dan açılan sayfa flex, MCP'den açılan ızgara olurdu.
+ * 2026-09-01: `wrap` varsayılanı `true` oldu (`DEFAULT_CONTAINER_LAYOUT_PROPS`) ve sete eklendi —
+ * `row` + `wrap:true` altında w:12 çocuklar alt satıra sararak dikey akar (eski tek-satır sıkışması bitti).
  */
 export function pageContainerNode() {
     return {
@@ -515,7 +677,8 @@ export function pageContainerNode() {
             horizontalAlign: { type: 'static', data: 'left' },
             verticalAlign: { type: 'static', data: 'top' },
             size: { type: 'static', data: 'shrink' },
-            gap: { type: 'static', data: 'medium' }
+            gap: { type: 'static', data: 'medium' },
+            wrap: { type: 'static', data: true }
         },
         blocks: [{ breakpoint: 1024, size: { h: 24, w: 12 }, position: { x: 0, y: 0 } }],
         states: { isSticky: false, isDroppable: true, isScrollable: true, isWrapper: true },
@@ -632,6 +795,123 @@ export function heightTypeNote(stamped) {
         : stamped.join(', ');
     return [`appearance.heightType yazıldı (${detail}): platform boş bırakılan appearance'ı 'fixed'e sabitliyor, Studio ise katalogdaki isDefaultAutoHeight'a bakıyor. 'fixed' düğüm tuvalde tam size.h*10px çizilip taşan içeriği kırptığı için katalog varsayılanı gövdeye açıkça yazıldı; bilerek sınırlamak istediğin düğüme appearance.heightType:'fixed' ver`];
 }
+/**
+ * Flex çocuğunun boyut modeli (2026-09-01, `AddSizeStringsToComponentAppearance`):
+ * `appearance.widthType` beş değer alır — `cover`/`contain` medya sığdırma, `auto`/`fixed`/`fill`
+ * flex-çocuk boyut modu. `fixed` iken serbest CSS uzunluğu `widthString`/`heightString`'den okunur;
+ * `fill`/`auto` string taşımaz (Studio paneli mod değişiminde string'i SİLER —
+ * `appearance-size.functions.ts` `buildFlexWidthMode`). Öncelik: fill > fixed(+string) > auto >
+ * eski 12 kolon span (`widthType` hiç yoksa). Eski backend bilinmeyen `widthType`'ı sessizce
+ * düşürür (`ComponentWidthType` enum'una `Fixed`/`Fill` 2026-09-01'de eklendi).
+ */
+const WIDTH_TYPES = new Set(['cover', 'contain', 'auto', 'fixed', 'fill']);
+/**
+ * `packages/ng-apps-screen-builder/src/flex-layout.ts` `normalizeCssSize`'ın birebir portu:
+ * çıplak sayı → px; birimler px/%/vw/vh/vmin/vmax/rem/em/ch; `calc(...)` aynen geçer; gerisi
+ * (negatif, `pt`, `fr`, `auto`…) undefined — platform kaydeder ama panel/runtime değeri düşürür.
+ */
+export function normalizeCssSize(raw) {
+    if (typeof raw === 'number')
+        return Number.isFinite(raw) && raw > 0 ? `${raw}px` : undefined;
+    const value = String(raw ?? '').trim();
+    if (!value)
+        return undefined;
+    if (/^\d+(\.\d+)?$/.test(value))
+        return `${value}px`;
+    if (/^\d+(\.\d+)?(px|%|vw|vh|vmin|vmax|rem|em|ch)$/.test(value))
+        return value;
+    if (/^calc\(.+\)$/.test(value))
+        return value;
+    return undefined;
+}
+function appearanceOf(node) {
+    return (node.appearance && typeof node.appearance === 'object' && !Array.isArray(node.appearance)
+        ? node.appearance
+        : {});
+}
+/**
+ * Studio paritesi: panel çıplak sayıyı `px`e çevirerek yazar (`buildFlexSizeValue`), gateway de
+ * aynısını yapar ki iki yoldan kurulan şema aynı görünsün. Yalnız türetilebilir olan çevrilir;
+ * geçersiz değerler burada DEĞİL `flexSizeWarnings`'te raporlanır (uyarı, silme değil — platform
+ * da silmiyor, yalnız okumuyor).
+ */
+export function normalizeSizeStrings(nodes) {
+    const fixed = [];
+    for (const node of asObjects(nodes)) {
+        const appearance = appearanceOf(node);
+        for (const field of ['widthString', 'heightString']) {
+            const raw = appearance[field];
+            if (raw === undefined || raw === null || raw === '')
+                continue;
+            const normalized = normalizeCssSize(raw);
+            if (normalized !== undefined && normalized !== raw) {
+                appearance[field] = normalized;
+                node.appearance = appearance;
+                fixed.push(`${String(node.elementId ?? node.name ?? node.type ?? '?')}.${field}: ${String(raw)} → ${normalized}`);
+            }
+        }
+        fixed.push(...normalizeSizeStrings(node.children));
+    }
+    return fixed;
+}
+export function sizeStringNote(fixed) {
+    if (fixed.length === 0)
+        return [];
+    return [`Boyut string'i normalize edildi (${fixed.join(', ')}): Studio paneli çıplak sayıyı px'e çevirerek yazar (appearance-size.functions.ts buildFlexSizeValue), gateway aynı biçimi üretir`];
+}
+/**
+ * U-05 (2026-09-09 koşusu): platform yazılmamış bir `appearance` alanını gövdede `null` olarak
+ * döndürüyor — `page_container` her yeni sayfada `widthType: null` ile geliyor. Yanıt katmanı
+ * null'ları eliyor (`responses.ts` `prune`), yani ajan öyle bir alan GÖRMÜYOR; lint ise ham
+ * gövdeye baktığı için `String(null)` = `'null'` diye bilinmeyen mod uyarısı basıyordu. Her yeni
+ * sayfanın ilk `page_schema_patch`'inde çıkan, kullanıcının düzeltemeyeceği gürültü buydu.
+ * `null` ve boş string = **yazılmamış**; `widthString`/`heightString` zaten böyle davranıyor.
+ */
+function sizeMode(raw) {
+    return raw === undefined || raw === null || raw === '' ? undefined : String(raw);
+}
+/**
+ * İki uyarı tek yürüyüşte:
+ *
+ * - **mod uyumsuzluğu** (`mismatchCode`): `widthString`/`heightString` var ama ilgili
+ *   `*Type` `'fixed'` değil — string yalnız `fixed` modda okunur (`getFlexChildStyle`;
+ *   `fill` her şeyi ezer), Studio paneli mod değişiminde string'i siler. Yazan ajan
+ *   büyük olasılıkla modu yazmayı unutmuştur.
+ * - **geçersiz değer / bilinmeyen mod** (`invalidCode`): `normalizeCssSize`'dan geçmeyen
+ *   string ya da `WIDTH_TYPES` dışı `widthType` — platform 200 döner ama değer sessizce
+ *   düşer (eski backend bilinmeyen enum'u da düşürür).
+ *
+ * Uyarı yalnız **yazılmış** değer için çıkar: `null` ve boş string yazılmamış sayılır
+ * (`sizeMode`). Boyut string'leri bunu zaten yapıyordu, modlar yapmıyordu.
+ */
+export function flexSizeWarnings(nodes, mismatchCode, invalidCode) {
+    const warnings = [];
+    const walk = (list) => {
+        for (const node of list) {
+            const appearance = appearanceOf(node);
+            const label = String(node.elementId ?? node.name ?? node.type ?? '?');
+            const widthType = sizeMode(appearance.widthType);
+            const heightType = sizeMode(appearance.heightType);
+            if (widthType !== undefined && !WIDTH_TYPES.has(widthType)) {
+                warnings.push(`${invalidCode}: '${label}' düğümünde bilinmeyen widthType '${widthType}' — geçerli küme: cover · contain · auto · fixed · fill. Platform kabul eder ama renderer okumaz, eski backend enum'u sessizce düşürür.`);
+            }
+            for (const [field, type, mode] of [['widthString', widthType, 'widthType'], ['heightString', heightType, 'heightType']]) {
+                const raw = appearance[field];
+                if (raw === undefined || raw === null || raw === '')
+                    continue;
+                if (normalizeCssSize(raw) === undefined) {
+                    warnings.push(`${invalidCode}: '${label}' düğümünde ${field} ('${String(raw)}') geçerli bir CSS uzunluğu değil — kabul edilenler: çıplak sayı (px sayılır), px · % · vw · vh · vmin · vmax · rem · em · ch birimli değer, calc(...). Negatif/pt/fr/auto GEÇMEZ; platform kaydeder ama panel ve runtime değeri sessizce düşürür.`);
+                }
+                if (type !== 'fixed') {
+                    warnings.push(`${mismatchCode}: '${label}' düğümünde ${field} var ama ${mode} 'fixed' değil (${type ?? 'yok'}) — string yalnız ${mode}:'fixed' iken okunur; 'fill' her şeyi ezer, 'auto'/mod yokken 12 kolon span geçerlidir. Sabit ölçü istiyorsan aynı düğüme ${mode}:'fixed' da yaz — platform_guide('component') §appearance.`);
+                }
+            }
+            walk(asObjects(node.children));
+        }
+    };
+    walk(asObjects(nodes));
+    return warnings;
+}
 const GRID_COLUMNS = 12;
 const DESKTOP_BREAKPOINT = 1024;
 const DEFAULT_RECT = { x: 0, y: 0, w: 12, h: 6 };
@@ -732,7 +1012,7 @@ function moveActive(items, active) {
         ? item
         : moved.find(entry => entry.elementId === item.elementId) ?? item));
 }
-function reorderSiblings(nodes) {
+function reorderSiblings(nodes, causes) {
     const laidOut = nodes
         .map((node, index) => ({ node, elementId: typeof node.elementId === 'string' && node.elementId !== '' ? node.elementId : `#${index}` }))
         .filter(entry => !ROOT_LAYER_TYPES.has(String(entry.node.type ?? '')));
@@ -741,8 +1021,17 @@ function reorderSiblings(nodes) {
     let items = laidOut.map(entry => ({ elementId: entry.elementId, rect: rectOf(desktopBlock(entry.node)) }));
     for (const entry of laidOut) {
         const active = items.find(item => item.elementId === entry.elementId);
-        if (active)
-            items = moveActive(items, active);
+        if (!active)
+            continue;
+        // Kimin ittiğini burada yakalıyoruz: bildirim "y değişti" demekle kalmayıp hangi kardeşle
+        // hücre paylaşıldığını da söylesin (G-31). Aynı düğüm birden çok turda itilirse SON iten
+        // kalır — düzeni açıklayan da odur.
+        const beforeMove = new Map(items.map(item => [item.elementId, item.rect.y]));
+        items = moveActive(items, active);
+        for (const item of items) {
+            if (beforeMove.get(item.elementId) !== item.rect.y)
+                causes.set(item.elementId, entry.elementId);
+        }
     }
     let moved = 0;
     for (const [index, entry] of laidOut.entries()) {
@@ -764,11 +1053,11 @@ function reorderSiblings(nodes) {
     }
     return moved;
 }
-function reorderPass(nodes) {
+function reorderPass(nodes, causes) {
     const siblings = asObjects(nodes);
-    let moved = reorderSiblings(siblings);
+    let moved = reorderSiblings(siblings, causes);
     for (const node of siblings) {
-        moved += reorderPass(node.children);
+        moved += reorderPass(node.children, causes);
     }
     return moved;
 }
@@ -811,12 +1100,17 @@ const MAX_REORDER_PASSES = 8;
  */
 export function reorderSchemaBlocks(nodes) {
     const before = [];
+    const causes = new Map();
     collectLayout(nodes, before);
-    for (let pass = 0; pass < MAX_REORDER_PASSES && reorderPass(nodes) > 0; pass++)
+    for (let pass = 0; pass < MAX_REORDER_PASSES && reorderPass(nodes, causes) > 0; pass++)
         continue;
     return before
         .filter(entry => rectOf(desktopBlock(entry.node)).y !== entry.y)
-        .map(entry => `${entry.label} y:${entry.y}→${rectOf(desktopBlock(entry.node)).y}${entry.hasBlock ? '' : " (desktop block'u yazıldı)"}`);
+        .map(entry => {
+        const cause = causes.get(entry.label);
+        const reason = cause && cause !== entry.label ? ` — '${cause}' ile aynı hücreleri paylaşıyordu` : '';
+        return `${entry.label} y:${entry.y}→${rectOf(desktopBlock(entry.node)).y}${entry.hasBlock ? '' : " (desktop block'u yazıldı)"}${reason}`;
+    });
 }
 export function reorderNote(moved) {
     if (moved.length === 0)
@@ -1177,6 +1471,9 @@ export function stringStyleWarning(ids) {
  * kapsayıcıya `direction: 'column'` yazmak SESSİZCE hiçbir şey yapmaz — doğrulama duvarı da
  * susar, çünkü prop katalogda VARDIR (2026-08-25 ölçümü: `page_schema_validate` yedi prop'a da
  * `valid: true` döndü). Katalog varsayılanına eşit değerler elenir; onlar niyet taşımaz.
+ * `wrap` varsayılanı 2026-09-01'de beş kapsayıcı şemasında ve Studio
+ * `DEFAULT_CONTAINER_LAYOUT_PROPS`'ta `false` → `true` oldu; buradaki küme onu izler,
+ * yoksa varsayılanla kurulmuş her düğüm yanlış pozitif üretir.
  */
 const FLEX_LAYOUT_DEFAULTS = {
     direction: 'row',
@@ -1184,16 +1481,34 @@ const FLEX_LAYOUT_DEFAULTS = {
     verticalAlign: 'top',
     size: 'shrink',
     gap: 'medium',
-    wrap: false
+    wrap: true
 };
 /** Kapsayıcı düzenini kuran prop kümesi (`ContainerComponent` şeması): `layout` + ona bağlı altı ayar. */
 export const FLEX_LAYOUT_PROP_NAMES = new Set(['layout', ...Object.keys(FLEX_LAYOUT_DEFAULTS)]);
+/**
+ * Düzen prop grubunu taşıyan komponent tipleri: `packages/ng-apps-ui/src/components` altında
+ * kendi `schema.ts` dosyasında `horizontalAlign` tanımlayanlar. Kural yalnız bunlara uygulanır — `button` · `avatar` ·
+ * `icon` gibi komponentlerin KENDİ `size` prop'u flex `size`'ı değildir ve dokuz komponent için
+ * yanlış uyarı üretiyordu (09-04 Y-08).
+ */
+const FLEX_LAYOUT_HOST_TYPES = new Set(['aibox', 'box', 'box-section', 'container', 'page-container', 'form', 'layout', 'widget-area']);
+/**
+ * Eski `cssgrid` (box/aibox'ın akan gerçek `display:grid` kipi; 2026-09-02'de seçenek olmaktan
+ * çıktı, kayıtlı düğümlerde çalışmaya devam ediyor) düzen prop'larının HEPSİNİ ölü yapmaz:
+ * `getGridChildrenStyle` boşluğu (`gap`/`gapCustom` → `resolveFlexGap`) ve `verticalAlign`'ı
+ * ('stretch' ise `align-items`) okur. Bu ikisini ölü diye bildirmek, çalışan bir ayarı
+ * sildirirdi. Kaynak: `packages/ng-apps-screen-builder/src/grid-layout.ts`.
+ */
+const CSS_GRID_READ_PROPS = new Set(['gap', 'verticalAlign']);
 export function inertFlexPropNodes(nodes) {
     const found = [];
     const walk = (list) => {
         for (const node of list) {
-            if (!isFlexContainer(node)) {
+            if (FLEX_LAYOUT_HOST_TYPES.has(String(node.type ?? '')) && !isFlexContainer(node)) {
+                const isCssGrid = staticPropValue(node, 'layout') === 'cssgrid';
                 const inert = Object.keys(FLEX_LAYOUT_DEFAULTS).filter(name => {
+                    if (isCssGrid && CSS_GRID_READ_PROPS.has(name))
+                        return false;
                     const value = staticPropValue(node, name);
                     return value !== undefined && value !== null && value !== FLEX_LAYOUT_DEFAULTS[name];
                 });
@@ -1214,6 +1529,69 @@ export function inertFlexPropWarning(entries) {
             + "sessizce yok sayılır (istek reddedilmez, prop katalogda vardır). Akış düzeni istiyorsan aynı düğüme "
             + "layout:'flex' de yaz, istemiyorsan bu prop'ları kaldır — platform_guide('page') Kural 1f-2."];
 }
+/**
+ * Bir yamanın SİLECEĞİ akışlar. Platform referanssız kalan akışı KALICI siler; uyarı yamadan sonra
+ * geldiğinde "önce yedekle" tavsiyesi uygulanamaz hâle geliyordu (09-05 koşusu: sekiz adımlı giriş
+ * akışı sıfırdan yeniden yazıldı). Bu yüzden plan yamadan ÖNCE hesaplanır — `remove_component`
+ * kadar `set_event`/`remove_event` de akış öldürür ve o yolda hiç uyarı yoktu.
+ */
+export function orphanedFlowPlan(schema, pageEvents, ops) {
+    const nodes = asObjects(schema);
+    const opList = asObjects(ops);
+    const plan = [];
+    const survivingRefs = (skipElementId, skipEvent) => {
+        const surviving = new Set();
+        for (const event of asObjects(pageEvents)) {
+            if (typeof event.value === 'string')
+                surviving.add(event.value);
+        }
+        collectFlowRefsExcept(nodes, skipElementId, surviving);
+        if (skipEvent !== undefined) {
+            const node = findNodeByElementId(nodes, skipElementId);
+            for (const event of asObjects(node?.events)) {
+                if (String(event.name ?? '') !== skipEvent && typeof event.value === 'string')
+                    surviving.add(event.value);
+            }
+            for (const flowId of collectFlowRefs({ ...(node ?? {}), events: [] }))
+                surviving.add(flowId);
+        }
+        return surviving;
+    };
+    for (const op of opList) {
+        const target = String(op.target ?? '');
+        if (target === '')
+            continue;
+        if (op.op === 'remove_component') {
+            const doomed = findNodeByElementId(nodes, target);
+            if (!doomed)
+                continue;
+            const losing = collectFlowRefs(doomed);
+            const surviving = survivingRefs(target);
+            const orphaned = [...losing].filter(flowId => !surviving.has(flowId));
+            if (orphaned.length > 0)
+                plan.push({ target, op: 'remove_component', flowIds: orphaned });
+            continue;
+        }
+        if (op.op !== 'set_event' && op.op !== 'remove_event')
+            continue;
+        const eventName = String(op.event ?? '');
+        const node = findNodeByElementId(nodes, target);
+        const current = asObjects(node?.events).find(event => String(event.name ?? '') === eventName);
+        const currentValue = typeof current?.value === 'string' ? current.value : '';
+        if (currentValue === '' || currentValue === String(op.eventValue ?? ''))
+            continue;
+        const surviving = survivingRefs(target, eventName);
+        if (!surviving.has(currentValue))
+            plan.push({ target, op: String(op.op), flowIds: [currentValue] });
+    }
+    return plan;
+}
+export function orphanedFlowMessage(plan) {
+    const lines = plan.map(entry => `'${entry.target}' (${entry.op}) → ${entry.flowIds.join(', ')}`);
+    return `İstek gönderilmedi: bu yama ${plan.reduce((total, entry) => total + entry.flowIds.length, 0)} akışı sayfada referanssız bırakıyor ve platform referanssız akışı KALICI siler — ${lines.join(' · ')}. `
+        + 'Akışı korumak için önce flow_get ile gövdesini yedekleyin ya da set_event ile başka bir komponente bağlayın. '
+        + 'Silinmesini bilerek istiyorsanız aynı çağrıyı allowFlowDeletion: true ile tekrarlayın; yanıt hangi akışların silindiğini listeler.';
+}
 export function orphanedFlowWarnings(schema, pageEvents, ops) {
     const removals = asObjects(ops).filter(op => op.op === 'remove_component');
     if (removals.length === 0)
@@ -1251,6 +1629,112 @@ function findNodeByElementId(nodes, elementId) {
     }
     return undefined;
 }
+/**
+ * `orphanedFlowWarnings` silinen düğümün REFERANS VERDİĞİ akışları bulur; burası ters yönü kapsar:
+ * silinen düğümü HEDEFLEYEN setter adımlarını. Aynı `elementId` ile hemen yeniden eklense bile
+ * platform komponent kimliğini yeniden üretir ve setter sessizce ölür — akış koşar, istek 200
+ * döner, komponente hiçbir şey yazılmaz ve tek belirti boş komponenttir. ÖLÇÜLDÜ 2026-09-04
+ * (benchmark 4. koşu, `S-9`): teşhis ~8 dakika sürdü, uç doğru veri döndürdüğü ve şema geçerli
+ * olduğu için hatayı yalnız ekran görüntüsü gösterdi. Kural `platform_guide('page')` Kural 1f'de
+ * yazılı ama düğüm silinmeden ÖNCE okunması gerekiyor; bu uyarı tek erken sinyaldir.
+ */
+export function staleSetterWarnings(flows, ops, schema) {
+    const opList = asObjects(ops);
+    const removed = new Set(opList
+        .filter(op => op.op === 'remove_component')
+        .map(op => String(op.target ?? ''))
+        .filter(target => target.length > 0));
+    if (removed.size === 0)
+        return [];
+    // Silinen KAPSAYICININ altındaki düğümler de gider. Eskiden yalnız op'un kendi target'ına
+    // bakılıyordu; 09-05 koşusunda `sign_in_form` silinince ona değil ÇOCUĞU `btn_sign_in`'e yazan
+    // setter sessizce koptu ve uyarı hiç çıkmadı (G-21). Komşu işlev `orphanedFlowWarnings` alt ağacı
+    // zaten geziyordu — iki işlev aynı olaya bakıp farklı derinlik kullanıyordu.
+    for (const target of [...removed]) {
+        const doomed = findNodeByElementId(asObjects(schema), target);
+        if (doomed)
+            collectElementIds(doomed.children, removed);
+    }
+    const readded = new Set();
+    for (const op of opList.filter(op => op.op === 'add_component'))
+        collectElementIds(op.component, readded);
+    const warnings = [];
+    const affected = [];
+    const seen = new Set();
+    for (const flow of asObjects(flows)) {
+        const flowName = String(flow.name ?? flow.slug ?? flow.id ?? 'adsız akış');
+        for (const step of [...asObjects(flow.steps), ...asObjects(flow.errorSteps)].filter(step => step.type === 'setter')) {
+            const args = (step.args ?? {});
+            for (const iteratee of asObjects(args.iteratees)) {
+                const element = typeof iteratee.element === 'string' ? iteratee.element : '';
+                if (!removed.has(element))
+                    continue;
+                const key = `${flow.id ?? flowName}|${step.name ?? step.stepId}|${element}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const stepName = String(step.name ?? step.stepId ?? 'adsız adım');
+                warnings.push(readded.has(element)
+                    ? `FLOW-018 (uyarı): '${element}' bu yamada silinip yeniden kuruldu ama '${flowName}' akışının '${stepName}' setter adımı hâlâ ona yazıyor. Platform komponent kimliğini yeniden üretir: akış koşar, istek 200 döner ve komponente HİÇBİR ŞEY yazılmaz — tek belirti boş komponenttir. flow_update ile akışı aynı gövdeyle yeniden kaydedin.`
+                    : `FLOW-018 (uyarı): '${element}' siliniyor ama '${flowName}' akışının '${stepName}' setter adımının hedefi o — adımın hedefi artık yok, akış sessizce hiçbir şeye yazmaz. Adımı kaldırın ya da flow_update ile başka bir komponente bağlayın.`);
+                affected.push(`${flowName} · ${stepName} → ${element}`);
+            }
+        }
+    }
+    // Özet satırı BAŞA gelir: yama işlenmeden önce kaç iteratee'nin ve hangi akışların etkileneceği
+    // tek bakışta görünsün (2026-09-06 · S-5, P0-2 Step 7). Tek tek satırlar altında kalır.
+    if (affected.length > 0) {
+        const flowNames = [...new Set(affected.map(entry => entry.split(' · ')[0]))];
+        warnings.unshift(`FLOW-018 (özet): bu yama ${affected.length} setter iteratee'sini hedefsiz bırakıyor — ${flowNames.length} akış etkileniyor (${flowNames.join(' · ')}). Etkilenenler: ${affected.join(' | ')}. Silmeden önce flow_get ile akışları yedekleyin.`);
+    }
+    return warnings;
+}
+/**
+ * FLOW-017'nin kör noktası: o kural yalnız BOŞ `element`/`property` görür. 2026-09-09 koşusunda
+ * (S-14) setter dolu ama HENÜZ VAR OLMAYAN bir elementId'ye bağlandı — platform alanı doğrulamaz,
+ * 200 döner ve `element`i null kaydeder; adım koşar, hata vermez, hiçbir şeye yazmaz. Tek belirti
+ * boş komponent. Yakalayan şey yazma SONRASI `silentlyDropped` diff'iydi; bu işlev aynı şeyi
+ * yazmadan önce söyler. Barındırıcı kaydını okumak gerektiği için `policyRules` içine giremez
+ * (check senkron ve yalnız gövdeyi görür) — yeri FLOW-003/FLOW-013 ile aynı, `tools/flows.ts`.
+ */
+export function unknownSetterTargetWarnings(steps, errorSteps, hostNodes) {
+    const known = new Set();
+    collectElementIds(hostNodes, known);
+    // Küme boşsa barındırıcı okunamamış ya da şema henüz kurulmamıştır: yanlış pozitif üretmektense
+    // sessiz kalırız — uyarının değeri "şemada VAR olanı da söylüyor" olmasından geliyor.
+    if (known.size === 0)
+        return [];
+    const warnings = [];
+    const seen = new Set();
+    for (const step of [...asObjects(steps), ...asObjects(errorSteps)].filter(step => step.type === 'setter')) {
+        const args = (step.args ?? {});
+        for (const iteratee of asObjects(args.iteratees)) {
+            const element = typeof iteratee.element === 'string' ? iteratee.element.trim() : '';
+            if (element.length === 0 || known.has(element))
+                continue;
+            const stepName = String(step.name ?? step.stepId ?? 'adsız adım');
+            const key = `${stepName}|${element}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            warnings.push(`FLOW-024 (uyarı): '${stepName}' setter adımının hedefi '${element}' barındırıcının şemasında YOK. Platform bu alanı doğrulamaz: istek 200 döner, element null kaydedilir ve adım koşunca HİÇBİR ŞEY yazmaz — tek belirti boş komponenttir (FLOW-017 yalnız BOŞ element'i görür, dolu ama var olmayan id'yi değil). Şemadaki elementId'ler: ${[...known].join(', ')}. Düğümü henüz kurmadıysanız sıra şudur: page_schema_patch add_component ile düğümü kurun, sonra akışı flow_update ile AYNI gövdeyle yeniden kaydedin — kaydedilen element null olduğu için flow_patch'in [element=…] seçicisi onu bulamaz.`);
+        }
+    }
+    return warnings;
+}
+function collectElementIds(node, into) {
+    if (Array.isArray(node)) {
+        for (const entry of node)
+            collectElementIds(entry, into);
+        return;
+    }
+    if (!node || typeof node !== 'object')
+        return;
+    const record = node;
+    if (typeof record.elementId === 'string')
+        into.add(record.elementId);
+    collectElementIds(record.children, into);
+}
 function collectFlowRefs(node) {
     const found = new Set();
     const visitProps = (value) => {