@appaflytech/zeyrek-ai-mcp 0.0.7 → 0.0.8

package/dist/knowledge/normalize.js

@@ -1,6 +1,7 @@
 import { logStep } from '../observability/trace.js';
 import { PlatformApiError } from '../platform/errors.js';
 import { ensureWorkflowErrorPath } from './errorPath.js';
+import { TYPED_STYLE_COMPONENTS } from './styleResolve.js';
 const SORT_DEFAULT = { name: 'sortField', type: 'sortType', source: 'query-string' };
 const LIMIT_DEFAULT = { name: 'limit', offset: 'offset', source: 'query-string' };
 function asArray(value) {
@@ -325,7 +326,7 @@ const REQUIRED_COLLECTIONS = ['events', 'validations', 'stateBindings', 'childre
 // 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']);
+export 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));
 }
@@ -489,6 +490,77 @@ export function schemaOpValidationErrors(ops) {
     }
     return errors;
 }
+/**
+ * G-02 (2026-09-15) — prop düzeyindeki `code` bir ŞABLONDUR: runtime yalnız `{{ }}` içini çalıştırır
+ * (ng-apps-flow `runPropertyCode`), parantezsiz ref OLDUĞU GİBİ metin döner. Akış tarafında aynı
+ * sarmal (setter iteratee, microservice parametresi) ifadeyi parantezsiz koşturduğu için ajan bu
+ * alışkanlığı prop'a taşıyor: yanıt temiz, ekran "çalışıyor", değer ise ifadenin kendi metni.
+ * eventcalendar'da `"new Date().getFullYear() + …"` tarihe çözülmeye çalışıldı ve V8 onu 2001-01-01
+ * okudu. Niyet türetilemez (düz metin mi, ifade mi?) → normalizasyon değil, PAGE-032 block'u.
+ */
+function bracketlessCodeRef(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.type !== 'code' || typeof record.ref !== 'string')
+        return undefined;
+    const ref = record.ref.trim();
+    return ref !== '' && !ref.includes('{{') ? ref : undefined;
+}
+function codeTemplateMessage(label, ref) {
+    return `${label}: code prop'unun ifadesi '{{ }}' içinde değil ('${ref.length > 80 ? `${ref.slice(0, 80)}…` : ref}'). Prop düzeyinde code bir ŞABLONDUR — runtime yalnız '{{ }}' içini çalıştırır, parantezsiz ref olduğu gibi METİN olarak prop'a düşer ve hiçbir hata üretmez. İfadeyse '{{ <ifade> }}' yazın; düz metin kastediyorsanız type: 'static' kullanın. (Akış adımlarındaki value.type='code' parantezsiz koşar — iki sözdizimi farklıdır, platform_guide('expressions').)`;
+}
+function collectBracketlessCodeProps(value, label, errors) {
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => collectBracketlessCodeProps(entry, `${label}[${index}]`, errors));
+        return;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    const ref = bracketlessCodeRef(value);
+    if (ref !== undefined) {
+        errors.push(codeTemplateMessage(label, ref));
+        return;
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        collectBracketlessCodeProps(entry, `${label}.${key}`, errors);
+    }
+}
+/**
+ * set_binding ifadeyi `expression` alanında taşır ve platform onu code Prop'un ref'ine yazar
+ * (PageSchemaMicroOpApplier; screen-builder patch.ts aynısı); replace_prop ifadeyi `value`'daki
+ * code sarmalının ref'inde taşır — aynı şablon kuralı. normalizeSchemaOps'tan SONRA çağrılır:
+ * replace_prop'un `expression`'ı ve ref'siz code sarmalı o noktada ref'e taşınmış olur.
+ */
+export function codePropTemplateErrors(ops) {
+    const errors = [];
+    const walkNodes = (nodes) => {
+        for (const node of asObjects(nodes)) {
+            const label = String(node.elementId ?? node.name ?? node.type ?? '?');
+            if (node.props && typeof node.props === 'object' && !Array.isArray(node.props)) {
+                for (const [name, prop] of Object.entries(node.props)) {
+                    collectBracketlessCodeProps(prop, `${label}.${name}`, errors);
+                }
+            }
+            walkNodes(node.children);
+        }
+    };
+    for (const op of asObjects(ops)) {
+        const label = `'${String(op.target ?? '?')}.${String(op.prop ?? '?')}'`;
+        if ((op.op === 'set_binding' || op.op === 'replace_prop') && typeof op.expression === 'string') {
+            const ref = bracketlessCodeRef({ type: 'code', ref: op.expression });
+            if (ref !== undefined)
+                errors.push(codeTemplateMessage(label, ref));
+        }
+        if (op.op === 'replace_prop') {
+            collectBracketlessCodeProps(op.value, label, errors);
+            continue;
+        }
+        if (op.op === 'add_component' && op.component)
+            walkNodes([op.component]);
+    }
+    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
@@ -549,6 +621,28 @@ export function normalizeComponentDefaults(nodes) {
             node[key] = [];
             missing.push(key);
         }
+        // S-16 — görünürlük tek yerden okunur: RenderComponent `{#if !props.isHidden}`. Appearance'ta
+        // isHidden alanı YOKTUR (backend 2026-09-15'te kaldırdı); gövdede kalırsa platform onu
+        // sessizce düşürür ve komponent sayfa açılır açılmaz görünür. Değer props.isHidden'a taşınır;
+        // prop zaten verilmişse o kazanır. false yalnız silinir — varsayılan zaten görünür.
+        const appearance = node.appearance;
+        if (appearance && typeof appearance === 'object' && !Array.isArray(appearance) && Object.hasOwn(appearance, 'isHidden')) {
+            const appearanceRecord = appearance;
+            const hidden = appearanceRecord.isHidden;
+            delete appearanceRecord.isHidden;
+            if (hidden !== false && hidden !== null && hidden !== undefined) {
+                if (!node.props || typeof node.props !== 'object' || Array.isArray(node.props))
+                    node.props = {};
+                const props = node.props;
+                if (Object.hasOwn(props, 'isHidden')) {
+                    missing.push("appearance.isHidden silindi — props.isHidden zaten verilmiş, o geçerli (appearance'ta isHidden alanı yok)");
+                }
+                else {
+                    props.isHidden = isPropShaped(hidden) ? hidden : { type: 'static', ref: null, data: hidden };
+                    missing.push("appearance.isHidden → props.isHidden taşındı (runtime görünürlüğü yalnız props.isHidden'dan okur; appearance'ta isHidden alanı yok)");
+                }
+            }
+        }
         if (node.props && typeof node.props === 'object' && !Array.isArray(node.props)) {
             const props = node.props;
             const styleKeys = [];
@@ -575,14 +669,26 @@ export function normalizeComponentDefaults(nodes) {
  * add_component micro-op'unun taşıdığı komponent ağacı da aynı ToDomain yolundan geçer.
  */
 /**
- * `replace_prop` micro-op'u Prop DEĞİL ham değer alır: PageSchemaMicroOpApplier.cs:77
- * `new Prop(PropValueType.Static) { Data = op.Value }` kurar (ifade verilmişse Code). Prop sarmalı
- * gönderildiğinde sarmalın kendisi `Data`'ya yazılır ve platform onu `Dictionary<string, Prop>`
- * olarak çözmeye çalışıp **500 JsonException** verir ("could not be converted to Prop. Path: $.type").
- * add_component'te sarmal ZORUNLU olduğu için bu tuzağa düşmek çok kolay; şekil tamamen
- * türetilebilir olduğundan lint değil normalizasyon: static sarmalını açıyor, code sarmalını
- * op'un `expression` alanına taşıyoruz. Diğer prop tipleri (page/file/flow/widget/element) bu
- * op'la ifade EDİLEMEZ — onlar için PAGE-006 uyarısı üretilir.
+ * `replace_prop` micro-op'u ham değer alır: PageSchemaMicroOpApplier `ApplyOne` sarmalsız değerden
+ * `new Prop(PropValueType.Static) { Data = op.Value }` kurar. Prop sarmalı gönderildiğinde sarmalın
+ * kendisi `Data`'ya yazılır ve platform onu `Dictionary<string, Prop>` olarak çözmeye çalışıp
+ * **500 JsonException** verir ("could not be converted to Prop. Path: $.type"). add_component'te
+ * sarmal ZORUNLU olduğu için bu tuzağa düşmek çok kolay; şekil tamamen türetilebilir olduğundan
+ * lint değil normalizasyon: static sarmalını açıyoruz.
+ *
+ * `code` sarmalı ise OLDUĞU GİBİ gider (2026-09-15): applier 2026-09-04'ten beri `value` bir
+ * `{type, ref, data}` sözlüğüyse tipini korur (StObjectConverter JSON nesnesini
+ * `Dictionary<string, object>`'e çözer — `PageSchemaMicroOpApplierTests` request gövdesiyle ölçer).
+ * `replace_prop` `expression` alanını HİÇ OKUMAZ — yalnız set_binding okur; eskiden sarmalı
+ * `expression`'a taşıyorduk ve prop 200 dönerken `{type:'static', data:null}` kaydediliyordu.
+ * İfade `ref`'tedir (PG-117); ref yoksa string `data`'dan alınır, ikisi de yoksa çağrı durur.
+ * Platform code prop'unda yalnız `Ref`'i saklar (`Prop` kurucusu), `data` kalıcı değildir; ama
+ * `CreateProp` veri tipini `Data`'dan seçtiği için nesne/dizi `data` 500 verir — ref ile değiştirilir.
+ * Aynı sebeple `value`'suz `expression` code sarmalına çevrilir, `value`'nun yanındaki `expression`
+ * silinir. `translation` sarmalı da aynı gerekçeyle olduğu gibi gider (G-04): applier
+ * `Translation` Prop'u `Ref` + metin `Data` ile kurar; eskiden gateway onu reddedip remove+add
+ * öneriyordu ve o yol düğüme yazan setter iteratee'lerinin `element`'ini sildi. Diğer prop tipleri
+ * (page/file/flow/widget/element) bu op'la kurulmaz (Y-22).
  *
  * DIŞ sarmalın olmaması İÇ sarmalın da olmaması demek değil: applier'ın kurduğu Prop yine
  * `ToDomain` → `CreateProp` yolundan geçer ve `Data`'nın içi HER SEVİYEDE
@@ -592,31 +698,64 @@ export function normalizeComponentDefaults(nodes) {
  * Studio'nun `mapRawPropToSchemaProp` çıktısının aynısı: dış sarmal YOK, her yaprak sarılı.
  */
 function normalizeReplacePropValue(op) {
-    const value = op.value;
     const label = `'${String(op.target ?? '?')}.${String(op.prop ?? '?')}'`;
+    if (op.value === undefined && typeof op.expression === 'string') {
+        op.value = { type: 'code', ref: op.expression, data: op.expression };
+        delete op.expression;
+        return [`${label}: replace_prop 'expression' alanı code sarmalına (value: { type: 'code', ref, data }) çevrildi — platform replace_prop'ta expression'ı okumaz, prop static null kaydedilirdi (ifade için set_binding de kullanılabilir)`];
+    }
+    const notes = [];
+    if (Object.hasOwn(op, 'expression')) {
+        delete op.expression;
+        notes.push(`${label}: replace_prop 'expression' alanı silindi — platform onu replace_prop'ta okumaz, geçerli olan value`);
+    }
+    const value = op.value;
     if (!isPropShaped(value)) {
-        if (!deepWrapPropData(value))
-            return [];
-        return [`${label}: value'nun iç değerleri Prop'a sarıldı — op ham değer alır ama platform Data'nın içini her seviyede Dictionary<string, Prop> olarak çözer, sarımsız iç değer 500 JsonException verir`];
+        if (deepWrapPropData(value))
+            notes.push(`${label}: value'nun iç değerleri Prop'a sarıldı — op ham değer alır ama platform Data'nın içini her seviyede Dictionary<string, Prop> olarak çözer, sarımsız iç değer 500 JsonException verir`);
+        return notes;
     }
     const propType = String(value.type);
     if (propType === 'static') {
         const data = value.data;
         op.value = data;
-        const notes = [`${label}: replace_prop value'su Prop sarmalından çıkarıldı — bu op ham değer alır, sarmal gönderilirse platform 500 JsonException verir`];
+        notes.push(`${label}: replace_prop value'su Prop sarmalından çıkarıldı — bu op ham değer alır, sarmal gönderilirse platform 500 JsonException verir`);
         if (deepWrapPropData(data))
             notes.push(`${label}: value'nun iç değerleri Prop'a sarıldı`);
         return notes;
     }
     if (propType === 'code') {
-        const expression = value.data ?? value.ref;
-        delete op.value;
-        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`];
+        const code = value;
+        if (typeof code.ref !== 'string') {
+            if (typeof code.data !== 'string') {
+                throw new PlatformApiError(`${label}: code sarmalında ifade yok — runtime ifadeyi ref'ten okur, ref'siz code prop'u 200 dönüp BOŞ kaydedilir. value: { type: 'code', ref: '{{ <ifade> }}' } yazın; sabit değer kastediyorsanız type: 'static' kullanın.`, 400);
+            }
+            code.ref = code.data;
+            notes.push(`${label}: code sarmalında ref yoktu, data'daki ifade ref'e kopyalandı — runtime ifadeyi ref'ten okur`);
+        }
+        if (code.data !== null && typeof code.data === 'object') {
+            notes.push(`${label}: code sarmalının nesne/dizi data'sı ref ile değiştirildi — platform code prop'unda data'yı saklamaz, nesne data'yı Dictionary<string, Prop> diye çözüp 500 verir`);
+            code.data = code.ref;
+        }
+        if (code.data === undefined)
+            code.data = code.ref;
+        return notes;
     }
-    // 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);
+    if (propType === 'translation') {
+        const translation = value;
+        if (typeof translation.ref !== 'string' || translation.ref.trim().length === 0) {
+            throw new PlatformApiError(`${label}: translation sarmalında çeviri anahtarı yok — anahtar ref'te taşınır, data yalnız tasarım yedeğidir. value: { type: 'translation', ref: '<anahtar>' } yazın; anahtarlar için translation_list.`, 400);
+        }
+        if (translation.data !== undefined && translation.data !== null && typeof translation.data === 'object') {
+            notes.push(`${label}: translation sarmalının nesne/dizi data'sı silindi — platform translation prop'unda data'yı metin olarak saklar, nesne tip adına dönüşürdü`);
+            translation.data = null;
+        }
+        return notes;
+    }
+    // Applier her sarmalın tipini korur, ama page/file/flow/widget/element taşıyıcıları başka alanlara
+    // (FlowId, RedirectPageId, dosya) yazılır ve bu op'la bağları kurulmaz. Remove+add önerilmez:
+    // düğümü yeniden kurmak ona yazan setter iteratee'lerinin element'ini siler (G-04, FLOW-018).
+    throw new PlatformApiError(`${label}: '${propType}' tipli Prop replace_prop ile kurulmaz — bu op static, code ve translation sarmalını taşır. Komponenti silip yeniden EKLEMEYİN: ona yazan setter adımlarının hedefi silinir (FLOW-018). Akış bağı için set_event, diğer tipler için page_update(schema) ile tam şema yazın.`, 400);
 }
 export function normalizeSchemaOps(ops) {
     const components = [];
@@ -634,6 +773,13 @@ export function normalizeSchemaOps(ops) {
             normalizeValidationList(op.validations, `'${String(op.target ?? '?')}'`, validations);
             continue;
         }
+        if (op.op === 'set_appearance') {
+            const appearance = op.appearance;
+            if (appearance && typeof appearance === 'object' && Object.hasOwn(appearance, 'isHidden')) {
+                throw new PlatformApiError(`'${String(op.target ?? '?')}': set_appearance isHidden yazamaz — appearance'ta isHidden alanı YOKTUR, runtime görünürlüğü yalnız props.isHidden'dan okur (S-16). Gizlemek için replace_prop { target, prop: 'isHidden', value: true }, koşullu göstermek için set_binding { target, prop: 'isHidden', expression } kullanın.`, 400);
+            }
+            continue;
+        }
         if (op.op !== 'add_component' || !op.component)
             continue;
         components.push(...normalizeComponentDefaults([op.component]));
@@ -682,7 +828,7 @@ export function pageContainerNode() {
         },
         blocks: [{ breakpoint: 1024, size: { h: 24, w: 12 }, position: { x: 0, y: 0 } }],
         states: { isSticky: false, isDroppable: true, isScrollable: true, isWrapper: true },
-        appearance: { heightType: 'auto', isHidden: false, marginValue: 0, marginType: 'none', paddingType: 'none', paddingValue: 0 },
+        appearance: { heightType: 'auto', marginValue: 0, marginType: 'none', paddingType: 'none', paddingValue: 0 },
         events: [],
         validations: [],
         stateBindings: [],
@@ -912,6 +1058,71 @@ export function flexSizeWarnings(nodes, mismatchCode, invalidCode) {
     walk(asObjects(nodes));
     return warnings;
 }
+/**
+ * İç boşluğun HİÇ çizilmediği tipler — `zeyrek-frontend` `packages/ng-apps-screen-builder/src/constants.ts`
+ * `NO_PADDING_TYPES` (kaplama çerçeveleri) + `spacing.ts` `SHELL_ROOT_TYPES` (kabuk kökleri).
+ */
+const PADDING_NEVER_DRAWN_TYPES = new Set(['auth-layout', 'modal', 'drawer', 'layout', 'layout-shell']);
+/**
+ * Düğümün `appearance.padding*` değeri runtime'da çiziliyor mu. Kural üç yüzeyde aynıdır
+ * (`render.functions.ts` `resolveZonePadding`, `spacing.ts` `leafPaddingCss`/`getSpacingLayers`):
+ * droppable kap dolguyu çocuk sarmalayıcısına, tipli stil modeline göçmüş yaprak kendi iç
+ * kutusuna alır; geri kalan her düğümde (slot dahil) dolgu HİÇBİR kutuya yazılmaz ve Studio
+ * paneli alanı göstermez.
+ */
+function drawsPadding(node) {
+    const type = String(node.type ?? '');
+    const states = (node.states && typeof node.states === 'object' ? node.states : {});
+    if (PADDING_NEVER_DRAWN_TYPES.has(type) || states.isShell === true)
+        return false;
+    return states.isDroppable === true || Object.hasOwn(TYPED_STYLE_COMPONENTS, type);
+}
+function spacingSides(appearance, layer) {
+    const values = appearance[`${layer}Values`];
+    const sides = values && typeof values === 'object' && !Array.isArray(values)
+        ? ['top', 'right', 'bottom', 'left'].map(side => values[side])
+        : [];
+    return [appearance[`${layer}Value`], ...sides].filter(value => value !== undefined && value !== null);
+}
+/**
+ * S-9 (2026-09-15): layout slot'una `paddingType:'custom'` + `paddingValue:"24px"` yazıldı, istek
+ * 200 döndü, slot 0px dolguyla çizildi ve sekiz sayfanın her birine sarmalayıcı kap eklendi. İki
+ * hata üst üste: slot dolgu çizmez (`drawsPadding`), değer de sayı değil string — boşluk kanalı
+ * sayı saklar, çizim `${value}px` birleştirir ve "24px" → `24pxpx` geçersiz CSS olur.
+ *
+ * - `unusedCode`: çizilmeyen düğümde sıfırdan büyük custom dolgu. Slot'un sayfa içeriğinden
+ *   uzaklığı `marginType`/`marginValue`'dur (Studio iskeleti de 8px custom margin yazar).
+ * - `numberCode`: `padding*`/`margin*` değeri sayı değil.
+ *
+ * Yalnız `custom` dolguya bakılır: `normal`/`none` kayıtlı düğümlerde varsayılan olarak durur ve
+ * panelin gizlediği alanda ajanın bilinçli bir kararı değildir.
+ */
+export function spacingLayerWarnings(nodes, unusedCode, numberCode) {
+    const warnings = [];
+    const walk = (list) => {
+        for (const node of list) {
+            const appearance = appearanceOf(node);
+            const label = String(node.elementId ?? node.name ?? node.type ?? '?');
+            for (const layer of ['padding', 'margin']) {
+                const invalid = spacingSides(appearance, layer).filter(value => typeof value !== 'number');
+                if (invalid.length > 0) {
+                    warnings.push(`${numberCode}: '${label}' düğümünde ${layer}Value/${layer}Values sayı değil (${invalid.map(value => JSON.stringify(value)).join(', ')}) — boşluk kanalı piksel SAYISI saklar ("24px" değil 24); çizim değere 'px' ekler ve string değer geçersiz CSS üretir.`);
+                }
+            }
+            const hasCustomPadding = appearance.paddingType === 'custom'
+                && spacingSides(appearance, 'padding').some(value => value !== 0 && value !== '0');
+            if (hasCustomPadding && !drawsPadding(node)) {
+                const hint = node.type === 'slot'
+                    ? "Slot'un sayfa içeriğinden uzaklığı dış boşluğudur: appearance.marginType:'custom' + marginValue (sayı) yaz — slot'un zemini/çerçevesi olmadığı için görsel sonuç iç boşlukla aynıdır."
+                    : "İç boşluk yalnız droppable kaplarda ve tipli stil modelindeki yapraklarda (box · text · container · statcard · icon · form) çizilir; kenardan uzaklık için marginType/marginValue, iç boşluk için sarmalayıcı container kullan.";
+                warnings.push(`${unusedCode}: '${label}' (${String(node.type ?? '?')}) düğümüne custom iç boşluk yazıldı ama bu düğümde iç boşluk HİÇBİR kutuya çizilmez — platform 200 döner, ekran değişmez. ${hint}`);
+            }
+            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 };
@@ -1243,6 +1454,171 @@ export function verticalGapWarnings(nodes, code, onlyParents) {
     gapWalk('kök', asObjects(nodes), code, onlyParents, true, warnings, false);
     return warnings;
 }
+const FLOW_LAYOUTS = new Set(['flex', 'cssgrid']);
+function childrenOf(node) {
+    if (!Array.isArray(node.children))
+        node.children = [];
+    return node.children;
+}
+function locateSlot(nodes, elementId, parent) {
+    for (let index = 0; index < nodes.length; index++) {
+        const node = nodes[index];
+        if (!node || typeof node !== 'object')
+            continue;
+        if (node.elementId === elementId)
+            return { siblings: nodes, parent, index };
+        const found = locateSlot(Array.isArray(node.children) ? node.children : [], elementId, node);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+function collectDesktopPositions(nodes, into) {
+    for (const node of nodes) {
+        const block = desktopBlock(node);
+        if (typeof node.elementId === 'string' && block)
+            into.set(node.elementId, rectOf(block));
+        collectDesktopPositions(asObjects(node.children), into);
+    }
+}
+/**
+ * G-10 (2026-09-15): `add_component`/`move_component`'in `index`'i dizi sırasını değiştirir ama
+ * ÇİZİMİ değiştirmez — runtime flex (ve eski `cssgrid`) kabın çocuklarını dizi sırasıyla değil
+ * `blocks.position` sırasıyla (önce y, sonra x) çizer (`zeyrek-frontend` `RenderComponent.svelte` →
+ * `sortNodesByBlockPosition`). Studio flex tuvalinde sıralarken bunu kardeşlerin desktop bloklarını
+ * yeniden yazarak çözer (`flex-designer.functions.ts` `resolveFlexOrder` + `buildFlexOrderedNodes`:
+ * görünen sıraya yerleştir, x=0, birikimli y). Burada aynısı yapılır: akış kabında `index` GÖRÜNEN
+ * sıradaki yerdir (eski kayıtlarda dizi sırası çizimle aynı değildir, Studio sürüklerken diziyi
+ * değil y'yi yazar). Op'lar okunan şemanın kopyasına sırayla uygulanır; eklenen düğümün son konumu
+ * kendi gövdesine, var olan kardeşlerinki yamanın sonuna `move_component {target, position}` olarak
+ * yazılır. Platform position'ı düğümün İLK bloğuna yazar: ilk bloğu desktop olmayan kardeş atlanır ve
+ * uyarılır. Izgara kapta çizim mutlak koordinattır; sona eklemeyen `index` orada PAGE-033 uyarısıdır.
+ * `index` verilmemiş op'a dokunulmaz.
+ */
+export function flexIndexOrder(schema, ops) {
+    const sent = asObjects(ops).map(op => JSON.parse(JSON.stringify(op)));
+    const tree = JSON.parse(JSON.stringify(asObjects(schema)));
+    const original = new Map();
+    const reordered = new Set();
+    const warnings = [];
+    collectDesktopPositions(tree, original);
+    for (const op of sent) {
+        if (op.op === 'replace_prop' && op.prop === 'layout') {
+            const target = findNodeByElementId(tree, String(op.target ?? ''));
+            const value = op.value !== null && typeof op.value === 'object' ? op.value : { type: 'static', data: op.value };
+            if (target)
+                target.props = { ...(target.props ?? {}), layout: value };
+        }
+        if (op.op === 'remove_component') {
+            const slot = locateSlot(tree, String(op.target ?? ''), undefined);
+            if (slot)
+                slot.siblings.splice(slot.index, 1);
+        }
+        if (op.op !== 'add_component' && op.op !== 'move_component')
+            continue;
+        let node;
+        let siblings = tree;
+        let parent;
+        if (op.op === 'add_component') {
+            node = op.component !== null && typeof op.component === 'object' ? JSON.parse(JSON.stringify(op.component)) : undefined;
+        }
+        else {
+            const slot = locateSlot(tree, String(op.target ?? ''), undefined);
+            if (slot) {
+                node = slot.siblings.splice(slot.index, 1)[0];
+                siblings = slot.siblings;
+                parent = slot.parent;
+            }
+            const block = node ? desktopBlock(node) : undefined;
+            const position = op.position;
+            if (block && position && typeof position === 'object')
+                block.position = { x: Number(position.x ?? 0), y: Number(position.y ?? 0) };
+        }
+        if (!node)
+            continue;
+        const requestedParent = op.parent;
+        if (op.op === 'add_component' || (requestedParent !== undefined && requestedParent !== null)) {
+            parent = typeof requestedParent === 'string' && requestedParent !== '' && requestedParent !== 'root'
+                ? findNodeByElementId(tree, requestedParent)
+                : undefined;
+            if (typeof requestedParent === 'string' && requestedParent !== '' && requestedParent !== 'root' && !parent)
+                continue;
+            siblings = parent ? childrenOf(parent) : tree;
+        }
+        const hasIndex = typeof op.index === 'number' && Number.isFinite(op.index);
+        const insertAt = hasIndex ? Math.max(0, Math.min(op.index, siblings.length)) : siblings.length;
+        siblings.splice(insertAt, 0, node);
+        if (!hasIndex)
+            continue;
+        const elementId = String(node.elementId ?? '?');
+        const parentLabel = String(parent?.elementId ?? 'kök');
+        if (!parent || !FLOW_LAYOUTS.has(String(staticPropValue(parent, 'layout')))) {
+            if (insertAt < siblings.length - 1) {
+                warnings.push(`PAGE-033 (uyarı): '${parentLabel}' ızgara kap — '${elementId}' için verilen index:${op.index} yalnız DİZİ sırasını değiştirir, ÇİZİMİ değil: ızgarada her çocuk kendi blocks.position'ında çizilir. Sırayı değiştirmek için position.y ver (move_component {target, position: {x, y}}) ya da kabı layout:'flex' yap — flex kapta index görünen sırayı belirler ve gateway kardeş konumlarını yeniden yazar.`);
+            }
+            continue;
+        }
+        const others = siblings
+            .filter(child => child !== node && desktopBlock(child) !== undefined)
+            .sort((left, right) => rectOf(desktopBlock(left)).y - rectOf(desktopBlock(right)).y || rectOf(desktopBlock(left)).x - rectOf(desktopBlock(right)).x);
+        const orderAt = Math.max(0, Math.min(op.index, others.length));
+        let y = 0;
+        for (const child of [...others.slice(0, orderAt), node, ...others.slice(orderAt)]) {
+            const block = desktopBlock(child);
+            if (!block)
+                continue;
+            const rect = rectOf(block);
+            if (rect.x !== 0 || rect.y !== y) {
+                block.position = { x: 0, y };
+                reordered.add(String(child.elementId ?? '?'));
+            }
+            y += Math.max(1, rect.h);
+        }
+        if (op.op === 'move_component')
+            reordered.add(elementId);
+    }
+    const addedBodies = new Map();
+    const moveTargets = new Set(sent.filter(op => op.op === 'move_component').map(op => String(op.target ?? '')));
+    const trailing = [];
+    const moved = [];
+    for (const op of sent) {
+        const component = op.component;
+        if (op.op === 'add_component' && component && typeof component.elementId === 'string')
+            addedBodies.set(component.elementId, component);
+    }
+    for (const elementId of reordered) {
+        const node = findNodeByElementId(tree, elementId);
+        const block = node ? desktopBlock(node) : undefined;
+        if (!node || !block)
+            continue;
+        const final = rectOf(block);
+        const body = addedBodies.get(elementId);
+        const bodyBlock = body ? desktopBlock(body) : undefined;
+        if (bodyBlock && !moveTargets.has(elementId)) {
+            const before = rectOf(bodyBlock);
+            if (before.x !== final.x || before.y !== final.y) {
+                bodyBlock.position = { x: final.x, y: final.y };
+                moved.push(`${elementId} y:${before.y}→${final.y}`);
+            }
+            continue;
+        }
+        const before = original.get(elementId);
+        if (!body && !moveTargets.has(elementId) && before && before.x === final.x && before.y === final.y)
+            continue;
+        if (Number(asObjects(node.blocks)[0]?.breakpoint) !== DESKTOP_BREAKPOINT) {
+            warnings.push(`PAGE-033 (uyarı): '${elementId}' flex sırasına göre y:${final.y}'e taşınmalıydı ama ilk bloğu desktop (1024) değil — platform move_component'in position'ını İLK bloğa yazar, yanlış kırılımı bozmamak için konum yazılmadı. Düğümü page_update(schema) ile düzeltin.`);
+            continue;
+        }
+        trailing.push({ op: 'move_component', target: elementId, position: { x: final.x, y: final.y } });
+        moved.push(`${elementId} y:${before?.y ?? '?'}→${final.y}`);
+    }
+    return { ops: [...sent, ...trailing], moved, warnings };
+}
+export function flexIndexOrderNote(moved) {
+    if (moved.length === 0)
+        return [];
+    return [`flex kapta index görünen sıraya çevrildi, kardeş konumları yeniden yazıldı (${moved.join(', ')}): runtime akış kabının çocuklarını dizi sırasıyla değil blocks.position sırasıyla (önce y, sonra x) çizer; Studio flex tuvali de sıralarken konumları böyle yazar (x=0, birikimli y)`];
+}
 /**
  * View gövdesinde alan→tablo bağı **alias** üzerinden kurulur (`ViewSourceMapper.Map`:
  * `tablesByAlias.GetValueOrDefault(input.ViewEntityAlias) ?? tables.FirstOrDefault()`) ama
@@ -1675,7 +2051,7 @@ export function staleSetterWarnings(flows, ops, schema) {
                 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}' bu yamada silinip yeniden kuruluyor ve '${flowName}' akışının '${stepName}' setter adımı ona yazıyor. Setter hedefi elementId değil komponentin iç kimliğidir; platform yeni kimlik üretirse iteratee'nin element'i SİLİNİR — akış koşar, istek 200 döner ve komponente HİÇBİR ŞEY yazılmaz. Gateway yazmadan sonra akışları yeniden okur: bağ koptuysa flowTargetsLost onarım op'larını verir. Prop tipini değiştirmek için düğümü yeniden kurmayın — replace_prop sarmalı (static/code/translation) ya da set_prop_type yeter.`
                     : `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}`);
             }
@@ -1689,6 +2065,66 @@ export function staleSetterWarnings(flows, ops, schema) {
     }
     return warnings;
 }
+/**
+ * FLOW-018'in yazma SONRASI ayağı (G-04). Uyarı yamadan önce "kopabilir" der ama sonucu bilemez:
+ * backend aynı yamada silinip aynı elementId ile eklenen düğüme eski kimliğini geri verir; o düzeltme
+ * deploy edilmemiş bir ortamda ise `step_iterates.DesignComponentId` FK'sı `SetNull` ile boşalır ve
+ * `flow_get` iteratee'yi `element`'siz döndürür (09-15 koşusu: pano açıldı, alt başlık ve tarih
+ * aralığı boş kaldı). Yamadan önce ve sonra okunan akışlar karşılaştırılır; YENİDEN EKLENEN bir
+ * düğüme yazıp `element`'ini kaybeden her iteratee için elle uygulanacak `flow_patch` op'u üretilir.
+ * Yalnız silinen düğümün kaybı burada sayılmaz: hedef gerçekten yoktur, onu FLOW-018 zaten söyler.
+ */
+export function lostSetterTargets(before, after, ops) {
+    const readded = new Set();
+    for (const op of asObjects(ops).filter(op => op.op === 'add_component'))
+        collectElementIds(op.component, readded);
+    const afterById = new Map(asObjects(after).map(flow => [String(flow.id ?? ''), flow]));
+    const lost = [];
+    for (const flow of asObjects(before)) {
+        const saved = afterById.get(String(flow.id ?? ''));
+        if (!saved)
+            continue;
+        const flowName = String(flow.name ?? flow.slug ?? flow.id ?? 'adsız akış');
+        for (const collection of ['steps', 'errorSteps']) {
+            const savedSteps = new Map(asObjects(saved[collection]).map(step => [String(step.stepId ?? ''), step]));
+            for (const step of asObjects(flow[collection]).filter(step => step.type === 'setter')) {
+                const savedStep = savedSteps.get(String(step.stepId ?? ''));
+                if (!savedStep)
+                    continue;
+                const savedIteratees = asObjects((savedStep.args ?? {}).iteratees);
+                asObjects((step.args ?? {}).iteratees).forEach((iteratee, index) => {
+                    const element = typeof iteratee.element === 'string' ? iteratee.element : '';
+                    const savedIteratee = savedIteratees.find(entry => iteratee.id !== undefined && entry.id === iteratee.id) ?? savedIteratees[index];
+                    if (!readded.has(element) || !savedIteratee || (typeof savedIteratee.element === 'string' && savedIteratee.element.length > 0))
+                        return;
+                    const savedIndex = savedIteratees.indexOf(savedIteratee);
+                    lost.push(`FLOW-018 (yazma sonrası): '${flowName}' · '${String(step.name ?? step.stepId)}' iteratee ${savedIndex} hedefini kaybetti ('${element}') — akış koşar ama komponente yazmaz. Onarım: flow_patch operations: [{ op: 'add', path: '/${collection}[stepId=${String(step.stepId)}]/args/iteratees/${savedIndex}/element', value: '${element}' }]`);
+                });
+            }
+        }
+    }
+    return lost;
+}
+/**
+ * FLOW-017 yazarken element'siz setter'ı reddeder; ama hedef SONRADAN silinince platform alanı
+ * boşaltır ve akış geçerli görünerek koşmaya devam eder (G-04). `flow_get` bu durumu okurken söyler —
+ * o gövdeyle `flow_update` zaten FLOW-017'ye takılır, sebebini önceden bilmek gerekir.
+ */
+export function targetlessSetterWarnings(flow) {
+    const record = (flow && typeof flow === 'object' && !Array.isArray(flow) ? flow : {});
+    const body = (record.data && typeof record.data === 'object' && !Array.isArray(record.data) ? record.data : record);
+    const warnings = [];
+    for (const collection of ['steps', 'errorSteps']) {
+        for (const step of asObjects(body[collection]).filter(step => step.type === 'setter')) {
+            asObjects((step.args ?? {}).iteratees).forEach((iteratee, index) => {
+                if (typeof iteratee.element === 'string' && iteratee.element.trim().length > 0)
+                    return;
+                warnings.push(`FLOW-017 (okuma): '${String(step.name ?? step.stepId)}' setter adımının iteratee ${index} hedefsiz — element yok, adım koşar ama HİÇBİR ŞEYE yazmaz. Hedef komponent silinmiş ya da yeniden kurulmuş olabilir (FLOW-018). page_schema_get ile elementId'yi bulup flow_patch ile yazın: { op: 'add', path: '/${collection}[stepId=${String(step.stepId)}]/args/iteratees/${index}/element', value: '<elementId>' }`);
+            });
+        }
+    }
+    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,

package/dist/knowledge/propTypes.js

@@ -2,10 +2,11 @@ import { findNode } from '../tools/screens.js';
 /**
  * Prop değerinin `type` alanı üç değer alır ve her biri taşıyıcısı farklıdır.
  *
- * Platformun kendi micro-op applier'ı `replace_prop`'ta gönderilen ham değeri HER ZAMAN `Static`
- * (ifade verilmişse `Code`) Prop'una sarar (`PageSchemaMicroOpApplier.cs:77`), yani kurulu bir
- * etiketi çeviriye bağlamanın platform tarafında bir yolu yoktur. Bu op o boşluğu kapatır:
- * şemayı okur, prop'un TİPİNİ yerinde değiştirir, gövdeyi tam yazar.
+ * Platformun kendi micro-op applier'ı `replace_prop`'ta gönderilen ham değeri `Static` Prop'una
+ * sarar, `{type:'code'|'translation', ref}` sarmalını tipiyle korur (`PageSchemaMicroOpApplier`
+ * `ApplyOne`); gateway bu sarmalları 2026-09-15'ten beri olduğu gibi geçirir (G-04). Bu op aynı
+ * işi şemayı okuyarak yapar: prop'un TİPİNİ yerinde değiştirir, mevcut `data`'yı tasarım yedeği
+ * olarak taşır ve gövdeyi tam yazar — layout ağacında micro-op hattı olmadığı için orada tek yoldur.
  *
  * Alternatifi `remove_component` + `add_component`'tı ve pahalıydı: 2026-09-06 koşusunda on bir
  * etiket o yolla yeniden kuruldu, o düğümlere yazan DOKUZ setter iteratee'si platform tarafından