@appaflytech/zeyrek-ai-mcp 0.0.6 → 0.0.8

package/dist/knowledge/rules.js

@@ -1,5 +1,8 @@
+import { applyPolicyMode } from './policy.js';
+import { PlatformApiError } from '../platform/errors.js';
 import { reservedTenantTables } from './reservedTables.js';
 import { headersAccessNames, isHeadersAccessGuarded } from './flowGuards.js';
+import { callsItself, functionCallRefs, isValidParameterName, mentionsAwait, nameProblem, sourceOf, callPrefix } from './functionGuards.js';
 import { backendPolicyRules } from './backendConstraints.js';
 const terminalStepTypes = new Set(['response', 'convert', 'revert']);
 const DESCRIPTION_EXEMPT_STEPS = new Set(['start']);
@@ -14,6 +17,7 @@ const stepKindMatrix = {
     workflow: ['workflow', 'automation', 'middleware'],
     email: ['workflow', 'automation', 'middleware'],
     'file-upload': ['workflow', 'automation', 'middleware'],
+    microfunction: ['workflow', 'automation', 'middleware'],
     variable: ['middleware'],
     'set-user': ['middleware'],
     setcookie: ['middleware'],
@@ -97,8 +101,19 @@ const flowBranchNames = {
     start: ['always'],
     microservice: ['always', 'success'],
     confirm: ['yes', 'no', 'always'],
+    function: ['always'],
     end: []
 };
+/**
+ * Gateway'in tanıdığı sayfa akışı adım tipleri — frontend `FlowTaskType` enum'unun aynası
+ * (`ng-apps-flow/src/flow-execution.enums.ts`). `flowBranchNames[type] ?? ['always']` varsayımı
+ * her tipi kabul ettiği için sürüklenme ancak bu AÇIK listeyle ölçülür
+ * (`test/flow-step-parity.test.ts`). Frontend'e yeni tip girince buraya da yazılır.
+ */
+export const knownFlowStepTypes = new Set([
+    'start', 'end', 'query', 'setter', 'download', 'condition', 'redirect', 'setcookie', 'alert', 'confirm',
+    'microservice', 'validation', 'flow-trigger', 'storage', 'navigate', 'code', 'function'
+]);
 const flowFreeBranchTypes = new Set(['condition']);
 /** `condition.types.ts` ConditionArgumentRuleType — motorun tanıdığı üçlü. */
 const conditionRuleTypes = new Set(['if', 'else-if', 'else']);
@@ -110,7 +125,7 @@ const conditionRuleIdPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}
 // Runtime.svelte'de HAM verilir (`argument: step.args`), yani bu alanlarda ifade değerlendirilmez.
 const flowLiteralTextFields = new Map([
     ['alert', ['message', 'description']],
-    ['confirm', ['message']]
+    ['confirm', ['message', 'title', 'confirmText', 'cancelText']]
 ]);
 const flowExpressionLooking = /\$\{|\b(?:Steps|Page|Row|Widget|LocalStorage|state|self|item|event|error|cookie)\s*(?:\?\.|\.|\[)/;
 // Barındırıcıya özel tipler (`navigate` web'de, `confirm`/`download` mobilde register edilmez)
@@ -205,7 +220,22 @@ function flowCodeExpressions(step) {
     }
     return expressions;
 }
-const writeOperations = new Set(['create', 'update', 'delete', 'upsert']);
+/**
+ * Kod ifadesi taşıyan her alan: `flowCodeExpressions` + condition kurallarının `expression`ı.
+ * FLOW-025 (`Functions.<ad>` çağrı taraması) bunu tarar; FLOW-011'in taradığı küme değişmez.
+ */
+export function flowExpressionSites(step) {
+    const shaped = step;
+    const sites = flowCodeExpressions(shaped);
+    if (shaped.type === 'condition') {
+        for (const rule of asArray((shaped.args ?? {}).rules).filter((rule) => Boolean(rule) && typeof rule === 'object')) {
+            if (typeof rule.expression === 'string' && rule.expression.trim() !== '')
+                sites.push({ expression: rule.expression, origin: `rules['${String(rule.id ?? '?')}'].expression` });
+        }
+    }
+    return sites;
+}
+const writeOperations = new Set(['create', 'update', 'delete', 'upsert', 'bulk-create', 'bulk-update', 'bulk-delete']);
 /** Built-in `roles` entity'si ve slug alanı — SeedData her projeye SABİT id'lerle açar (EntityConstants.cs). */
 const rolesEntityId = '01917ede-88a2-72ea-8397-2619e5d5dca0';
 const rolesSlugFieldId = '0199c35d-cfc8-77d4-9c20-29b857153147';
@@ -224,7 +254,7 @@ function writesRolesWithoutSlug(entityId, parameters) {
 }
 const rolesSlugMessage = "Built-in 'roles' entity'sine slug YAZMADAN rol satırı ÜRETİLİYOR (operation create/upsert). Insert 200 döner, satır role_list'te görünür ve page.roleIds ile bağlanır — ama yetkilendirme SLUG karşılaştırır: platformun get-user sorgusu roles+user_roles join'inden slug dizisi üretir ve Authorized(user.roles) o rol için hiçbir zaman tutmaz. fields'a slug'ı ekleyin ('super-admin' slug'ını vermeyin — platform süper yöneticiyi o slug ile arar). Upsert'te slug'ı İFADEYLE üretmeyin: UPDATE yolunda ifade yeniden değerlendirilir ve var olan rolün slug'ı sessizce değişir (MS-016) — üretilen slug'ı yalnız create ucunda yazın. Rolü kullanıcıya bağlamak ayrı bir user_roles satırıdır.";
 const contractKeys = ['returnDtoId', 'parameterDtoId', 'returnBehavior', 'parameterBehavior'];
-const filterOperators = new Set(['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'contains', 'icontains', 'in', 'notin', 'startswith', 'endswith', 'istartswith', 'iendswith']);
+const filterOperators = new Set(['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'contains', 'icontains', 'in', 'notin', 'startswith', 'endswith', 'istartswith', 'iendswith', 'isnull', 'isnotnull']);
 function flattenFilterTree(filters) {
     return filters
         .filter((filter) => Boolean(filter) && typeof filter === 'object')
@@ -316,6 +346,40 @@ function unreadSelectFields(step, steps) {
         .map(field => String(field.fieldSlug ?? field.slug ?? ''))
         .filter(slug => slug.length > 0 && !new RegExp(`\\b${escapeForPattern(slug)}\\b`).test(usage));
 }
+const SQL_COMMENT_PATTERN = /--[^\n]*|\/\*[\s\S]*?\*\//g;
+const QUERY_PARAMETER_TOKEN = String.raw `(?:\{\{\s*([A-Za-z_]\w*)\s*\}\}|(?<![:@\w'])@([A-Za-z_]\w*))(?:\s*::\s*\w+)*`;
+const EMPTY_STRING_COMPARISON_PATTERN = new RegExp(`${QUERY_PARAMETER_TOKEN}\\s*=\\s*(?<!')''(?!')|(?<!')''\\s*=\\s*${QUERY_PARAMETER_TOKEN}`, 'g');
+/**
+ * `rawQuery`'de bir parametreyi boş string'le EŞİTLİK üzerinden karşılaştıran yerlerin parametre
+ * adları (`@p = ''`, `@p::text = ''`, `'' = {{p}}`). Yorumlar önce atılır — platform da yorum
+ * içindeki belirteci parametre saymıyor. Yalnız `=` aranır: `@p <> ''` boş değerde NULL (yanlış)
+ * verir ve "doluysa" niyetiyle yazıldığında sonuç zaten doğrudur.
+ */
+function emptyStringComparisons(rawQuery) {
+    if (typeof rawQuery !== 'string')
+        return [];
+    const names = new Set();
+    for (const match of rawQuery.replace(SQL_COMMENT_PATTERN, ' ').matchAll(EMPTY_STRING_COMPARISON_PATTERN)) {
+        const name = match[1] ?? match[2] ?? match[3] ?? match[4];
+        if (name !== undefined)
+            names.add(name);
+    }
+    return [...names];
+}
+/** `rawQuery`'nin başvurduğu parametre adları (`@p`, `{{p}}`), yorumlar atılarak; ilk görülme sırasıyla. */
+export function rawQueryParameterNames(rawQuery) {
+    if (typeof rawQuery !== 'string')
+        return [];
+    const names = new Set();
+    for (const match of rawQuery.replace(SQL_COMMENT_PATTERN, ' ').matchAll(new RegExp(QUERY_PARAMETER_TOKEN, 'g'))) {
+        const name = match[1] ?? match[2];
+        if (name !== undefined)
+            names.add(name);
+    }
+    return [...names];
+}
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const functionsGuide = 'ngapps://guides/functions';
 export const policyRules = [
     {
         id: 'MS-001',
@@ -386,7 +450,7 @@ export const policyRules = [
         id: 'MS-016',
         module: 'microservice',
         appliesTo: ['create', 'update', 'preview'],
-        sourceRef: "İK koşusu M-3: operation 'upsert' olan uçta expression'la yazılan alan UPDATE yolunda yeniden değerlendiriliyor; Incremental sicil alanı EMP-0005 → EMP-0006 diye sessizce değişti. Platformda alan bazlı writeOn (create|update|always) YOK — bu kural o gelene kadarki tek uyarı",
+        sourceRef: "İK koşusu M-3: operation 'upsert' olan uçta expression'la yazılan alan UPDATE yolunda yeniden değerlendiriliyor; Incremental sicil alanı EMP-0005 → EMP-0006 diye sessizce değişti. Alan bazlı writeOn (create|update|always) 2026-09-04'te eklendi (B-12), bu yüzden kural artık çözümü söyler ve writeOn:'create' taşıyan alanda susar",
         check: definition => {
             const parameters = (definition.sourceParameters ?? {});
             if (String(parameters.operation ?? '') !== 'upsert')
@@ -394,13 +458,14 @@ export const policyRules = [
             const generated = asArray(parameters.fields)
                 .map(entry => entry)
                 .filter(field => String(field.source ?? '') === 'expression')
+                .filter(field => String(field.writeOn ?? 'always').toLowerCase() !== 'create')
                 .map(field => String(field.alias ?? field.fieldId ?? '?'));
             if (generated.length === 0)
                 return [];
             return [{
                     ruleId: 'MS-016',
                     severity: 'warn',
-                    message: `upsert ucunda expression kaynaklı alan var (${generated.join(', ')}): upsert UPDATE yolunda da bu ifadeyi yeniden değerlendirir, yani sicil/kod gibi ÜRETİLEN bir değer güncellemede sessizce değişir. Alanı yalnız oluşturmada yazmak istiyorsanız create ve update için iki ayrı uç kurun — platformda alan bazlı 'yalnız create'te yaz' ifadesi henüz yok.`,
+                    message: `upsert ucunda expression kaynaklı alan var (${generated.join(', ')}): upsert UPDATE yolunda da bu ifadeyi yeniden değerlendirir, yani sicil/kod gibi ÜRETİLEN bir değer güncellemede sessizce değişir. Alan yalnız oluşturmada yazılacaksa fields[] öğesine writeOn: 'create' koyun — upsert'in UPDATE dalı o alanı satıra hiç koymaz ve bu uyarı susar. writeOn yalnız operation:'upsert' ucunda geçerlidir (MS-017) ve bir 'kısmi güncelleme' bayrağı DEĞİLDİR: listelenen alan gövdede gelmezse yine NULL yazılır.`,
                     guide: 'ngapps://guides/microservice'
                 }];
         }
@@ -419,6 +484,23 @@ export const policyRules = [
                     guide: 'ngapps://guides/microservice'
                 }]
     },
+    {
+        id: 'QRY-007',
+        module: 'query',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "2026-09-15 bulgusu: pano sorgusu '(@tech = '' OR w.technician_id::text = @tech)' ile 0 satır döndü, hata yok. Kök neden Query.PrepareQueryParameters / NormalizePreviewParameters: boş ya da yalnız boşluktan oluşan değer NULL bağlanır, bu yüzden '@p = ''' hiçbir değerle doğru olmaz. Bulgunun 'dokunulmamış dropdown null gönderiyor' teşhisi yanlıştı — '' gönderen form da aynı sonucu alır. warn: kalıp hatalı ama yazmayı durdurmak gerekmiyor",
+        check: definition => {
+            const names = emptyStringComparisons(definition.rawQuery);
+            if (names.length === 0)
+                return [];
+            return [{
+                    ruleId: 'QRY-007',
+                    severity: 'warn',
+                    message: `rawQuery parametreyi boş string'le karşılaştırıyor (${names.map(name => `@${name} = ''`).join(', ')}): platform boş ya da yalnız boşluktan oluşan parametre değerini NULL bağlar, NULL = '' hiçbir zaman doğru olmaz ve 'filtre boşsa hepsini getir' dalı ASLA çalışmaz — filtre boş geldiğinde sorgu hatasız 0 satır döner. Değerin form bileşeninden null ya da '' gelmesi fark etmez. Şöyle yazın: (@${names[0]} IS NULL OR kolon::text = @${names[0]}).`,
+                    guide: 'ngapps://guides/microservice'
+                }];
+        }
+    },
     {
         id: 'MS-018',
         module: 'microservice',
@@ -583,6 +665,38 @@ export const policyRules = [
             });
         }
     },
+    {
+        id: 'WF-MF-001',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "MicrofunctionStep.cs: rule.MicrofunctionId ile kayıt yüklenir, Status != Published ise FailedOutput(MicrofunctionNotPublishedException) — adım hata dalına düşer, akış 200 dönse bile iş yapılmaz. Ölçüldü 2026-09-10 (B4 doğrulaması: taslak fonksiyona bağlı uç 500 MicrofunctionNotPublishedException)",
+        check: definition => {
+            const body = workflowBody(definition);
+            return workflowSteps(body)
+                .filter(step => step.type === 'microfunction')
+                .flatMap((step) => {
+                const rule = (step.rule ?? {});
+                const microfunctionId = rule.microfunctionId;
+                if (!hasText(microfunctionId)) {
+                    return [{
+                            ruleId: 'WF-MF-001',
+                            severity: 'block',
+                            message: `'${stepLabel(step)}' microfunction adımında rule.microfunctionId yok — adım hangi fonksiyonu koşturacağını bilmez. microfunction_list(status: 'published') ile id seçin; argümanlar rule.expression'a yazılır (fonksiyonun parameterDto'su varsa o şemaya göre).`,
+                            guide: 'ngapps://guides/microfunction'
+                        }];
+                }
+                if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(String(microfunctionId))) {
+                    return [{
+                            ruleId: 'WF-MF-001',
+                            severity: 'block',
+                            message: `'${stepLabel(step)}' adımının rule.microfunctionId'si GUID değil: '${String(microfunctionId)}'. Platform alanı Guid'e çeviremediği için 400 döner.`,
+                            guide: 'ngapps://guides/microfunction'
+                        }];
+                }
+                return [];
+            });
+        }
+    },
     {
         id: 'WF-006',
         module: 'workflow',
@@ -1704,6 +1818,203 @@ export const policyRules = [
                 }];
         })
     },
+    {
+        id: 'FN-001',
+        module: 'function',
+        appliesTo: ['create', 'update'],
+        sourceRef: "GlobalFunctionRules.cs IsValidName(name, source)/IsValidParameterName → 422 GlobalFunctionNameInvalid; function-source.ts isValidName — geçersiz ad iki dünyada da fonksiyonu ATLATIR. Kaynağa özel ayrılmış ad: studio 'Functions' (K1), workflow WorkflowReservedNames (motor globalleri)",
+        check: definition => {
+            const name = String(definition.name ?? '');
+            const source = sourceOf(definition);
+            const findings = [];
+            const problem = nameProblem(definition.name, source);
+            if (problem !== undefined) {
+                findings.push({
+                    ruleId: 'FN-001',
+                    severity: 'block',
+                    message: source === 'workflow'
+                        ? `Fonksiyon adı '${name}' geçersiz: ${problem}. Ad /^[A-Za-z_$][A-Za-z0-9_$]*$/ kalıbına uymalı, JavaScript ayrılmış sözcüğü ve workflow motorunun global adı (system, input, Now, crypto…) olmamalı — platform 422 GlobalFunctionNameInvalid döner.`
+                        : `Fonksiyon adı '${name}' geçersiz: ${problem}. Ad /^[A-Za-z_$][A-Za-z0-9_$]*$/ kalıbına uymalı, JavaScript ayrılmış sözcüğü ve 'Functions' olmamalı — platform 422 GlobalFunctionNameInvalid döner; kayıt bir yolla geçse bile runtime böyle bir adı atlar ve Functions.${name} tanımsız kalır.`,
+                    guide: functionsGuide
+                });
+            }
+            for (const parameter of asArray(definition.parameters).filter(isRecord)) {
+                if (isValidParameterName(parameter.name))
+                    continue;
+                findings.push({
+                    ruleId: 'FN-001',
+                    severity: 'block',
+                    message: `'${name}' fonksiyonunun parametre adı '${String(parameter.name ?? '')}' geçersiz (${nameProblem(parameter.name) ?? 'geçersiz'}) — platform 422 GlobalFunctionNameInvalid döner; runtime geçersiz parametre adlı fonksiyonu TÜMÜYLE atlar.`,
+                    guide: functionsGuide
+                });
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'FN-002',
+        module: 'function',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'CreateGlobalFunctionCommandValidator: parametre adı tekrarı → 422 GlobalFunctionParameterNameDuplicate; bildirim parametreleri konumsal bağlar, aynı ad ikinci değeri gölgeler',
+        check: definition => {
+            const names = asArray(definition.parameters).filter(isRecord).map(parameter => String(parameter.name ?? ''));
+            const duplicates = [...new Set(names.filter((entry, index) => entry !== '' && names.indexOf(entry) !== index))];
+            return duplicates.length === 0
+                ? []
+                : [{
+                        ruleId: 'FN-002',
+                        severity: 'block',
+                        message: `'${String(definition.name ?? '?')}' fonksiyonunda parametre adı tekrar ediyor: ${duplicates.join(', ')} — platform 422 GlobalFunctionParameterNameDuplicate döner. Çağrı konumsaldır (K5); aynı ad iki konumu birden alamaz.`,
+                        guide: functionsGuide
+                    }];
+        }
+    },
+    {
+        id: 'FN-003',
+        module: 'function',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'K15: fonksiyon başka fonksiyonu çağırabilir, tanım sırası önemsiz — kendini çağıran gövde durma koşulu yoksa sonsuz özyinelemedir; runCode RangeError\'ı yutar, sunucuda Jint LimitRecursion henüz yok (B-16, Faz 9)',
+        check: definition => {
+            const name = String(definition.name ?? '');
+            const source = sourceOf(definition);
+            const body = typeof definition.body === 'string' ? definition.body : '';
+            if (name === '' || !callsItself(name, body, source))
+                return [];
+            return [{
+                    ruleId: 'FN-003',
+                    severity: 'warn',
+                    message: `'${name}' gövdesi ${callPrefix(source)}${name}(…) ile KENDİNİ çağırıyor. Durma koşulu yoksa ${source === 'workflow' ? 'Jint sınırsız özyinelemeye girer (B-16 sertleştirmesi Faz 9\'da)' : "tarayıcıda 'Maximum call stack size exceeded' (runCode yutar, hedef prop yazılmaz)"}. Bilinçli özyinelemeyse yok sayın.`,
+                    guide: functionsGuide
+                }];
+        }
+    },
+    {
+        id: 'FN-004',
+        module: 'function',
+        appliesTo: ['create', 'update'],
+        sourceRef: "K6: isAsync istemci semantiğidir — function-source.ts compiles(): await taşıyan senkron gövde derlenmez ve atlanır; {{ }} inline bağlama Promise'i [object Promise] çizer. source:'workflow' senkron Jint motorunda koşar: GlobalFunction.ValidateState isAsync'i reddeder (422 GlobalFunctionAsyncNotAllowed)",
+        check: definition => {
+            const name = String(definition.name ?? '?');
+            const body = typeof definition.body === 'string' ? definition.body : '';
+            const isAsync = definition.isAsync === true;
+            if (isAsync && sourceOf(definition) === 'workflow') {
+                return [{
+                        ruleId: 'FN-004',
+                        severity: 'block',
+                        message: `'${name}' source:'workflow' ama isAsync=true — workflow motoru senkron çalışır, async bildirimin dönüşü Promise olur ve code adımı '[object Promise]' görür; platform 422 GlobalFunctionAsyncNotAllowed döner. isAsync:false yapın; await gerekiyorsa bu bir studio fonksiyonudur.`,
+                        guide: functionsGuide
+                    }];
+            }
+            if (isAsync && !mentionsAwait(body)) {
+                return [{
+                        ruleId: 'FN-004',
+                        severity: 'warn',
+                        message: `'${name}' isAsync=true ama gövdede await yok — async gereksiz ve bedeli var: {{ }} inline bağlamada dönüş Promise'dir ve ekrana '[object Promise]' yazılır. await gerekmiyorsa isAsync:false yapın.`,
+                        guide: functionsGuide
+                    }];
+            }
+            if (!isAsync && mentionsAwait(body)) {
+                return [{
+                        ruleId: 'FN-004',
+                        severity: 'warn',
+                        message: `'${name}' gövdesi await içeriyor ama isAsync=false — senkron function içinde await SyntaxError'dur: tarayıcı gövdeyi derleyemez ve fonksiyonu ATLAR (function-source.ts compiles), sunucu da derleyemediği gövdeyi atlar; Functions.${name} hiçbir yerde tanımlı olmaz. Ya isAsync:true yapın (o zaman yalnız tarayıcıda, function/code adımından çağrılır) ya da await'i kaldırın.`,
+                        guide: functionsGuide
+                    }];
+            }
+            return [];
+        }
+    },
+    {
+        id: 'FN-005',
+        module: 'function',
+        appliesTo: ['create'],
+        sourceRef: "CreateGlobalFunctionCommandValidator When(source): workflow ⇒ applicationId/pageId/scope null (422 GlobalFunctionSourceWorkflowScopeForbidden); studio ⇒ applicationId ve scope zorunlu, scope=page ⇒ pageId (422 GlobalFunctionScopePageRequired), scope=application ⇒ pageId yok (422 GlobalFunctionScopeApplicationPageForbidden)",
+        check: definition => {
+            const name = String(definition.name ?? '?');
+            const source = sourceOf(definition);
+            const has = (key) => definition[key] !== undefined && definition[key] !== null && definition[key] !== '';
+            const block = (message) => ({ ruleId: 'FN-005', severity: 'block', message, guide: functionsGuide });
+            if (source === 'workflow') {
+                const extras = ['applicationId', 'pageId', 'scope'].filter(has);
+                return extras.length === 0
+                    ? []
+                    : [block(`'${name}' source:'workflow' ama ${extras.join(', ')} verilmiş — workflow fonksiyonu TENANT genelidir, uygulamaya/kapsama/sayfaya bağlanmaz (platform 422 GlobalFunctionSourceWorkflowScopeForbidden). Alanları kaldırın; uygulamaya özel bir tarayıcı fonksiyonu istiyorsanız source:'studio'.`)];
+            }
+            if (!has('applicationId'))
+                return [block(`'${name}' source:'studio' ama applicationId yok — studio fonksiyonu bir uygulamaya aittir (platform 422). application_list ile uygulama id'sini verin; tenant geneli bir SUNUCU fonksiyonu istiyorsanız source:'workflow'.`)];
+            if (!has('scope'))
+                return [block(`'${name}' source:'studio' ama scope yok — 'application' (her sayfada) ya da 'page' (tek sayfa, pageId zorunlu) seçin (platform 422).`)];
+            if (definition.scope === 'page' && !has('pageId'))
+                return [block(`'${name}' scope:'page' ama pageId yok — platform 422 GlobalFunctionScopePageRequired verir; page_list ile sayfa id'sini alın.`)];
+            if (definition.scope === 'application' && has('pageId'))
+                return [block(`'${name}' scope:'application' fonksiyonda pageId verilmez — platform 422 GlobalFunctionScopeApplicationPageForbidden verir; sayfaya bağlamak istiyorsanız scope:'page'.`)];
+            return [];
+        }
+    },
+    {
+        id: 'FLOW-024',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'K9 + B-19: function adımında args.functionId zorunlu ve uygulamada var olmalı (CreateFlowCommandHandler ilk satırında 422 UiFunctionNotFound); tasks/function/function.ts önce id, sonra functionName ile çözer; parameters bildirim sırasına göre ada göre eşlenir',
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'function')
+            .flatMap(step => {
+            const args = (step.args ?? {});
+            const label = flowStepLabel(step);
+            const findings = [];
+            if (typeof args.functionId !== 'string' || !conditionRuleIdPattern.test(args.functionId)) {
+                findings.push({
+                    ruleId: 'FLOW-024',
+                    severity: 'block',
+                    message: `'${label}' function adımında args.functionId ${args.functionId === undefined || args.functionId === null ? 'yok' : `geçersiz ('${String(args.functionId)}')`} — platform 422 UiFunctionNotFound döner. Gerçek id'yi function_list ile alın; runtime fonksiyonu ÖNCE id ile çözer, functionName yalnız yedektir (K9).`,
+                    guide: functionsGuide
+                });
+            }
+            if (typeof args.functionName !== 'string' || args.functionName.trim() === '') {
+                findings.push({
+                    ruleId: 'FLOW-024',
+                    severity: 'warn',
+                    message: `'${label}' function adımında args.functionName boş — Studio adım özeti 'seçili fonksiyon yok' gösterir ve id çözülemezse ad yedeği de kalmaz. functionName: '<fonksiyon adı>' yazın.`,
+                    guide: functionsGuide
+                });
+            }
+            if (args.parameters !== undefined && args.parameters !== null && !Array.isArray(args.parameters)) {
+                findings.push({
+                    ruleId: 'FLOW-024',
+                    severity: 'block',
+                    message: `'${label}' function adımında args.parameters dizi değil (${typeof args.parameters}) — şekil: [{ name: '<bildirimdeki ad>', value: { type: 'static'|'property'|'storage'|'state'|'code'|'variable'|'page'|'item', ref } }].`,
+                    guide: functionsGuide
+                });
+            }
+            const nameless = asArray(args.parameters).filter(isRecord).filter(parameter => typeof parameter.name !== 'string' || parameter.name.trim() === '');
+            if (nameless.length > 0) {
+                findings.push({
+                    ruleId: 'FLOW-024',
+                    severity: 'block',
+                    message: `'${label}' function adımında ${nameless.length} parametrenin name'i yok — eşleme bildirimdeki ada göre yapılır, adsız parametre hiçbir argümana bağlanmaz.`,
+                    guide: functionsGuide
+                });
+            }
+            return findings;
+        })
+    },
+    {
+        id: 'WF-030',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "2026-09-10 kararı (Owner MR notu, zeyrek-backend docs/global-functions/02 §1): sunucu UI fonksiyonlarını YÜKLEMEZ — WorkflowContext'in 'Functions' ad alanı ve yükleme yolu kaldırıldı. Workflow/middleware/automation ifadesindeki Functions.<ad>(…) çağrısı Jint'te 'Functions is not defined' ile düşer (canlı ölçüldü: workflow_preview code adımı). Sunucuda paylaşılan hesap source:'workflow' fonksiyondur, çıplak adla çağrılır",
+        check: (definition, context) => {
+            const names = [...new Set(functionCallRefs(JSON.stringify(workflowBody(definition, context.workflowKind) ?? {})).map(ref => ref.name))];
+            return names.length === 0
+                ? []
+                : [{
+                        ruleId: 'WF-030',
+                        severity: 'block',
+                        message: `İfadeler ${names.map(name => `Functions.${name}(…)`).join(', ')} çağırıyor ama SUNUCUDA 'Functions' ad alanı YOKTUR (2026-09-10): motor kullanıcı fonksiyonlarını yüklemez, çağrı 'Functions is not defined' ile düşer ve adım hata yoluna girer. Sunucuda paylaşılan hesap source:'workflow' fonksiyondur — function_create source:'workflow' ile tanımlayıp ifadede çıplak adla çağırın ('${names[0]}(…)'). Kullanıcı fonksiyonları yalnız tarayıcıda çalışır ({{ }} bağlaması ve UI flow adımları).`,
+                        guide: functionsGuide
+                    }];
+        }
+    },
     {
         id: 'FLOW-005',
         module: 'flow',
@@ -1954,7 +2265,7 @@ export const policyRules = [
         id: 'FLOW-022',
         module: 'flow',
         appliesTo: ['create', 'update'],
-        sourceRef: "alert.ts `const { message, alertType, description } = task.argument` → toast.error(message, { description }) / dialog.alert(message); confirm.ts `dialog.confirm(task.argument.message)`. Argüman Runtime.svelte'de HAM geçer (`argument: step.args`) — bu alanlarda hiçbir ifade değerlendirilmez, yazılan metin ekranda harfi harfine görünür (2026-09-06·2 koşusu S-13'ün ikinci turu: rehber hata mesajını göstermek için alert adımını öneriyordu)",
+        sourceRef: "alert.ts `const { message, alertType, description } = task.argument` → toast.error(message, { description }) / dialog.alert(message); confirm.ts `dialog.confirm(message, { title, confirmText, cancelText })` (boş çerçeve metni dialog.functions.ts resolveDialogFrame'de sabit metne düşer). Argüman Runtime.svelte'de HAM geçer (`argument: step.args`) — bu alanlarda hiçbir ifade değerlendirilmez, yazılan metin ekranda harfi harfine görünür (2026-09-06·2 koşusu S-13'ün ikinci turu: rehber hata mesajını göstermek için alert adımını öneriyordu)",
         check: definition => flowAllSteps(definition)
             .flatMap((step) => {
             const type = String(step.type ?? '');
@@ -2479,3 +2790,139 @@ export const policyRules = [
     // tek liste `backendConstraints.ts`'te durur, buradan yalnız politika motoruna katılır.
     ...backendPolicyRules()
 ];
+/**
+ * WF-MF-001'in ikinci yarısı. Bir adımın koşup koşmayacağı yalnız GÖVDEDEN anlaşılamaz: karar
+ * seçilen microfunction'ın YAYIN DURUMUNA bağlıdır ve o durum platformda yaşar. Politika
+ * kuralları senkron ve saf olduğu için bu denetim ayrı durur — gateway `microfunction_get`
+ * ucunu okur, bulguyu aynı `policyFindings` kanalına koyar ve `policyOverride` / `POLICY=warn`
+ * kaçışları (applyPolicyMode) aynen geçerli kalır.
+ *
+ * Okuma başarısız olursa (ağ, yetki, beklenmeyen gövde) kural SUSAR: ön-denetim bir kolaylıktır,
+ * gateway'in kendi arızası yüzünden geçerli bir workflow yazılamaz hâle gelmemeli.
+ */
+export async function microfunctionStepFindings(platform, project, environment, definition, kind, policyOverride = false) {
+    if (platform.config.policyMode === 'off')
+        return [];
+    const steps = workflowSteps(workflowBody(definition, kind))
+        .filter(step => step.type === 'microfunction')
+        .filter(step => hasText((step.rule ?? {}).microfunctionId));
+    if (steps.length === 0)
+        return [];
+    const records = new Map();
+    const findings = [];
+    for (const step of steps) {
+        const rule = (step.rule ?? {});
+        const microfunctionId = String(rule.microfunctionId);
+        if (!records.has(microfunctionId)) {
+            try {
+                const payload = await platform.tenant('GET', project, `/microfunctions/${microfunctionId}`, { environment });
+                records.set(microfunctionId, (payload?.data ?? payload));
+            }
+            catch (error) {
+                records.set(microfunctionId, error instanceof PlatformApiError && error.status === 404 ? 'missing' : 'unreadable');
+            }
+        }
+        const record = records.get(microfunctionId);
+        if (record === undefined || record === 'unreadable')
+            continue;
+        if (record === 'missing') {
+            findings.push({
+                ruleId: 'WF-MF-001',
+                severity: 'block',
+                message: `'${stepLabel(step)}' adımının microfunctionId'si (${microfunctionId}) bu ortamda YOK. Adım kuralı step_rules.microfunction_id ile kayda FK'lıdır: gövde gitseydi platform 400 dönerdi. microfunction_list ile bu ortamdaki kayıtları görün — fonksiyon başka bir dalda/ortamda kalmış olabilir.`,
+                guide: 'ngapps://guides/microfunction'
+            });
+            continue;
+        }
+        const status = String(record.status ?? '');
+        if (status === 'draft' || status === 'publish-failed') {
+            findings.push({
+                ruleId: 'WF-MF-001',
+                severity: 'block',
+                message: `'${stepLabel(step)}' adımı '${String(record.name ?? microfunctionId)}' fonksiyonunu seçiyor ama kaydın durumu '${status}'${status === 'publish-failed' && hasText(record.publishError) ? ` (publishError: ${String(record.publishError)})` : ''}. Step YALNIZ yayındaki kaydı koşturur: MicrofunctionStep kaydı yükleyip Status != Published görünce MicrofunctionNotPublishedException ile FAIL dalına düşer — akış kurulur, kaydedilir ve koşumda sessizce hata yoluna girer. Önce microfunction_publish çağırın ve microfunction_get ile 'published' olduğunu görün.`,
+                guide: 'ngapps://guides/microfunction'
+            });
+            continue;
+        }
+        if (status === 'publishing') {
+            findings.push({
+                ruleId: 'WF-MF-001',
+                severity: 'warn',
+                message: `'${stepLabel(step)}' adımının fonksiyonu ('${String(record.name ?? microfunctionId)}') şu anda yayınlanıyor. Yayın ASENKRONDUR: bu akış şimdi koşarsa adım fail dalına düşer. microfunction_get ile 'published' olduğunu doğrulayın (yayın başarısız olursa durum 'publish-failed' olur).`,
+                guide: 'ngapps://guides/microfunction'
+            });
+        }
+        if (record.hasUnpublishedChanges === true) {
+            findings.push({
+                ruleId: 'WF-MF-001',
+                severity: 'warn',
+                message: `'${String(record.name ?? microfunctionId)}' fonksiyonu yayında ama üstüne yazılmış (hasUnpublishedChanges: true, revision ${String(record.revision ?? '?')} ≠ publishedRevision ${String(record.publishedRevision ?? '?')}). Runtime hâlâ ESKİ sürümü koşuyor — yeni kodu canlıya almak için microfunction_publish çağırın.`,
+                guide: 'ngapps://guides/microfunction'
+            });
+        }
+        if (!hasText(rule.expression) && hasText(record.parameterDtoId)) {
+            findings.push({
+                ruleId: 'WF-MF-001',
+                severity: 'warn',
+                message: `'${stepLabel(step)}' adımında rule.expression boş ama '${String(record.name ?? microfunctionId)}' fonksiyonunun bir parametre DTO'su var (parameterDtoId: ${String(record.parameterDtoId)}). Fonksiyon args olarak boş nesne alır ve kendi alanlarını undefined görür. Argümanları ifadeyle geçirin — şemayı microfunction_get çıktısındaki parameterScheme verir.`,
+                guide: 'ngapps://guides/microfunction'
+            });
+        }
+    }
+    return applyPolicyMode(platform.config, findings, policyOverride);
+}
+const partialWriteOperations = new Set(['create', 'update', 'upsert']);
+const inputReferencePattern = /\binput\.([A-Za-z_$][\w$]*)/g;
+function inputReferencesOf(rule) {
+    return asArray(rule.fields)
+        .filter((field) => Boolean(field) && typeof field === 'object')
+        .flatMap(field => [...String(field.value ?? '').matchAll(inputReferencePattern)].map(match => match[1]))
+        .filter((name) => typeof name === 'string');
+}
+/**
+ * WF-031 — yazma adımı, akışın giriş DTO'sunda OLMAYAN bir `input.x` alanını yazıyorsa uyarır.
+ * Böyle bir ifade çalışma anında `undefined` döner, `Parse` onu `null` yapar ve platform kolonu
+ * NULL yazar: satırdaki mevcut değer silinir, yanıt yine 200'dür (risk uygulaması Kanban taşıma
+ * bulgusu, 2026-09-15 — `{ id, status }` gövdesi `title`/`owner_id`/`due_date`'i sildi).
+ *
+ * Kural yalnız DTO'da HİÇ olmayan alanı sayar: "DTO'da var ama çağıran göndermedi" vakası
+ * tanımdan görülemez, onu rehber anlatır. DTO şeması okunamazsa (404/erişim) kural susar —
+ * bir okuma hatası yazma çağrısını engellememelidir.
+ */
+export async function undefinedInputFieldFindings(platform, project, environment, definition, kind, policyOverride = false) {
+    if (platform.config.policyMode === 'off')
+        return [];
+    const body = workflowBody(definition, kind);
+    if (!hasText(body.parameterDtoId))
+        return [];
+    const candidates = workflowSteps(body)
+        .filter(step => step.type === 'table' && step.rule)
+        .filter(step => partialWriteOperations.has(String(step.rule.operation ?? '').toLowerCase()))
+        .map(step => ({ step, references: [...new Set(inputReferencesOf(step.rule))] }))
+        .filter(candidate => candidate.references.length > 0);
+    if (candidates.length === 0)
+        return [];
+    let dtoFieldNames;
+    try {
+        const payload = await platform.tenant('GET', project, `/datatransferobjects/${String(body.parameterDtoId)}/scheme`, { environment });
+        const items = asArray(payload?.data ?? payload).filter((item) => Boolean(item) && typeof item === 'object');
+        dtoFieldNames = new Set(items.map(item => String(item.name ?? '')));
+    }
+    catch (error) {
+        if (error instanceof PlatformApiError)
+            return [];
+        throw error;
+    }
+    const findings = candidates.flatMap(({ step, references }) => {
+        const missing = references.filter(name => !dtoFieldNames.has(name));
+        return missing.length > 0
+            ? [{
+                    ruleId: 'WF-031',
+                    severity: 'warn',
+                    message: `'${stepLabel(step)}' adımı ${missing.map(name => `input.${name}`).join(', ')} alanlarını yazıyor ama akışın giriş DTO'sunda bu alanlar YOK: ifade undefined döner, platform kolonu NULL yazar ve satırdaki mevcut değer SİLİNİR (yanıt yine 200). Yazma adımında SET listesi fields[]'tir, gövde değil — 'göndermediğim alan değişmez' (REST PATCH) sezgisi burada geçmez. İki doğru çıkış: (1) adımı EYLEM BAŞINA daraltın, fields[] yalnız bu eylemin gerçekten yazdığı alanları listelesin (kanban taşıma: yalnız status); (2) alanı DTO'ya ekleyin VE çağıranın her istekte gönderdiğinden emin olun — DTO'ya eklemek yalnız izin verir, göndermeyi garanti etmez. Alan kümesi ancak çağrı anında belliyse akışta oku-birleştir: önce table get, sonra "typeof input.x !== 'undefined' && input.x !== null ? input.x : read_row.data.x" (bedeli fazladan okuma ve son-yazan-kazanır).`,
+                    guide: 'ngapps://guides/workflow'
+                }]
+            : [];
+    });
+    return applyPolicyMode(platform.config, findings, policyOverride);
+}

package/dist/knowledge/styleResolve.js

@@ -419,6 +419,12 @@ export const TYPED_STYLE_COMPONENTS = {
         // Taşma hedefi olmayan komponentte contentOverflow ölü kural üretirdi.
         omit: { surfaceStyle: ['contentOverflow'] }
     },
+    form: {
+        // Çerçeve <form> KÖKÜNDE: yüzey köke, taşma gövdeye (S-19, 2026-09-15).
+        // Genel düğüm yüzeyi yolu değeri kökün dışındaki kutuya yazıp ikinci çerçeve çiziyordu.
+        groups: ['surfaceStyle'],
+        ext: { overflowTarget: '&__body' }
+    },
     icon: {
         // Yalnız hover: surface çipin (chipShape/chipColor), typography da boyutun
         // (size) ve rengin (color) çift kanalı olurdu — görsel kararlar semantik
@@ -439,7 +445,6 @@ export const TYPED_STYLE_COMPONENTS = {
 export const NODE_SURFACE_TYPES = new Set([
     'table',
     'datatable',
-    'form',
     'collapsible-container',
     'drawer',
     'modal',